diff --git a/docs/solutions/build-errors/crowdin-translation-sanitizer-mdx-fence-bugs.md b/docs/solutions/build-errors/crowdin-translation-sanitizer-mdx-fence-bugs.md
new file mode 100644
index 00000000000..e00ccc2cd8c
--- /dev/null
+++ b/docs/solutions/build-errors/crowdin-translation-sanitizer-mdx-fence-bugs.md
@@ -0,0 +1,283 @@
+# Crowdin Translation Sanitizer: MDX Build Failures from Backslash Injection and Code Fence Drift
+
+> **Date:** 2026-02-27
+> **PR:** #17125 (French Crowdin import)
+> **Component:** post-import translation sanitizer (`src/scripts/i18n/post_import_sanitize.ts`)
+> **Problem type:** build-error, translation-artifact
+> **Languages affected:** fr (confirmed); potentially any Crowdin-imported language
+> **Severity:** Critical -- both patterns cause Netlify build failures (MDX compilation errors)
+> **Tags:** crowdin, sanitizer, mdx, build-error, code-fence, backslash, translation
+
+## Problem Symptom
+
+The Netlify build for PR #17125 (French translation import, ~300 files) failed with MDX compilation errors in three files:
+
+1. `public/content/translations/fr/ai-agents/index.md` -- "Unexpected character" at backslash before closing tag
+2. `public/content/translations/fr/restaking/index.md` -- same backslash pattern (2 occurrences)
+3. `public/content/translations/fr/developers/tutorials/reverse-engineering-a-contract/index.md` -- "Unexpected character `[`" from code fence boundaries being completely inverted
+
+These are two distinct Crowdin translation artifacts that both manifest as MDX compilation failures.
+
+## Root Cause Analysis
+
+### Pattern 12: Backslash Before Closing HTML Tag
+
+**What happens:** Crowdin's translation memory or post-processing inserts a backslash `\` immediately before closing HTML tags. This produces patterns like:
+
+```
+<strong>Bon a savoir\</strong>
+```
+
+The backslash is not valid in MDX/JSX context and causes the MDX compiler to choke.
+
+**Why it happens:** Crowdin's TM system treats `</` as a potential escape sequence boundary and inserts a backslash as a "protective" escape. This is a known Crowdin artifact that appears inconsistently across languages.
+
+**Affected tags:** Any closing HTML tag -- `</strong>`, `</em>`, `</a>`, `</p>`, and even JSX fragment closers `</>`.
+
+**Real-world occurrences found in FR import:**
+- `fr/ai-agents/index.md` line 67: `<strong>Bon a savoir\</strong>`
+- `fr/restaking/index.md` lines 42, 99: same pattern
+- `fr/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md` line 146: `\</>`
+
+### Pattern 13: Catastrophic Code Fence Drift
+
+**What happens:** Crowdin completely scrambles the boundaries between code fences and prose in translation files containing significant code blocks. The result is:
+
+- Code that should be inside fences ends up as raw MDX prose (causing compilation errors)
+- Prose/comments that should be outside fences get absorbed into code blocks
+- Heading lines (`## Title {#anchor-id}`) get merged into adjacent prose paragraphs
+- Anchor IDs (`{#custom-id}`) become detached from their heading lines
+
+**Why it happens:** Crowdin's segmentation algorithm treats code fence markers (`` ``` ``) as segment boundaries. When translating, it can reassemble segments with fence markers in wrong positions. Files with many interleaved code/prose sections (like tutorials) are especially vulnerable.
+
+**Scale of damage in FR import:** In `reverse-engineering-a-contract/index.md`, approximately 165 lines (581-746) were structurally destroyed:
+- 22 code fence markers displaced
+- Multiple headings absorbed into prose paragraphs
+- Python decompiler output exposed as raw MDX
+- Anchor IDs detached from heading lines
+
+## Investigation Steps Tried
+
+1. **Direct inspection** -- Read the affected French files and compared against English sources line-by-line
+2. **Pattern identification** -- Found the backslash pattern was consistent and regex-matchable; the code fence drift was structural and not auto-fixable
+3. **English source comparison** -- Confirmed English sources had correct structure; damage was purely from Crowdin processing
+4. **Cross-file check** -- Searched all FR files for both patterns to determine full scope
+
+## Working Solution
+
+### Fix 1: `fixBackslashBeforeClosingTag` (Deterministic Auto-Fix)
+
+Added to `src/scripts/i18n/post_import_sanitize.ts` at line 1625:
+
+```typescript
+function fixBackslashBeforeClosingTag(content: string): {
+  content: string
+  fixCount: number
+} {
+  let fixCount = 0
+
+  // Split content to preserve code blocks (fenced and inline)
+  const codeBlockPattern = /(```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`]+`)/g
+  const parts = content.split(codeBlockPattern)
+
+  for (let i = 0; i < parts.length; i++) {
+    if (i % 2 === 1) continue // Skip code blocks
+
+    // Match backslash immediately before </ (closing HTML tag) or </>
+    parts[i] = parts[i].replace(/\\(<\/[a-zA-Z]*>)/g, (_match, tag) => {
+      fixCount++
+      return tag
+    })
+  }
+
+  return { content: parts.join(""), fixCount }
+}
+```
+
+**Wired into pipeline:** Placed before `removeOrphanedClosingTags` in `processMarkdownFile` via `applyFix`.
+
+**Regex explanation:** `\\(<\/[a-zA-Z]*>)` matches a literal backslash followed by `</` + optional tag name + `>`. The capture group preserves the valid closing tag while discarding the backslash.
+
+### Fix 2: `warnCatastrophicCodeFenceDrift` (Detection + Warning)
+
+Added to `src/scripts/i18n/post_import_sanitize.ts` at line 497. This is a warning-only function because the damage is too structural to auto-fix -- it requires LLM-assisted reconstruction.
+
+The function performs three checks:
+
+1. **Prose-in-fences:** Compares each translated fence body against its English counterpart. If English has 3+ lines with code keywords but translated has <=2 lines with no code keywords, flags it.
+
+2. **Code-outside-fences:** Scans prose sections (outside fences) for programming keywords (`def `, `class `, `if `, `return `, `require `, etc.). If 3+ keyword occurrences found outside fences, flags catastrophic inversion.
+
+3. **Detached anchor IDs:** Checks that `{#anchor-id}` patterns only appear on heading lines (starting with `#`). Detached anchors indicate heading absorption.
+
+### Manual Reconstruction for Pattern 13
+
+The `reverse-engineering-a-contract/index.md` file required full manual reconstruction of lines 581-746 using the English structural skeleton with French prose reinserted. This was done by an agent that:
+
+1. Used the English source as the structural template (fence positions, headings, anchor IDs)
+2. Extracted translatable prose from the mangled French file
+3. Rebuilt the file maintaining English code blocks verbatim
+4. Verified: 22 fence markers balanced, all anchor IDs on heading lines
+
+## Tests Added
+
+### Standalone Fix Tests (`tests/unit/sanitizer/standalone-fixes.spec.ts`)
+
+7 new tests for `fixBackslashBeforeClosingTag`:
+
+| Test | Description |
+|------|-------------|
+| fixes backslash before closing strong tag | `\</strong>` -> `</strong>` |
+| fixes backslash before closing em tag | `\</em>` -> `</em>` |
+| fixes backslash before closing a tag | `\</a>` -> `</a>` |
+| fixes multiple occurrences in one string | 2 fixes in single content block |
+| leaves correct closing tags unchanged | No false positives on valid HTML |
+| does not modify content inside code blocks | Preserves `\</strong>` inside backticks |
+| fixes JSX fragment closer | `\</>` -> `</>` |
+
+### Warning Tests (`tests/unit/sanitizer/warnings.spec.ts`)
+
+5 new tests for `warnCatastrophicCodeFenceDrift`:
+
+| Test | Description |
+|------|-------------|
+| detects prose inside code fences | Prose replacing code triggers warning |
+| detects code keywords outside fences | `def`, `return`, etc. in prose triggers warning |
+| no warning on correctly structured files | Clean content produces no warnings |
+| detects detached heading anchors | `{#id}` not on `##` line triggers warning |
+| no false positive on properly anchored headings | Correct `## Heading {#id}` produces no warning |
+
+**Test results:** All 111 sanitizer tests pass (56 standalone + 22 warnings + 33 other).
+
+## Prevention Strategies
+
+### Short-term
+
+1. **Sanitizer pipeline catches Pattern 12 automatically** -- The `fixBackslashBeforeClosingTag` function runs on every Crowdin import, catching all occurrences without manual intervention.
+
+2. **Sanitizer warns on Pattern 13** -- The `warnCatastrophicCodeFenceDrift` function flags files with structural damage so they can be routed to LLM review.
+
+### Medium-term
+
+3. **Pre-import Crowdin configuration** -- Investigate Crowdin's "Code" content type settings to prevent code fence boundaries from being treated as translatable segments.
+
+4. **Expand code keyword detection** -- Add language-specific keywords (Solidity: `pragma`, `mapping`, `event`; JavaScript: `const`, `function`, `async`) to improve detection sensitivity.
+
+5. **Automated LLM reconstruction pipeline** -- When catastrophic drift is detected, automatically invoke an LLM agent to reconstruct the file from English structure + translated prose, similar to the manual process used here.
+
+### Long-term
+
+6. **Crowdin segment locking** -- Work with Crowdin to lock code fence markers and their contents as non-translatable segments, preventing the drift at source.
+
+7. **Structural hash comparison** -- Generate a structural hash (fence positions, heading levels, anchor IDs) for English source files and compare against translated files post-import to catch any structural divergence.
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| `src/scripts/i18n/post_import_sanitize.ts` | Added `fixBackslashBeforeClosingTag` (line 1625) and `warnCatastrophicCodeFenceDrift` (line 497); wired both into pipeline; added to `_testOnly` export |
+| `tests/unit/sanitizer/standalone-fixes.spec.ts` | 7 new tests for backslash fix |
+| `tests/unit/sanitizer/warnings.spec.ts` | 5 new tests for catastrophic drift detection |
+| `docs/solutions/integration-issues/sanitizer-test-research.md` | Added patterns 12 and 13 to catalog; moved both to "handled" list |
+| `public/content/translations/fr/ai-agents/index.md` | Fixed `\</strong>` at line 67 |
+| `public/content/translations/fr/restaking/index.md` | Fixed `\</strong>` at lines 42 and 99 |
+| `public/content/translations/fr/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md` | Fixed `\</>` at line 146 |
+| `public/content/translations/fr/developers/tutorials/reverse-engineering-a-contract/index.md` | Full structural reconstruction of lines 581-746 |
+
+---
+
+## Part 2: Follow-Up Build Failures (Patterns 14-15)
+
+> **Date:** 2026-02-27 (same session, second build attempt)
+
+After the Part 1 fixes were pushed and built, two more MDX compilation errors surfaced in the same PR.
+
+### Pattern 14: Translated Word After Bare `<` Breaks MDX Tag Parsing
+
+**Symptom:** `Unexpected character [ (U+005B) in name` on `/fr/developers/tutorials/reverse-engineering-a-contract`
+
+**Root cause:** English has `\<Storage[4]` in markdown tables (opcode stack notation). Crowdin translated "Storage" to "Stockage" AND dropped the backslash escape, producing `<Stockage[4]`. MDX tries to parse `<Stockage` as a component tag, then chokes on `[`.
+
+The existing `restoreDroppedBackslashEscapes` function only matches exact follower text from English. Since `Stockage[4]` != `Storage[4]`, the bare `<` went undetected.
+
+**Fix:** Extended `escapeMdxAngleBrackets` with a new rule:
+
+```typescript
+// Escape < before word containing [ (e.g., <Stockage[4]) -- never valid MDX
+parts[i] = parts[i].replace(/(?<!\\)<([a-zA-Z]+\[)/g, (_, after) => {
+  fixCount++
+  return `\\<${after}`
+})
+```
+
+The pattern `<Word[` is never valid MDX/HTML syntax, so this is safe to escape unconditionally.
+
+### Pattern 15: `fixBackslashBeforeClosingTag` Too Broad -- Strips `\</>`
+
+**Symptom:** `Unexpected closing slash / in tag` on `/fr/developers/tutorials/creating-a-wagmi-ui-for-your-contract`
+
+**Root cause:** The Pattern 12 fix (from Part 1) used regex `[a-zA-Z]*` (zero or more letters), which matched `\</>` -- a JSX fragment with an empty tag name. Stripping the backslash exposed bare `</>` to the MDX parser.
+
+The `\</>` was actually a legitimate escape (placed by `escapeMdxAngleBrackets`) protecting a bare `</>` that sat outside inline code backticks due to a Crowdin backtick misplacement.
+
+**Fix:** Changed quantifier from `*` to `+`:
+
+```typescript
+// Requires at least one letter in tag name -- leaves \</> (JSX fragment) intact
+parts[i] = parts[i].replace(/\\(<\/[a-zA-Z]+>)/g, (_, tag) => {
+```
+
+**Cascading effect:** Once `\</>` was preserved, the existing `repairUnclosedBackticks` function could detect the real problem (odd backtick count on line 146) and fix the misplaced backtick: `` (`<> ...` </>`) `` became `` (`<> ... </>`) ``.
+
+### Key Lesson: Sanitizer Function Interaction
+
+This was a cascading failure:
+1. `fixBackslashBeforeClosingTag` (Pattern 12 fix) stripped `\</>` -- unmasking a bare `</>` in prose
+2. That bare `</>` was actually the symptom of a deeper problem: a misplaced backtick
+3. `repairUnclosedBackticks` could have fixed the backtick, but only if the escapes were intact
+4. Narrowing the regex (Pattern 15 fix) preserved `\</>`, letting `repairUnclosedBackticks` do its job
+
+**Takeaway:** Sanitizer functions form a pipeline. Earlier functions that strip escapes can mask problems that later functions would fix. Each function should only strip escapes it's certain about -- use `+` not `*`, enumerate known tag names, and test with JSX fragments.
+
+### Tests Added (Part 2)
+
+6 new tests in `standalone-fixes.spec.ts`:
+
+| Test | Description |
+|------|-------------|
+| does NOT strip backslash from JSX fragment `\</>` | Verifies `[a-zA-Z]+` excludes empty tag names |
+| escapes bare `<` before word containing `[` | `<Stockage[4]` -> `\<Stockage[4]` |
+| escapes multiple bare `<` before `word[` patterns | 2 occurrences in one string |
+| leaves already-escaped `\<Word[` unchanged | No double-escaping |
+| skips `<Word[` inside code blocks | Preserves code fence content |
+| does not escape valid MDX component tags | `<Card>` left alone |
+
+**Test results:** All 116 sanitizer tests pass (61 standalone + 22 warnings + 33 other).
+
+### Additional Files Changed (Part 2)
+
+| File | Change |
+|------|--------|
+| `src/scripts/i18n/post_import_sanitize.ts` | Extended `escapeMdxAngleBrackets` (+1 rule); narrowed `fixBackslashBeforeClosingTag` (`*` -> `+`) |
+| `tests/unit/sanitizer/standalone-fixes.spec.ts` | 6 new tests |
+| `docs/solutions/integration-issues/sanitizer-test-research.md` | Added patterns 14 and 15 |
+| `public/content/translations/fr/.../reverse-engineering-a-contract/index.md` | `<Stockage[4]` escaped (lines 472-473) |
+| `public/content/translations/fr/.../creating-a-wagmi-ui-for-your-contract/index.md` | Backtick fixed (line 146) |
+
+### Prevention: Regex Safety Rules for Sanitizer Functions
+
+1. **Use `+` not `*`** when matching tag names -- empty matches cause unintended stripping
+2. **Test with JSX fragments** (`<>`, `</>`) as edge cases for any HTML tag regex
+3. **Test idempotency** -- `sanitize(sanitize(x))` should equal `sanitize(x)`
+4. **Test function composition** -- run functions in sequence and verify escapes survive
+5. **Run `npx tsc --noEmit`** before pushing -- catches unused variables the test runner misses
+
+## Cross-References
+
+- [Sanitizer Test Research: Pattern Catalog](../integration-issues/sanitizer-test-research.md) -- Patterns 12-15
+- [Post-Import Sanitizer Bugs Found During Japanese Review](../integration-issues/post-import-sanitizer-bugs-found-japanese-review.md) -- Prior sanitizer bug documentation
+- [Crowdin Import Review Agent Calibration](../integration-issues/crowdin-import-review-agent-calibration.md) -- Agent calibration for translation reviews
+- [Crowdin File Path Mapping and Review Workflow](../integration-issues/crowdin-file-path-mapping-and-review-workflow.md) -- Full review pipeline documentation
+- [French Import Review](../integration-issues/crowdin-french-import-review-pr-17125.md) -- Comprehensive FR import context
+- PR #17125 -- French Crowdin import (source of these bugs)
+- PR #17654 -- Sanitizer test infrastructure (where test framework was established)
diff --git a/docs/solutions/integration-issues/crowdin-french-import-review-pr-17125.md b/docs/solutions/integration-issues/crowdin-french-import-review-pr-17125.md
new file mode 100644
index 00000000000..0fd3e4817df
--- /dev/null
+++ b/docs/solutions/integration-issues/crowdin-french-import-review-pr-17125.md
@@ -0,0 +1,488 @@
+---
+title: "French Crowdin Translation Import: Critical Issues in 300-File Batch"
+date: "2026-02-26"
+category: "integration-issues"
+tags:
+  - crowdin
+  - i18n
+  - french-translation
+  - sanitizer
+  - quality-assurance
+  - unit-tests
+severity: "high"
+component:
+  - "i18n translation pipeline"
+  - "Crowdin integration"
+  - "sanitizer scripts"
+symptoms:
+  - "Semantic inversions in domain-specific terminology (trusted/trustless)"
+  - "Translated YAML frontmatter toId values breaking in-page navigation"
+  - "Translated internal href paths breaking routing"
+  - "Garbled numeric identifiers (ERC-7575 -> ERC-75757)"
+  - "Untranslated content blocks in otherwise-French files"
+  - "Broken HTML tags across markdown and JSON files"
+  - "35 critical issues across 17 of 300 files (207 markdown + 93 JSON)"
+root_cause: "Crowdin's aggressive translation strategy translates protected fields and identifiers that must remain in English; lack of pre-import validation for frontmatter, hrefs, and numeric patterns"
+resolution_time: "~4 hours (worktree setup, sanitizer run, 12-agent parallel review, auto-fix, scoring, PR posting)"
+files_affected: 17
+pre_fix_score: "7.1/10"
+post_fix_score: "8.7/10"
+related:
+  - docs/solutions/integration-issues/crowdin-import-review-turkish-pr-17182.md
+  - docs/solutions/integration-issues/crowdin-import-review-japanese-pr-17132.md
+  - docs/solutions/integration-issues/crowdin-import-review-czech-pr-17547.md
+  - docs/solutions/integration-issues/crowdin-import-review-agent-calibration.md
+---
+
+# French Crowdin Translation Import: Pitfalls, Fixes, and Sanitizer Enhancements
+
+**PR:** #17125
+**Language:** French (fr)
+**Scope:** 300 files (207 markdown + 93 JSON)
+**Date:** 2026-02-26
+
+## Overview
+
+This documents the full review of PR #17125, a French Crowdin translation import for ethereum.org. The review pipeline -- worktree setup, sanitizer run, 12 parallel AI review agents, auto-fix, and scoring -- uncovered 35 critical issues across 17 files. Every pitfall encountered is cataloged below, alongside the fix applied, whether the sanitizer script could handle the fix deterministically, and proposed unit tests for each deterministic case.
+
+## Pipeline Pitfalls
+
+### Pitfall 1: Merge Conflict in Translation JSON
+
+**File:** `src/intl/fr/page-developers-tutorials.json`
+
+**Problem:** Conflict between PR branch and dev branch. Dev had a newer translation ("Reinitialiser les filtres") plus 5 additional keys not in the PR.
+
+**Fix:** Kept dev's translation value and merged the 5 new keys from PR manually.
+
+**Sanitizer handling:** Not automatable. Merge conflicts require human judgment about which translation is authoritative.
+
+---
+
+### Pitfall 2: Sanitizer Argument Parsing
+
+**Problem:** `npx tsx sanitize-pr.ts --pr=17125` failed. The script expects a positional argument, not a named flag.
+
+**Fix:** `npx tsx sanitize-pr.ts 17125`
+
+**Sanitizer enhancement:** Accept both `--pr=N` and positional `N`, or emit a clear error.
+
+```ts
+// Proposed test
+it("should parse both flag and positional forms", () => {
+  expect(parseArgs(["--pr=17125"]).pr).toBe(17125)
+  expect(parseArgs(["17125"]).pr).toBe(17125)
+})
+```
+
+---
+
+### Pitfall 3: Rate Limiting on Parallel Agent Launch
+
+**Problem:** All 12 Opus agents launched simultaneously; 11 hit API rate limits and failed.
+
+**Fix:** Waited for reset, relaunched all 11 successfully.
+
+**Lesson:** Stagger agent launches (2-3 per minute) or use lower-tier models for some agents. This is a process issue, not a sanitizer issue.
+
+---
+
+### Pitfall 4: Agent False Positives on Translated Tags
+
+**Problem:** One agent flagged translated concept tags (e.g., "contrats intelligents") as errors.
+
+**Fix:** No file change needed. Per policy, concept/category tags ARE intentionally translated by Crowdin; only brand-name tags must stay English.
+
+**Lesson:** Review agent prompts must explicitly distinguish brand-name tags (must stay English) from concept tags (translation is correct).
+
+---
+
+## Terminology Fixes (Deterministic -- Sanitizer Could Handle)
+
+### Pitfall 5: Acronym Transposition -- EMV -> EVM
+
+**File:** `developers/docs/evm/opcodes/index.md` (title)
+
+**Problem:** "EVM" rendered as "EMV" -- letter transposition.
+
+**Pattern:** Common in Crowdin output. Known variants: EMV, EHT, BSL, ECDAS.
+
+**Sanitizer enhancement:** Expand `TICKER_CORRECTIONS` map with acronym transpositions.
+
+```ts
+describe("fixAcronymTypos", () => {
+  it("should fix EMV -> EVM", () => {
+    expect(fixAcronymTypos("Opcodes pour l'EMV")).toBe("Opcodes pour l'EVM")
+  })
+  it("should fix EHT -> ETH", () => {
+    expect(fixAcronymTypos("Send EHT to wallet")).toBe("Send ETH to wallet")
+  })
+  it("should not fix inside backticks", () => {
+    expect(fixAcronymTypos("Use `EMV` in code")).toBe("Use `EMV` in code")
+  })
+})
+```
+
+---
+
+### Pitfall 6: Proper Noun Phonetic Translation -- Ce Age -> Ice Age
+
+**File:** `ethereum-forks/index.md`
+
+**Problem:** "Ice Age" (Ethereum historical event) rendered as "Ce Age" -- phonetic approximation.
+
+**Sanitizer enhancement:** Dictionary of Ethereum proper nouns that must remain in English.
+
+```ts
+describe("preserveProperNouns", () => {
+  it("should fix Ce Age -> Ice Age", () => {
+    expect(preserveProperNouns("repousser l'Ce Age")).toBe("repousser l'Ice Age")
+  })
+  it("should preserve already-correct terms", () => {
+    expect(preserveProperNouns("l'Ice Age")).toBe("l'Ice Age")
+  })
+})
+```
+
+---
+
+### Pitfall 7: ERC Number Digit Duplication -- ERC-75757 -> ERC-7575
+
+**File:** `developers/docs/standards/tokens/erc-4626/index.md`
+
+**Problem:** "ERC-7575" rendered as "ERC-75757" -- digit duplication during translation.
+
+**Sanitizer enhancement:** Compare ERC/EIP numbers against English source; flag any mismatch.
+
+```ts
+describe("fixERCNumbers", () => {
+  it("should fix digit duplication", () => {
+    expect(fixERCNumbers("ERC-75757", enSource)).toBe("ERC-7575")
+  })
+  it("should fix prefix truncation RC-20 -> ERC-20", () => {
+    expect(fixERCNumbers("RC-20", enSource)).toBe("ERC-20")
+  })
+  it("should preserve correct numbers", () => {
+    expect(fixERCNumbers("ERC-20", enSource)).toBe("ERC-20")
+  })
+})
+```
+
+---
+
+### Pitfall 8: ERC Prefix Truncation -- RC-20 -> ERC-20
+
+**File:** `staking/pools/index.md`
+
+**Problem:** "ERC-20" rendered as "RC-20" -- leading "E" dropped.
+
+**Sanitizer enhancement:** Regex `\bRC-\d+\b` to catch truncated ERC references.
+
+```ts
+it("should restore truncated ERC prefix", () => {
+  expect(fixERCPrefix("jetons RC-20")).toBe("jetons ERC-20")
+})
+```
+
+---
+
+### Pitfall 9: Code Identifier Translated -- faut() -> foo()
+
+**File:** `developers/docs/standards/tokens/erc-223/index.md`
+
+**Problem:** Placeholder `foo()` translated to French word `faut()` ("must").
+
+**Sanitizer enhancement:** Extract inline code identifiers, compare against English source, revert mismatches that match target-language dictionary words.
+
+```ts
+describe("preserveCodeIdentifiers", () => {
+  it("should fix faut() -> foo()", () => {
+    expect(preserveCodeIdentifiers("`faut()`", enSource)).toBe("`foo()`")
+  })
+  it("should preserve correct identifiers", () => {
+    expect(preserveCodeIdentifiers("`getBalance()`", enSource)).toBe("`getBalance()`")
+  })
+})
+```
+
+**Note:** Semi-deterministic. Requires source comparison + dictionary lookup.
+
+---
+
+## Structural Fixes (Deterministic -- Sanitizer Could Handle)
+
+### Pitfall 10: Double-Escaped HTML Entity -- `\&lt;` -> `\<`
+
+**File:** `developers/docs/networking-layer/portal-network/index.md`
+
+**Problem:** `\&lt;` where `\<` expected. Double-escaping: HTML entity introduced during translation combined with existing backslash.
+
+**Sanitizer enhancement:** Regex `\\&lt;` -> `\\<` and `\\&gt;` -> `\\>`.
+
+```ts
+describe("fixDoubleEscape", () => {
+  it("should fix \\&lt; -> \\<", () => {
+    expect(fixDoubleEscape("\\&lt;1 Go de RAM")).toBe("\\<1 Go de RAM")
+  })
+  it("should not touch bare entities", () => {
+    expect(fixDoubleEscape("&lt;div&gt;")).toBe("&lt;div&gt;")
+  })
+})
+```
+
+---
+
+### Pitfall 11: HTML Attribute Spacing -- `href = "url"` -> `href="url"`
+
+**File:** `restaking/index.md`
+
+**Problem:** Spaces inserted around `=` in HTML attributes, breaking link rendering.
+
+**Sanitizer enhancement:** Regex to normalize `(\w+)\s+=\s+"` -> `$1="` within HTML tags.
+
+```ts
+describe("normalizeHrefSpacing", () => {
+  it("should remove spaces around = in attributes", () => {
+    expect(normalizeHrefSpacing('href = "https://example.com"')).toBe('href="https://example.com"')
+  })
+  it("should not modify non-HTML context", () => {
+    expect(normalizeHrefSpacing("x = y + 2")).toBe("x = y + 2")
+  })
+})
+```
+
+---
+
+### Pitfall 12: Translated Internal Hrefs -- `/staking/retraits/` -> `/staking/withdrawals/`
+
+**Files:** `staking/solo/index.md`, `ethereum-forks/index.md`, `roadmap/merge/index.md`
+
+**Problem:** Internal paths translated. Routes are always English; translated paths yield 404s.
+
+**Sanitizer enhancement:** Extract all internal hrefs (starting with `/`), compare against English source, revert translated ones.
+
+```ts
+describe("revertTranslatedHrefs", () => {
+  it("should restore translated path", () => {
+    expect(revertTranslatedHrefs("/staking/retraits/", enSource)).toBe("/staking/withdrawals/")
+  })
+  it("should not modify external URLs", () => {
+    expect(revertTranslatedHrefs("https://external.com/fr/", enSource)).toBe("https://external.com/fr/")
+  })
+  it("should not modify already-correct paths", () => {
+    expect(revertTranslatedHrefs("/staking/withdrawals/", enSource)).toBe("/staking/withdrawals/")
+  })
+})
+```
+
+---
+
+### Pitfall 13: Translated toId Anchors in YAML Frontmatter
+
+**Files:** `ai-agents/index.md`, `restaking/index.md`, `prediction-markets/index.md`
+
+**Problem:** YAML `toId` values translated (e.g., `que-sont-les-agents-ia`) but heading anchors use English IDs (`{#what-are-ai-agents}`). Breaks in-page navigation buttons.
+
+**Sanitizer enhancement:** Parse frontmatter `toId` values, match against `{#anchor}` patterns in English source headings, auto-sync.
+
+```ts
+describe("matchToIdToAnchors", () => {
+  it("should restore translated toId to English anchor", () => {
+    const fr = { toId: "que-sont-les-agents-ia" }
+    const enAnchors = ["what-are-ai-agents", "ai-agents-on-ethereum"]
+    expect(matchToIdToAnchors(fr, enAnchors).toId).toBe("what-are-ai-agents")
+  })
+  it("should not modify already-correct toId", () => {
+    const fr = { toId: "what-are-ai-agents" }
+    const enAnchors = ["what-are-ai-agents"]
+    expect(matchToIdToAnchors(fr, enAnchors).toId).toBe("what-are-ai-agents")
+  })
+})
+```
+
+---
+
+### Pitfall 14: Displaced `</strong>` Closing Tag in JSON
+
+**File:** `src/intl/fr/page-roadmap.json`
+
+**Problem:** `</strong>` tag moved to wrong position in string, wrapping unintended text. EN source has `...do anything** to secure their assets.</strong>` but FR had `</strong>` after "Les opérateurs de" (next sentence).
+
+**Sanitizer enhancement:** Compare HTML tag positions between EN and FR JSON values; flag structural mismatches.
+
+```ts
+describe("fixDisplacedTags", () => {
+  it("should detect tag count mismatch", () => {
+    const en = "<strong>text</strong> more"
+    const fr = "<strong>text more</strong> extra"
+    expect(detectTagMismatch(fr, en)).toBe(true)
+  })
+  it("should pass when tags match", () => {
+    const en = "<strong>text</strong>"
+    const fr = "<strong>texte</strong>"
+    expect(detectTagMismatch(fr, en)).toBe(false)
+  })
+})
+```
+
+---
+
+## Semantic Fixes (Non-Deterministic -- Requires AI Judgment)
+
+### Pitfall 15: Trusted/Trustless Bridge Semantic Inversion
+
+**File:** `bridges/index.md`
+
+**Problem:** "trusted" translated as "sans risque" (risk-free) and "trustless" as "risque" (risky). Completely inverted: in Ethereum bridge terminology, a "trusted" bridge requires trust assumptions (more risk), while "trustless" minimizes trust (less risk).
+
+**Fix:** Replaced with "de confiance" (trusted) / "sans confiance" (trustless) throughout 5 instances in the file.
+
+**Sanitizer handling:** Cannot be fully automated. Domain-specific semantic inversions require understanding context. A glossary of high-stakes term pairs could flag for human review:
+
+```
+trusted -> de confiance  (NOT "sans risque", NOT "fiable")
+trustless -> sans confiance  (NOT "risque", NOT "non fiable")
+```
+
+---
+
+### Pitfall 16: Anonyme vs. Pseudonyme
+
+**File:** `defi/index.md`
+
+**Problem:** "pseudonymous" translated as "anonyme" (anonymous). Distinct privacy concepts: pseudonymous = identity obscured via pseudonym but traceable; anonymous = no identifying information exists.
+
+**Fix:** Replaced "anonyme" with "pseudonyme".
+
+**Sanitizer handling:** Partially automatable via glossary lookup. A known-bad-translation dictionary could flag "anonyme" where English source says "pseudonymous".
+
+---
+
+## Content Patches (Mixed Automatability)
+
+### Pitfall 17: Multiple Paragraphs Left in English
+
+**File:** `community/events/organizing/index.md`
+
+**Problem:** 5+ paragraphs left entirely in English in an otherwise French-translated file.
+
+**Fix:** Replaced with fully translated version from commit `2cb992ef`.
+
+**Sanitizer enhancement:** `franc-min` language detection (already partially implemented) should flag paragraphs whose detected language is English within a French-locale file.
+
+```ts
+describe("detectWrongLanguage", () => {
+  it("should flag English paragraph in French file", () => {
+    expect(detectWrongLanguage(
+      "This is a completely untranslated English paragraph.",
+      "fr"
+    )).toBe(true)
+  })
+  it("should pass French paragraph", () => {
+    expect(detectWrongLanguage(
+      "Ceci est un paragraphe en francais avec du contenu.",
+      "fr"
+    )).toBe(false)
+  })
+})
+```
+
+---
+
+### Pitfall 18: Dev Branch Had Superior Translation
+
+**File:** `contributing/index.md`
+
+**Problem:** Dev branch contained a better translation than Crowdin imported.
+
+**Fix:** Patched from dev branch version.
+
+**Sanitizer handling:** Not automatable. Determining which of two valid translations is "better" requires human judgment.
+
+---
+
+### Pitfall 19: Untranslated JSON String
+
+**File:** `src/intl/fr/page-staking.json`
+
+**Problem:** "Deposit 32 ETH and generate your keys with assistance" left in English.
+
+**Sanitizer enhancement:** Compare FR and EN JSON values; flag identical strings exceeding a length threshold (e.g., 20 characters), excluding brand names, URLs, and code.
+
+```ts
+describe("detectUntranslated", () => {
+  it("should flag identical long strings", () => {
+    expect(detectUntranslated(
+      "Deposit 32 ETH and generate your keys with assistance",
+      "Deposit 32 ETH and generate your keys with assistance"
+    )).toBe(true)
+  })
+  it("should skip short brand strings", () => {
+    expect(detectUntranslated("ETH", "ETH")).toBe(false)
+  })
+  it("should skip URLs", () => {
+    expect(detectUntranslated(
+      "https://ethereum.org/staking",
+      "https://ethereum.org/staking"
+    )).toBe(false)
+  })
+})
+```
+
+---
+
+## Summary Table
+
+| # | Issue | Deterministic? | Sanitizer Can Fix? | Has Unit Test? |
+|---|-------|:-:|:-:|:-:|
+| 1 | Merge conflict | No | No | N/A |
+| 2 | Arg parsing | Yes | Yes (script fix) | Yes |
+| 3 | Rate limiting | N/A | Process fix | N/A |
+| 4 | False positive tags | No | Prompt fix | N/A |
+| 5 | EMV -> EVM | Yes | Yes | Yes |
+| 6 | Ce Age -> Ice Age | Yes | Yes | Yes |
+| 7 | ERC-75757 -> ERC-7575 | Yes | Yes (needs source) | Yes |
+| 8 | RC-20 -> ERC-20 | Yes | Yes | Yes |
+| 9 | faut() -> foo() | Partial | Partial (needs source + dict) | Yes |
+| 10 | `\&lt;` -> `\<` | Yes | Yes | Yes |
+| 11 | `href = "url"` spacing | Yes | Yes | Yes |
+| 12 | Translated internal hrefs | Yes | Yes (needs source) | Yes |
+| 13 | Translated toId anchors | Yes | Yes (needs source) | Yes |
+| 14 | Displaced `</strong>` | Yes | Yes (needs source) | Yes |
+| 15 | Trusted/trustless inversion | No | No (glossary can flag) | N/A |
+| 16 | anonyme vs pseudonyme | No | Partial (glossary) | N/A |
+| 17 | Paragraphs left in English | Partial | Partial (franc-min) | Yes |
+| 18 | Dev vs Crowdin quality | No | No | N/A |
+| 19 | Untranslated JSON string | Yes | Yes (length threshold) | Yes |
+
+**Key finding:** 11 of 19 pitfalls are fully deterministic and could be caught by enhanced sanitizer scripts. 3 more are partially automatable. Only 5 require human or AI judgment.
+
+## Sanitizer Enhancement Priority
+
+Based on impact and implementation simplicity:
+
+1. **High priority (simple regex, high impact):**
+   - Translated internal hrefs (Pitfall 12) -- 404 errors on live site
+   - Translated toId anchors (Pitfall 13) -- broken navigation
+   - ERC/EIP number validation (Pitfalls 7-8) -- factual errors
+   - Double HTML entity escaping (Pitfall 10) -- MDX build failures
+
+2. **Medium priority (needs source comparison):**
+   - Displaced HTML tags in JSON (Pitfall 14)
+   - Untranslated string detection (Pitfall 19)
+   - HTML attribute spacing (Pitfall 11)
+
+3. **Lower priority (needs dictionary/glossary):**
+   - Code identifier translation (Pitfall 9)
+   - Proper noun preservation (Pitfall 6)
+   - Acronym transposition (Pitfall 5) -- partially implemented already
+
+## Cross-References
+
+- **Turkish review (PR #17182):** First comprehensive Crowdin import review establishing the baseline issue catalog
+- **Japanese review (PR #17132):** Exposed 5 bugs in `post_import_sanitize.ts`, led to Phase 1 sanitizer fixes
+- **Czech review (PR #17547):** Sanitizer crash on orphaned Crowdin paths; translation staleness patterns
+- **Agent calibration (PR #17553):** False positive calibration for brand vs concept tags, functional code vs comments
+- **Sanitizer source:** `src/scripts/i18n/post_import_sanitize.ts`
+- **Sanitizer roadmap:** `src/scripts/i18n/docs/v0.2.0-roadmap.md` (planned glossary validation)
+- **Knowledge base:** `~/.claude/translation-review/known-patterns.md` (11 patterns), `per-language/fr.md`
diff --git a/docs/solutions/integration-issues/sanitizer-test-research.md b/docs/solutions/integration-issues/sanitizer-test-research.md
index 2ef75c1291c..82ebfaa2c97 100644
--- a/docs/solutions/integration-issues/sanitizer-test-research.md
+++ b/docs/solutions/integration-issues/sanitizer-test-research.md
@@ -19,6 +19,10 @@
 | 9 | Simplified Chinese contamination in zh-tw | zh-tw #17544 | `着` (simplified) instead of `著` (traditional) | Medium — wrong variant |
 | 10 | "Gas" translated as "Sprit" (gasoline) in German | de #17389 | 31 replacements needed across files | Medium — semantic error |
 | 11 | Dropped glossary links during translation | ur #17467 | Entire `<a href>` tag removed, only text remains | High — loses links |
+| 12 | Backslash before closing HTML tag | fr #17125 | `<strong>Bon à savoir\</strong>` — backslash inserted before `</` | Critical — breaks MDX compilation |
+| 13 | Code fence drift — comments inside fence, code outside | fr #17125 | Crowdin puts translated comment inside `` ```python `` fence, leaves actual Python code as raw MDX | Critical — breaks MDX compilation |
+| 14 | Translated word after bare `<` breaks MDX tag parsing | fr #17125 | `<Stockage[4]` — Crowdin translates `Storage` to `Stockage` but drops `\` escape before `<` | Critical — breaks MDX compilation |
+| 15 | `fixBackslashBeforeClosingTag` too broad — strips `\</>` | fr #17125 | `\</>` in prose is a legitimate escape; stripping `\` exposes bare `</>` to MDX | Critical — breaks MDX compilation |
 
 ## Patterns Already Handled by Sanitizer (Confirmed Working)
 
@@ -42,6 +46,8 @@ These patterns are covered by existing fix functions and should have regression
 - **Code fence drift** (`warnCodeFenceContentDrift`)
 - **Backslash escape restoration** (`restoreDroppedBackslashEscapes`)
 - **Unclosed backtick repair** (`repairUnclosedBackticks`)
+- **Backslash before closing tag** (`fixBackslashBeforeClosingTag`) — `\</strong>` → `</strong>`
+- **Catastrophic code fence drift detection** (`warnCatastrophicCodeFenceDrift`) — prose/code boundaries swapped
 
 ## Recommendations for Future Sanitizer Iteration
 
diff --git a/public/content/translations/fr/about/index.md b/public/content/translations/fr/about/index.md
index ba6219d23c7..ed30929409d 100644
--- a/public/content/translations/fr/about/index.md
+++ b/public/content/translations/fr/about/index.md
@@ -1,6 +1,6 @@
 ---
-title: À propos de nous
-description: À propos de l'équipe, de la communauté et de la mission d'ethereum.org
+title: "À propos de nous"
+description: "À propos de l'équipe, de la communauté et de la mission d'ethereum.org"
 lang: fr
 ---
 
@@ -26,9 +26,9 @@ Ethereum est un réseau public, une blockchain et un protocole open source - mis
 
 Ether (également connu sous son symbole téléscripteur ETH) est la monnaie native transactionnelle utilisée sur Ethereum. De l'Ether est requis pour payer les frais inhérents à l'utilisation du réseau Ethereum (sous forme de frais de transaction). L'Ether (ETH) permet également de sécuriser le réseau à travers la mise en jeu. Les gens parlent du prix de l'Ethereum, en référence à son actif l'Ether (ETH).
 
-[En savoir plus sur ETH](/what-is-ether/)
+[En savoir plus sur l'ETH](/what-is-ether/)
 
-[Plus d'infos sur la mise en jeu ETH](/staking/)
+[En savoir plus sur la mise en jeu d'ETH](/staking/)
 
 ### Ethereum Foundation {#ethereum-foundation}
 
@@ -44,7 +44,7 @@ Cette page contient davantage d'informations sur ethereum.org.
 
 ## Notre mission {#our-mission}
 
-**La mission d'ethereum.org est d'être le meilleur portail possible pour la communauté en plein essor d'Ethereum.**
+**La mission d'ethereum.org est d'être le meilleur portail pour la communauté grandissante d'Ethereum**
 
 Nous nous efforçons de construire une ressource éducative facile à comprendre pour tous les sujets relatifs à Ethereum, conçue pour aider les nouveaux utilisateurs à se familiariser avec Ethereum et ses principaux concepts. Nous souhaitons :
 
@@ -57,7 +57,7 @@ Nous nous efforçons de construire une ressource éducative facile à comprendre
 
 Pour mener à bien cette mission, notre équipe se concentre sur deux objectifs principaux sur ethereum.org :
 
-### 1. Optimiser l'expérience utilisateur pour les visiteurs d'ethereum.org {#visitors}
+### 1. Améliorer l'expérience utilisateur pour les visiteurs d'ethereum.org {#visitors}
 
 - Élargir et améliorer le contenu tout en le maintenant à jour
 - Améliorer la convivialité et l'accessibilité grâce à la localisation et aux bonnes pratiques de développement Web
@@ -78,39 +78,44 @@ Certains principes fondamentaux nous guident dans l'accomplissement de notre mis
 
 ### 1. ethereum.org est un portail vers Ethereum 🌏 {#core-principles-1}
 
-Nous voulons susciter l'intérêt de nos utilisateurs et répondre à leurs questions. Notre portail doit donc proposer des informations, des "moments magiques" ainsi que des liens vers les excellentes ressources communautaires disponibles. Notre objectif, en matière de contenu, est d'être un "portail d’intégration" et non un substitut aux vastes ressources qui existent déjà. Nous tenons à soutenir et à intégrer les ressources créées par la communauté en leur donnant plus de visibilité et en facilitant leur découverte. [La communauté Ethereum](/community/) est au cœur de cette démarche : nous ne devons pas uniquement servir la communauté, nous devons travailler avec ses membres et intégrer leurs commentaires. Le site Web n'est pas seulement destiné à la communauté actuelle, mais aussi à celle que nous espérons développer. Nous devons nous rappeler que notre communauté est mondiale, constituée de personnes parlant différentes langues, provenant de différentes régions et possédant différentes cultures.
+Nous voulons susciter l'intérêt de nos utilisateurs et répondre à leurs questions. Notre portail doit donc proposer des informations, des "moments magiques" ainsi que des liens vers les excellentes ressources communautaires disponibles. Notre objectif, en matière de contenu, est d'être un "portail d’intégration" et non un substitut aux vastes ressources qui existent déjà. Nous tenons à soutenir et à intégrer les ressources créées par la communauté en leur donnant plus de visibilité et en facilitant leur découverte.
+La [communauté d'Ethereum](/community/) est au cœur de cette démarche : nous ne devons pas seulement servir la communauté, mais aussi travailler avec elle et intégrer ses commentaires. Le site Web n'est pas seulement destiné à la communauté actuelle, mais aussi à celle que nous espérons développer. Nous devons nous rappeler que notre communauté est mondiale, constituée de personnes parlant différentes langues, provenant de différentes régions et possédant différentes cultures.
 
 ### 2. ethereum.org est en constante évolution 🛠 {#core-principles-2}
 
-Ethereum et la communauté étant en constante évolution, ethereum.org l'est aussi. Voilà pourquoi l'apparence et la structure du site sont simples. Nous procédons régulièrement à des modifications à mesure que nous comprenons la façon dont les gens utilisent le site et ce que la communauté en attend. Nous fonctionnons en open source, et disposons d'une communauté de contributeurs. Vous pouvez donc proposer des changements ou nous aider. [ En savoir plus sur les contributions](/contributing/)
+Ethereum et la communauté étant en constante évolution, ethereum.org l'est aussi. C'est pourquoi le site dispose d'un système de conception simple et d'une structure modulaire. Nous procédons régulièrement à des modifications à mesure que nous comprenons la façon dont les gens utilisent le site et ce que la communauté en attend.
+Nous fonctionnons en open source, et disposons d'une communauté de contributeurs. Vous pouvez donc proposer des changements ou nous aider.
+[Découvrez comment contribuer](/contributing/)
 
-### 3. ethereum.org n'est pas un site de produits classique🦄 {#core-principles-3}
+### 3. ethereum.org n'est pas un site web de produit typique 🦄 {#core-principles-3}
 
-Ethereum est un vaste concept : il s'agit d'une communauté, d'une technologie, d'un ensemble d'idées et d'idéologies, et de bien d'autres choses encore. Cela signifie que le site web doit gérer de nombreux parcours d'utilisateurs différents, qu'il s'agisse d'un "développeur qui souhaite un outil spécifique" ou d'un "nouvel arrivant qui vient d'acheter de l'ETH et ne sait pas ce qu'est un portefeuille". "Quel est le meilleur site web pour une plateforme blockchain ?" reste une question ouverte. Nous sommes des pionniers. Pour construire un tel écosystème, il faut expérimenter.
+Ethereum est un vaste concept : il s'agit d'une communauté, d'une technologie, d'un ensemble d'idées et d'idéologies, et de bien d'autres choses encore.
+Cela signifie que le site web doit gérer de nombreux parcours d'utilisateurs différents, qu'il s'agisse d'un "développeur qui souhaite un outil spécifique" ou d'un "nouvel arrivant qui vient d'acheter de l'ETH et ne sait pas ce qu'est un portefeuille".
+"Quel est le meilleur site web pour une plateforme blockchain ?" reste une question ouverte. Nous sommes des pionniers. Pour construire un tel écosystème, il faut expérimenter.
 
 ## Feuille de route du produit {#roadmap}
 
-Afin de rendre notre travail plus accessible et de favoriser davantage la collaboration de la communauté, l'équipe principale de ethereum.org publie un aperçu des objectifs de notre feuille de route trimestrielle.
+Afin de rendre notre travail plus accessible et de favoriser une plus grande collaboration de la communauté, l'équipe principale d'ethereum.org publie un aperçu des objectifs de notre feuille de route du [cycle Shape Up](https://www.productplan.com/glossary/shape-up-method/).
 
-[Voir notre feuille de route du troisième trimestre 2024](https://github.com/ethereum/ethereum-org-website/issues/13399)
+[Consulter notre feuille de route produit du cycle 1 de 2025](https://github.com/ethereum/ethereum-org-website/issues/14726)
 
-**Comment avez-vous trouvé cela ?** Nous nous réjouissons toujours de recevoir des feedbacks sur notre feuille de route - Y a-t-il encore des choses auxquelles nous devrions travailler ? N'hésitez pas à nous le faire savoir ! Nous accueillons avec plaisir les idées et les RP de n'importe quel membre de la communauté.
+**Qu'en pensez-vous ?** Nous apprécions toujours les retours sur notre feuille de route. S'il y a quelque chose sur lequel vous pensez que nous devrions travailler, n'hésitez pas à nous le faire savoir ! Nous accueillons avec plaisir les idées et les RP de n'importe quel membre de la communauté.
 
-**Vous voulez vous impliquer ? ** [En savoir plus sur les contributions](/contributing/), [nous contacter sur Twitter](https://twitter.com/ethdotorg), ou rejoindre les discussions de la communauté sur [notre serveur Discord](https://discord.gg/ethereum-org).
+**Vous souhaitez participer ?** [En savoir plus sur la contribution](/contributing/), [contactez-nous sur Twitter](https://x.com/ethdotorg) ou rejoignez les discussions de la communauté sur [notre serveur Discord](https://discord.gg/ethereum-org).
 
 ## Principes de conception {#design-principles}
 
 Nous utilisons un ensemble de [principes de conception](/contributing/design-principles/) pour guider nos décisions en matière de contenu et de conception sur le site.
 
-## Architecture du système {#design-system}
+## Système de conception {#design-system}
 
-Nous avons construit et publié un [système de conception](https://www.figma.com/file/NrNxGjBL0Yl1PrNrOT8G2B/ethereum.org-Design-System?node-id=0%3A1&t=QBt9RkhpPqzE3Aa6-1) pour livrer plus rapidement des fonctionnalités et permettre aux membres de la communauté de participer à la conception ouverte de ethereum.org.
+Nous avons créé et publié un [système de conception](https://www.figma.com/file/NrNxGjBL0Yl1PrNrOT8G2B/ethereum.org-Design-System?node-id=0%3A1&t=QBt9RkhpPqzE3Aa6-1) pour déployer des fonctionnalités plus rapidement et permettre aux membres de la communauté de participer à la conception ouverte d'ethereum.org.
 
-Vous voulez vous impliquer ?[Suivez le projet dans Figma](https://www.figma.com/file/NrNxGjBL0Yl1PrNrOT8G2B/ethereum.org-Design-System), les [tickets GitHub](https://github.com/ethereum/ethereum-org-website/issues/6284) et rejoignez la conversation dans notre [canal Discord #design](https://discord.gg/ethereum-org).
+Vous souhaitez participer ?[Suivez le projet sur Figma](https://www.figma.com/file/NrNxGjBL0Yl1PrNrOT8G2B/ethereum.org-Design-System), le [ticket GitHub](https://github.com/ethereum/ethereum-org-website/issues/6284) et rejoignez la conversation sur notre [canal Discord #design](https://discord.gg/ethereum-org).
 
 ## Guide de style {#style-guide}
 
-Nous nous appuyons sur un [guide de style](/contributing/style-guide/) pour standardiser certains aspects de l'écriture de contenu et ainsi faciliter le processus de contribution.
+Nous avons un [guide de style](/contributing/style-guide/) pour standardiser certains aspects de la rédaction de contenu afin de faciliter le processus de contribution.
 
 Assurez-vous de lire [nos principes](/contributing/design-principles/) et [notre guide de style](/contributing/style-guide/) si vous souhaitez [contribuer au site](/contributing/).
 
@@ -118,12 +123,12 @@ Nous apprécions les commentaires sur nos principes de conception, notre systèm
 
 ## Licence {#license}
 
-Le site ethereum.org est open source et construit sous [Licence MIT](https://github.com/ethereum/ethereum-org-website/blob/dev/LICENSE) sauf indication contraire. En savoir plus sur les [conditions d'utilisation](/terms-of-use/) d'ethereum.org.
+Le site web ethereum.org est open source et publié sous une [licence MIT](https://github.com/ethereum/ethereum-org-website/blob/dev/LICENSE), sauf indication contraire. En savoir plus sur les [conditions d'utilisation](/terms-of-use/) d'ethereum.org.
 
-## Offres d'emploi {#open-jobs}
+## Postes à pourvoir {#open-jobs}
 
 Bien que ce site soit open source et que tout le monde puisse y travailler, nous disposons d'une équipe dédiée à ethereum.org et à d'autres projets web de l'Ethereum Foundation.
 
-Nous publierons les offres d'emploi ici. Si vous ne trouvez pas de poste qui vous corresponde, rendez-vous sur [notre serveur Discord,](https://discord.gg/ethereum-org) et faites-nous savoir comment vous souhaiteriez travailler avec nous !
+Nous publierons les offres d'emploi ici. Si vous ne trouvez pas de poste qui vous corresponde, rendez-vous sur [notre serveur Discord](https://discord.gg/ethereum-org) et faites-nous savoir comment vous souhaiteriez travailler avec nous !
 
-Vous cherchez un poste en dehors de l'équipe ethereum.org ? [Découvrez d'autres emplois liés à Ethereum](/community/get-involved/#ethereum-jobs/).
+Vous cherchez un poste en dehors de l'équipe ethereum.org ? [Consultez d'autres offres d'emploi liées à Ethereum](/community/get-involved/#ethereum-jobs/).
diff --git a/public/content/translations/fr/ai-agents/index.md b/public/content/translations/fr/ai-agents/index.md
new file mode 100644
index 00000000000..911c7a90f35
--- /dev/null
+++ b/public/content/translations/fr/ai-agents/index.md
@@ -0,0 +1,100 @@
+---
+title: Agents IA
+metaTitle: Agents IA | Agents IA sur Ethereum
+description: "Un aperçu des agents IA sur Ethereum"
+lang: fr
+template: use-cases
+emoji: ":robot:"
+sidebarDepth: 2
+image: /images/ai-agents/hero-image.png
+alt: "Des gens rassemblés autour d'un panneau de terminal"
+summaryPoint1: "IA qui interagit avec la blockchain et effectue des transactions de manière autonome"
+summaryPoint2: "Contrôle des portefeuilles et des fonds sur la blockchain"
+summaryPoint3: Embauche des humains ou d'autres agents pour travailler
+buttons:
+  - content: Que sont les agents IA ?
+    toId: what-are-ai-agents
+  - content: Explorer les agents
+    toId: ai-agents-on-ethereum
+    isSecondary: false
+---
+
+Imaginez naviguer sur Ethereum avec un assistant IA qui étudie les tendances du marché sur la blockchain 24h/24, répond aux questions et exécute même des transactions en votre nom. Bienvenue dans le monde des agents IA — des systèmes intelligents conçus pour simplifier votre vie numérique.
+
+Sur Ethereum, nous assistons à des innovations d’agents IA allant des influenceurs virtuels et créateurs de contenu autonomes aux plateformes d’analyse de marché en temps réel, offrant aux utilisateurs des informations, du divertissement et une efficacité opérationnelle.
+
+## Que sont les agents IA ? {#what-are-ai-agents}
+
+Les agents IA sont des programmes logiciels qui utilisent l’intelligence artificielle pour effectuer des tâches ou prendre leurs propres décisions. Ils apprennent à partir des données, s’adaptent aux changements et gèrent des tâches complexes. Ils fonctionnent en continu et peuvent détecter instantanément des opportunités.
+
+### Comment les agents IA fonctionnent avec les blockchains {#how-ai-agents-work-with-blockchains}
+
+Dans la finance traditionnelle, les agents IA opèrent souvent dans des environnements centralisés avec des entrées de données limitées. Cela limite leur capacité à apprendre ou à gérer des actifs de manière autonome.
+
+En revanche, l’écosystème décentralisé d’Ethereum offre plusieurs avantages clés :
+
+- <strong>Données transparentes :</strong> Accès aux informations de la blockchain en temps réel.
+- <strong>Véritable propriété des actifs :</strong> Les actifs numériques sont entièrement détenus par les agents IA.
+- <strong>Fonctionnalité onchain robuste :</strong> Permet aux agents IA d’exécuter des transactions, d’interagir avec des contrats intelligents, de fournir de la liquidité et de collaborer entre protocoles.
+
+Ces facteurs transforment les agents IA de simples bots en systèmes dynamiques et auto-améliorants qui apportent une valeur significative dans de nombreux secteurs :
+
+<CardGrid>
+  <Card title="DeFi automatisée" emoji=":money_with_wings:" description="Les agents IA surveillent les tendances du marché, exécutent des transactions et gèrent les portefeuilles, rendant le monde complexe de la DeFi bien plus accessible."/>
+  <Card title="Nouvelle économie d'agents IA" emoji="🌎" description="Les agents IA peuvent engager d'autres agents (ou humains) dotés de compétences différentes pour accomplir des tâches spécialisées." />
+  <Card title="Gestion des risques" emoji="🛠️" description="En surveillant les activités transactionnelles, les agents IA peuvent aider à repérer les arnaques et à protéger vos actifs numériques plus rapidement et plus efficacement." />
+</CardGrid>
+
+## Agents IA sur Ethereum {#ai-agents-on-ethereum}
+
+Nous commençons à explorer tout le potentiel des agents IA, et des projets tirent déjà parti de la synergie entre l’IA et la blockchain — notamment en matière de transparence et de monétisation.
+
+<AiAgentProductLists list="ai-agents" />
+
+<strong>Première apparition de Luna en tant qu'invitée de podcast</strong>
+
+<YouTube id="ZCsOMxnIruA" />
+
+## Portefeuilles contrôlés par des agents {#agent-controlled-wallets}
+
+Des agents comme Luna ou AIXBT contrôlent leur propre portefeuille onchain ([portefeuille d’AIXBT](https://clusters.xyz/aixbt), [portefeuille de Luna](https://zapper.xyz/account/0x0d177181e3763b20d47dc3a72dd584368bd8bf43)), ce qui leur permet de donner des pourboires à leurs fans et de participer à des activités économiques.
+
+Lors de la campagne sociale #LunaMuralChallenge sur X, Luna a sélectionné et récompensé les gagnants via son portefeuille Base — marquant <strong>la première instance d’une IA embauchant des humains contre une récompense en crypto</strong>.
+
+<Alert variant="warning">
+<AlertEmoji text="💡"/>
+<AlertContent>
+<p className="mt-0"><strong>Bon à savoir</strong></p>
+<p className="mt-2">Les agents IA et les outils associés sont encore en phase de développement précoce et très expérimentaux — à utiliser avec prudence.</p>
+</AlertContent>
+
+</Alert>
+
+## Contrôlez votre portefeuille à l’aide de commandes de chat {#control-your-wallet-using-chat-commands}
+
+Vous pouvez passer outre les interfaces complexes de la DeFi et gérer votre crypto avec de simples commandes de chat.
+
+Cette approche intuitive rend les transactions plus rapides, plus simples et moins sujettes aux erreurs comme l’envoi de fonds à une mauvaise adresse ou le paiement excessif de frais.
+
+<AiAgentProductLists list="chat" />
+
+## Agents IA vs Bots IA {#ai-agents-vs-ai-bots}
+
+La distinction entre les agents IA et les bots IA peut parfois prêter à confusion, car tous deux exécutent des actions automatisées en fonction d’entrées.
+
+- Les bots IA sont comme des assistants automatisés — Ils suivent des instructions spécifiques et préprogrammées pour effectuer des tâches routinières.
+- Les agents IA sont plutôt comme des compagnons intelligents — Ils tirent des leçons de l’expérience, s’adaptent aux nouvelles informations et prennent des décisions par eux-mêmes.
+
+|                         | Agents IA                                                                               | IA bots                                                      |
+| ----------------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| **Interactions**        | Complexes, adaptables, autonomes                                                        | Simples, périmètre prédéfini, codés en dur                   |
+| **Apprentissage**       | Apprend en continu, peut expérimenter et s’adapter à de nouvelles données en temps réel | Fonctionne sur des données préentraînées ou des règles fixes |
+| **Exécution de tâches** | Vise à atteindre des objectifs plus larges                                              | Se concentre uniquement sur des tâches spécifiques           |
+
+## Approfondir {#dive-deeper}
+
+<AiAgentProductLists list="dive-deeper" />
+
+## Vous pouvez créer votre propre agent IA {#you-can-build-your-own-ai-agent}
+
+<BuildYourOwnAIAgent />
\ No newline at end of file
diff --git a/public/content/translations/fr/bridges/index.md b/public/content/translations/fr/bridges/index.md
index bfda9e3f18a..6276a2fdf5c 100644
--- a/public/content/translations/fr/bridges/index.md
+++ b/public/content/translations/fr/bridges/index.md
@@ -1,12 +1,12 @@
 ---
 title: Introduction aux ponts de blockchain
-description: Les ponts permettent aux utilisateurs de déplacer leurs fonds à travers différentes blockchains
+description: "Les ponts permettent aux utilisateurs de déplacer leurs fonds à travers différentes blockchains"
 lang: fr
 ---
 
-# Ponts de connexion blockchain {#prerequisites}
+# Ponts de blockchain {#prerequisites}
 
-_Le Web3 a évolué en un écosystème de solutions blockchain L1 et de mise à l'échelle L2, chacune ayant des avantages et des inconvénients. À mesure qu'augmente le nombre de protocoles blockchain, la demande de déplacement d'actifs entre les chaînes augmente aussi. Pour répondre à cette demande, nous avons besoin de ponts._
+_Le Web3 a évolué en un écosystème de solutions blockchain L1 et de mise à l'échelle L2, chacune ayant des avantages et des inconvénients. À mesure qu'augmente le nombre de protocoles blockchain, la demande de déplacement d'actifs entre les chaînes augmente aussi.Pour répondre à cette demande, nous avons besoin de ponts._
 
 <Divider />
 
@@ -18,32 +18,32 @@ Prenons un exemple :
 
 Vous êtes originaire des États-Unis et vous prévoyez un voyage en Europe. Vous avez des dollars américains, mais vous avez besoin d'euros à dépenser. Pour échanger vos dollars américains contre des euros, vous pouvez utiliser un échangeur de devises moyennant de faibles frais.
 
-Mais, que feriez-vous si vous vouliez faire le même échange pour utiliser une [blockchain](/glossary/#blockchain) différente ? Disons que vous voulez échanger des [ETH](/glossary/#ether) du réseau principal Ethereum contre des ETH d'[Arbitrum](https://arbitrum.io/). À l'instar de l'échange de devises que nous avons effectué pour les euros, nous avons besoin d'un mécanisme pour transférer nos ETH d'Ethereum vers Arbitrum. Les ponts permettent de telles transactions. Dans ce cas, [Arbitrum a un pont natif](https://bridge.arbitrum.io/) qui peut transférer des ETH du Mainnet vers Arbitrum.
+Mais, que faites-vous si vous voulez effectuer un échange similaire pour utiliser une [blockchain](/glossary/#blockchain) différente ? Disons que vous voulez échanger des [ETH](/glossary/#ether) sur le réseau principal Ethereum contre des ETH sur [Arbitrum](https://arbitrum.io/). À l'instar de l'échange de devises que nous avons effectué pour les euros, nous avons besoin d'un mécanisme pour transférer nos ETH d'Ethereum vers Arbitrum. Les ponts permettent de telles transactions. Dans ce cas, [Arbitrum dispose d'un pont natif](https://portal.arbitrum.io/bridge) qui peut transférer des ETH du réseau principal vers Arbitrum.
 
 ## Pourquoi avons-nous besoin de ponts ? {#why-do-we-need-bridges}
 
-Toutes les blockchains ont leurs limites. Pour qu'Ethereum puisse évoluer et répondre à la demande, il a fallu procéder à des [rollups](/glossary/#rollups). Alternativement, des L1 comme Solana ou Avalanche sont conçues différemment pour permettre un débit plus élevé mais au prix de la décentralisation.
+Toutes les blockchains ont leurs limites. Pour qu'Ethereum puisse évoluer et répondre à la demande, il a fallu des [rollups](/glossary/#rollups). Alternativement, des L1 comme Solana ou Avalanche sont conçues différemment pour permettre un débit plus élevé mais au prix de la décentralisation.
 
-Cependant, toutes les blockchains se développent dans des environnements isolés et possèdent des règles et des mécanismes de [consensus](/glossary/#consensus) différents. Cela signifie qu'elles ne peuvent pas communiquer de manière native et que les jetons ne peuvent pas circuler librement entre les blockchains.
+Cependant, toutes les blockchains sont développées dans des environnements isolés et ont des règles et des mécanismes de [consensus](/glossary/#consensus) différents. Cela signifie qu'elles ne peuvent pas communiquer de manière native et que les jetons ne peuvent pas circuler librement entre les blockchains.
 
 Les ponts existent pour connecter les blockchains, permettant le transfert d'informations et de jetons entre elles.
 
-**Les ponts permettent** :
+Les ponts permettent :
 
 - le transfert inter-chaînes d'actifs et d'informations.
-- aux [dapps](/glossary/#dapp) d'accéder aux forces de différentes blockchains, renforçant leurs capacités (les protocoles disposant désormais de plus d'espace de conception pour l'innovation).
+- aux [dapps](/glossary/#dapp) d'accéder aux points forts de diverses blockchains, améliorant ainsi leurs capacités (car les protocoles disposent désormais de plus d'espace de conception pour l'innovation).
 - aux utilisateurs d'accéder à de nouvelles plateformes et de tirer parti des avantages de différentes chaînes.
 - aux développeurs de différents écosystèmes de blockchain de collaborer et de créer de nouvelles plateformes pour les utilisateurs.
 
-[Comment transférer des jetons aux réseaux de secondes couches](/guides/how-to-use-a-bridge/)
+[Comment ponter des jetons vers la couche 2](/guides/how-to-use-a-bridge/)
 
 <Divider />
 
-## Exemple d'utilisation d'un pont {#bridge-use-cases}
+## Cas d'utilisation des ponts {#bridge-use-cases}
 
 Voici quelques scénarios où vous pouvez utiliser un pont :
 
-### Des frais de transactions moins élevés {#transaction-fees}
+### Frais de transaction plus bas {#transaction-fees}
 
 Disons que vous avez de l'ETH sur le réseau principal Ethereum mais que vous voulez des frais de transaction moins élevés pour explorer différentes dapps. En transférant votre ETH du réseau principal à un rollup L2 d'Ethereum, vous pouvez bénéficier de frais de transaction moins élevés.
 
@@ -51,19 +51,19 @@ Disons que vous avez de l'ETH sur le réseau principal Ethereum mais que vous vo
 
 Si vous utilisez Aave sur le réseau principal Ethereum pour prêter des USDT mais que le taux d'intérêt pour prêter des USDT en utilisant Aave sur Polygon est plus élevé.
 
-### Explorer les écosystèmes blockchain {#explore-ecosystems}
+### Explorer les écosystèmes de blockchain {#explore-ecosystems}
 
 Si vous avez des ETH sur le réseau principal Ethereum et que vous voulez explorer un L1 alternatif pour essayer leurs dapps natives. Vous pouvez utilisez un pont pour transférer vos ETH du réseau principal Ethereum vers le L1.
 
-### Posséder des actifs crypto natifs {#own-native}
+### Posséder des actifs de cryptomonnaie natifs {#own-native}
 
-Disons que vous voulez posséder des bitcoins (BTC) natifs, mais que vous n'avez des fonds que sur le réseau principal Ethereum. Pour vous exposer aux BTC sur Ethereum, vous pouvez acheter des Wrapped Bitcoin (WBTC). Cependant, le WBTC est un jeton [ERC-20](/glossary/#erc-20) natif du réseau Ethereum, ce qui signifie qu'il s'agit d'une version Ethereum de Bitcoin et non de l'actif original sur la blockchain Bitcoin. Pour posséder des BTC natifs, vous devez basculer vos actifs d'Ethereum à Bitcoin en utilisant un pont. Cela permettra de relier votre WBTC et de le convertir en BTC natif. Alternativement, vous pouvez également posséder des BTC et vouloir les utiliser dans les protocoles [DeFi](/glossary/#defi) d'Ethereum. Pour cela, il faudrait faire le pont dans l'autre sens, de BTC à WBTC, qui peut ensuite être utilisé comme actif sur Ethereum.
+Disons que vous voulez posséder des bitcoins (BTC) natifs, mais que vous n'avez des fonds que sur le réseau principal Ethereum. Pour vous exposer aux BTC sur Ethereum, vous pouvez acheter des Wrapped Bitcoin (WBTC). Cependant, le WBTC est un jeton [ERC-20](/glossary/#erc-20) natif du réseau Ethereum, ce qui signifie qu'il s'agit d'une version Ethereum de Bitcoin et non de l'actif original sur la blockchain Bitcoin. Pour posséder des BTC natifs, vous devez basculer vos actifs d'Ethereum à Bitcoin en utilisant un pont. Cela permettra de relier votre WBTC et de le convertir en BTC natif. Alternativement, vous pouvez posséder des BTC et vouloir les utiliser dans des protocoles [DeFi](/glossary/#defi) Ethereum. Pour cela, il faudrait faire le pont dans l'autre sens, de BTC à WBTC, qui peut ensuite être utilisé comme actif sur Ethereum.
 
 <Alert variant="update">
 <AlertEmoji text=":bulb:"/>
 <AlertContent>
 <AlertDescription>
-  Vous pouvez également faire tout ce qui précède en utilisant un [échange centralisé](/get-eth/). Cependant, à moins que vos fonds ne soient déjà mêlés à un échange, cela impliquerait plusieurs étapes et il serait probablement préférable d'utiliser un pont.
+  Vous pouvez également faire tout ce qui précède en utilisant un [échange centralisé](/get-eth). Cependant, à moins que vos fonds ne soient déjà mêlés à un échange, cela impliquerait plusieurs étapes et il serait probablement préférable d'utiliser un pont.
 </AlertDescription>
 </AlertContent>
 </Alert>
@@ -72,18 +72,18 @@ Disons que vous voulez posséder des bitcoins (BTC) natifs, mais que vous n'avez
 
 ## Types de ponts {#types-of-bridge}
 
-Les ponts présentent de nombreux types de conceptions et de subtilités. En général, les ponts se divisent en deux catégories : les ponts sans risque et les ponts risqués.
+Les ponts présentent de nombreux types de conceptions et de subtilités. En général, les ponts se divisent en deux catégories : les ponts de confiance et les ponts sans confiance.
 
-| Ponts sans risque                                                                                                                                                                             | Ponts risqués                                                                                                                                     |
-| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Le fonctionnement des ponts sans risque repose sur une entité ou un système central pour leur fonctionnement.                                                                                 | Le fonctionnement des ponts risqués repose sur des contrats intelligents et des algorithmes.                                                      |
-| Ces ponts sont associés à des hypothèses de confiance en ce qui concerne la garde des fonds et la sécurité du pont. Les utilisateurs se fient surtout à la réputation de l'opérateur du pont. | Ils sont risqués, c'est-à-dire que la sécurité du pont est la même que celle de la blockchain sous-jacente.                                       |
-| Les utilisateurs doivent renoncer au contrôle de leurs crypto-actifs.                                                                                                                         | Grâce aux [contrats intelligents](/glossary/#smart-contract), les ponts risqués permettent aux utilisateurs de garder le contrôle de leurs fonds. |
+| Ponts de confiance                                                                                                                                                                                                             | Ponts sans confiance                                                                                                                                                            |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Le fonctionnement des ponts de confiance repose sur une entité ou un système central pour leur fonctionnement.                                                                                                 | Le fonctionnement des ponts sans confiance repose sur des contrats intelligents et des algorithmes.                                                             |
+| Ces ponts sont associés à des hypothèses de confiance en ce qui concerne la garde des fonds et la sécurité du pont. Les utilisateurs se fient surtout à la réputation de l'opérateur du pont. | Ils sont sans confiance, c'est-à-dire que la sécurité du pont est la même que celle de la blockchain sous-jacente.                                              |
+| Les utilisateurs doivent renoncer au contrôle de leurs crypto-actifs.                                                                                                                                         | Grâce aux [contrats intelligents](/glossary/#smart-contract), les ponts sans confiance permettent aux utilisateurs de garder le contrôle de leurs fonds. |
 
-Pour résumer, nous pouvons dire que les ponts sans risque reposent sur des hypothèses de confiance, tandis que les ponts risqués minimisent la confiance et ne font pas de nouvelles hypothèses de confiance au-delà de celles des domaines sous-jacents. Voici comment ces termes peuvent être décrits :
+Pour résumer, nous pouvons dire que les ponts de confiance reposent sur des hypothèses de confiance, tandis que les ponts sans confiance minimisent la confiance et ne font pas de nouvelles hypothèses de confiance au-delà de celles des domaines sous-jacents. Voici comment ces termes peuvent être décrits :
 
-- **Risqué** : qui a une sécurité équivalente à celle des domaines sous-jacents. Comme décrit par [Arjun Bhuptani in this article.](https://medium.com/connext/the-interoperability-trilemma-657c2cf69f17)
-- **Hypothèses de confiance :** s'éloigner de la sécurité des domaines sous-jacents en ajoutant des vérificateurs externes dans le système, ce qui le rend moins sûr sur le plan crypto-économique.
+- **Sans confiance** : possédant une sécurité équivalente à celle des domaines sous-jacents. Tel que décrit par [Arjun Bhuptani dans cet article.](https://medium.com/connext/the-interoperability-trilemma-657c2cf69f17)
+- **Hypothèses de confiance :** s'éloigner de la sécurité des domaines sous-jacents en ajoutant des vérificateurs externes au système, le rendant ainsi moins sécurisé sur le plan crypto-économique.
 
 Pour mieux comprendre les principales différences entre les deux approches, prenons un exemple :
 
@@ -94,51 +94,52 @@ Imaginez que vous soyez à un point de contrôle de sécurité dans un aéroport
 
 Un point de contrôle manuel est similaire à un modèle de confiance puisque qu'il dépend d'une tierce partie, par exemple les fonctionnaires, pour leurs opérations. En tant qu'utilisateur, vous faites confiance aux fonctionnaires pour prendre les bonnes décisions et utiliser correctement vos informations privées.
 
-L'enregistrement automatique s'apparente à un modèle risqué car il supprime le rôle de l'opérateur et utilise la technologie pour ses opérations. Les utilisateurs gardent toujours le contrôle de leurs données et ne doivent pas confier leurs informations privées à un tiers.
+L'enregistrement automatique s'apparente à un modèle sans confiance car il supprime le rôle de l'opérateur et utilise la technologie pour ses opérations. Les utilisateurs gardent toujours le contrôle de leurs données et ne doivent pas confier leurs informations privées à un tiers.
 
 De nombreuses solutions de transition adoptent des modèles entre ces deux extrêmes, avec des degrés de confiance variables.
 
 <Divider />
 
-## Utiliser des ponts {#use-bridge}
+## Utiliser les ponts {#use-bridge}
 
 L'utilisation des ponts vous permet de déplacer vos fonds entre différentes blockchains. Voici quelques ressources pour vous aider à trouver et utiliser des ponts :
 
-- **[Liste des ponts L2BEAT](https://l2beat.com/bridges/summary)&[Analyse des risques L2BEAT des ponts](https://l2beat.com/bridges/summary)** : Une liste complète de divers ponts, incluant des détails sur leur part de marché, le type de pont et les chaînes de destination. L2BEAT propose également une analyse des risques des ponts, aidant les utilisateurs à prendre des décisions éclairées lors de la sélection d'un pont.
-- **[Liste des ponts de DefiLlama](https://defillama.com/bridges/Ethereum)** : Un résumé des volumes des ponts sur les réseaux Ethereum.
+- **[L2BEAT Bridges Summary](https://l2beat.com/bridges/summary) & [L2BEAT Bridges Risk Analysis](https://l2beat.com/bridges/summary)** : un résumé complet de divers ponts, incluant des détails sur la part de marché, le type de pont et les chaînes de destination. L2BEAT propose également une analyse des risques des ponts, aidant les utilisateurs à prendre des décisions éclairées lors de la sélection d'un pont.
+- **[DefiLlama Bridge Summary](https://defillama.com/bridges/Ethereum)** : un résumé des volumes des ponts sur les réseaux Ethereum.
 
 <Divider />
 
-## Risques liés à l'utilisation de ponts {#bridge-risk}
+## Risques liés à l'utilisation des ponts {#bridge-risk}
 
 Les ponts en sont aux premiers stades de développement. Il est probable que le design optimal des ponts n'ait pas encore été découvert. Interagir avec n'importe quel type de pont comporte des risques :
 
-- **Risque lié aux contrats intelligents -** le risque d'un bug dans le code peut causer la perte des fonds de l'utilisateur
-- **Risque technologique —** une défaillance du logiciel, un code bugé, une erreur humaine, du spam et des attaques malveillantes peuvent éventuellement perturber les opérations des utilisateurs
+- **Risque lié au contrat intelligent —** le risque d'un bogue dans le code pouvant entraîner la perte des fonds des utilisateurs
+- **Risque technologique —** défaillance logicielle, code bogué, erreur humaine, spam et attaques malveillantes peuvent potentiellement perturber les opérations des utilisateurs
 
 De plus, comme les ponts de confiance ajoutent des hypothèses de confiance, ils comportent des risques supplémentaires tels que :
 
-- **Risque de censure —** les opérateurs de pont peuvent théoriquement empêcher les utilisateurs de transférer leurs biens en utilisant le pont
-- **Risque de garde —** les opérateurs de ponts peuvent s'entendre pour voler les fonds des utilisateurs
+- **Risque de censure —** les opérateurs de pont peuvent théoriquement empêcher les utilisateurs de transférer leurs actifs via le pont
+- **Risque de garde —** les opérateurs de pont peuvent s'entendre pour voler les fonds des utilisateurs
 
 Les fonds de l'utilisateur sont en danger si :
 
 - il y a un bug dans le contrat intelligent
 - l'utilisateur fait une erreur
 - la blockchain sous-jacente est hackée
-- les opérateurs du pont ont des intentions malveillantes sur un pont sans risque
+- les opérateurs du pont ont des intentions malveillantes sur un pont de confiance
 - le pont est hacké
 
-Un piratage a récemment eu lieu sur le pont Wormhole de Solana, [où 120k wETH (325 millions d'USD) ont été volé](https://rekt.news/wormhole-rekt/). La plupart des [meilleurs hacks dans les blockchains impliquaient des ponts](https://rekt.news/leaderboard/).
+L'un des piratages récents concernait le pont Wormhole de Solana, [où 120k de wETH (325 millions de dollars américains) ont été volés](https://rekt.news/wormhole-rekt/). Bon nombre des [plus grands piratages de blockchains impliquaient des ponts](https://rekt.news/leaderboard/).
 
-Les ponts sont essentiels pour l'accueil des utilisateurs sur les L2 d'Ethereum, et même pour les utilisateurs qui veulent explorer différents écosystèmes. Cependant, étant donné les risques liés à l'interaction avec les ponts, les utilisateurs doivent comprendre les compromis que font les ponts. Voici [des stratégies pour la sécurité transversale](https://blog.debridge.finance/10-strategies-for-cross-chain-security-8ed5f5879946).
+Les ponts sont essentiels pour l'accueil des utilisateurs sur les L2 d'Ethereum, et même pour les utilisateurs qui veulent explorer différents écosystèmes. Cependant, étant donné les risques liés à l'interaction avec les ponts, les utilisateurs doivent comprendre les compromis que font les ponts. Voici quelques [stratégies pour la sécurité inter-chaînes](https://debridge.com/learn/blog/10-strategies-for-cross-chain-security/).
 
 <Divider />
 
 ## En savoir plus {#further-reading}
-- [EIP-5164: Exécution Cross-Chain](https://ethereum-magicians.org/t/eip-5164-cross-chain-execution/9658) - _18 juin 2022 - Brendan Asselstine_
+
+- [EIP-5164: Cross-Chain Execution](https://ethereum-magicians.org/t/eip-5164-cross-chain-execution/9658) - _18 juin 2022 - Brendan Asselstine_
 - [L2Bridge Risk Framework](https://gov.l2beat.com/t/l2bridge-risk-framework/31) - _5 juillet 2022 - Bartek Kiepuszewski_
-- [Pourquoi l'avenir sera multi-chaînes, mais ne sera pas cross-chaînes."](https://old.reddit.com/r/ethereum/comments/rwojtk/ama_we_are_the_efs_research_team_pt_7_07_january/hrngyk8/) - _8 janvier 2022 - Vitalik Buterin_
-- [Exploiter la sécurité partagée pour une interopérabilité cross-chain sécurisée : Comités d'état Lagrange et au-delà](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - _12 juin 2024 - Emmanuel Awosika_
-- [L'état des solutions d'interopérabilité des rollups](https://web.archive.org/web/20250428015516/https://research.2077.xyz/the-state-of-rollup-interoperability) - _20 juin 2024 - Alex Hook_
+- ["Pourquoi l'avenir sera multi-chaînes, mais il ne sera pas inter-chaînes."](https://old.reddit.com/r/ethereum/comments/rwojtk/ama_we_are_the_efs_research_team_pt_7_07_january/hrngyk8/) - _8 janvier 2022 - Vitalik Buterin_
+- [Harnessing Shared Security For Secure Cross-Chain Interoperability: Lagrange State Committees And Beyond](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - _12 juin 2024 - Emmanuel Awosika_
+- [The State Of Rollup Interoperability Solutions](https://web.archive.org/web/20250428015516/https://research.2077.xyz/the-state-of-rollup-interoperability) - _20 juin 2024 - Alex Hook_
 
diff --git a/public/content/translations/fr/community/code-of-conduct/index.md b/public/content/translations/fr/community/code-of-conduct/index.md
index 0341cf2ef65..c50f3e46708 100644
--- a/public/content/translations/fr/community/code-of-conduct/index.md
+++ b/public/content/translations/fr/community/code-of-conduct/index.md
@@ -1,6 +1,6 @@
 ---
 title: Code de conduite
-description: Les normes de base que nous nous efforçons de respecter dans les espaces ethereum.org.
+description: "Les normes de base que nous nous efforçons de respecter dans les espaces ethereum.org."
 lang: fr
 ---
 
@@ -14,7 +14,7 @@ Développer et maintenir le centre de connaissances le plus complet et le plus a
 
 La communauté ethereum.org s'efforce d'être :
 
-- éducative, destinée à aider tout un chacun à comprendre Ethereum
+- éducative, destinée à aider tout le monde à comprendre Ethereum
 - inclusive
 - accessible
 - axée sur la communauté
@@ -35,15 +35,15 @@ La communauté ethereum.org s'efforce d'être :
 
 La participation ouverte est au cœur de la philosophie d'ethereum.org. Nous sommes un site web et une communauté entretenus par des milliers de contributeurs, et cela n'est possible que si nous maintenons un environnement accueillant et participatif. À cette fin, les contributeurs de ce site s'engagent à maintenir un environnement sans harcèlement pour tous les participants et participantes sur toutes les plateformes et espaces communautaires d'ethereum.org. La communauté ethereum.org accueille et valorise toute personne souhaitant participer de manière constructive et amicale, indépendamment de l'âge, du handicap, de l'ethnicité, des caractéristiques sexuelles, de l'identité de genre, du niveau d'expérience, du domaine d'expertise, de l'éducation, du statut socio-économique, de la nationalité, de l'apparence personnelle, de la race, de la religion ou de toute autre dimension de la diversité.
 
-### Portée {#scope}
+### Champ d'application {#scope}
 
-Ce code de conduite s'applique à tous les espaces ethereum.org (tels que GitHub, Discord, Figma, Crowdin, Twitter et autres plateformes en ligne), et il s'applique également lorsque la communauté est représentée dans des espaces publics réels tels que les meet-ups, les conférences et les événements.
+Ce code de conduite s'applique à tous les espaces ethereum.org (tels que GitHub, Discord, Figma, Crowdin, X (anciennement Twitter) et autres plateformes en ligne), et il s'applique également lorsque la communauté est représentée dans des espaces publics réels tels que les meetups, les conférences et les événements.
 
-### Nos standards {#our-standards}
+### Nos normes {#our-standards}
 
 Voici des exemples de comportements qui contribuent à créer un environnement positif :
 
-- L'utilisation d'un langage accueillant et inclusif
+- Utiliser un langage accueillant et inclusif
 - Être respectueux des différents points de vue et expériences
 - Accepter gracieusement les critiques constructives et/ou les formuler avec empathie
 - Agir avec calme et professionnalisme lors de la résolution de conflits ou de désaccords
@@ -68,10 +68,10 @@ Voici quelques exemples de comportements inacceptables de la part des participan
 
 Les violations du code de conduite seront normalement visibles par la communauté, car nous essayons de tout faire sur des canaux ouverts et publics, ce qui permet aux membres de la communauté de s'autosurveiller.
 
-Cependant, si quelque chose se produit et que vous pensez qu'il faut y prêter attention, vous pouvez en parler à quelqu'un qui a un rôle de modération (par exemple, guide discord) afin qu'il puisse aider à enquêter et à appliquer la réponse appropriée.
+Cependant, si quelque chose se produit et que vous pensez qu'il faut y prêter attention, vous pouvez en parler à quelqu'un qui a un rôle de modération (par exemple, guide Discord) afin qu'il puisse aider à enquêter et à appliquer la réponse appropriée.
 
 Dans votre signalement, veuillez fournir autant de détails que possible, y compris des exemples spécifiques et des horodatages. Cela permettra de garantir un résultat équitable.
 
-### Mise en œuvre {#enforcement}
+### Application {#enforcement}
 
 En fonction de la gravité, les personnes qui enfreignent le code de conduite peuvent recevoir des avertissements, des interdictions temporaires ou des interdictions permanentes des communautés ethereum.org.
diff --git a/public/content/translations/fr/community/events/organizing/index.md b/public/content/translations/fr/community/events/organizing/index.md
new file mode 100644
index 00000000000..8e9197b46d5
--- /dev/null
+++ b/public/content/translations/fr/community/events/organizing/index.md
@@ -0,0 +1,221 @@
+---
+title: "Organiser un événement Ethereum"
+description: "Comment organiser un événement Ethereum"
+lang: fr
+hideEditButton: true
+---
+
+# Comment organiser un événement Ethereum {#how-to-organize-an-ethereum-event}
+
+Construire une communauté forte et dynamique est au cœur de la croissance de l’écosystème Ethereum. Que vous envisagiez d’organiser des rencontres, des ateliers ou une conférence à grande échelle, le succès de votre événement dépend des connexions et de l’engagement au sein de votre réseau local. Ce guide vous aidera à jeter les bases d’une communauté Ethereum active et vous guidera étape par étape dans le processus d’organisation d’une conférence mémorable et percutante.
+
+## Demandez-vous, existe-t-il une communauté Ethereum ? {#ask-yourself-is-there-an-ethereum-community}
+
+Une conférence Ethereum réussie repose sur une communauté active et engagée. Si vous en avez déjà une, vous avez une longueur d’avance, mais si ce n’est pas le cas, l’étape préalable essentielle est de construire cette fondation. Il est important de faire la distinction entre une scène et une communauté : une scène peut inclure des entreprises et des individus présents dans une certaine zone, mais ils fonctionnent souvent de manière indépendante avec seulement des initiatives communes occasionnelles — comme l’écosystème web2 traditionnel dans de nombreux endroits. Une communauté, en revanche, est un réseau de personnes et d’organisations interconnectées qui collaborent et se soutiennent mutuellement, ce que l’on observe souvent dans les écosystèmes du web3.
+
+**Vos premiers pas devraient être :**
+
+- Explorez les startups et les entreprises locales : avoir des entreprises fortes et actives dans votre ville ou votre pays est souvent la condition préalable la plus importante pour bâtir une communauté.
+- Vérifiez s'il existe déjà des rencontres — ethereum.org [page des événements](https://ethereum.org/community/events/)
+- [Le site Web ethereum.org](https://ethereum.org/community/events/) et ethereum.org Discord — pour vérifier s'il existe des événements, des développeurs et des contributeurs Ethereum locaux.
+- Luma et Meetup.com — pour voir s'il y a des événements liés à Ethereum ou des événements web3 plus larges qui se déroulent dans votre région.
+- X — Essayez de trouver des défenseurs ou des influenceurs locaux dans l’espace.
+
+Si vous trouvez la plupart de ces éléments, c’est un signe fort que les conditions pour construire une communauté existent — mais pas nécessairement qu’une communauté est déjà en place. L’étape suivante consiste à organiser, engager et nourrir ces acteurs, en créant des opportunités de collaboration et de croissance à long terme.
+
+### Sinon, comment le construire {#if-not-how-to-build-it}
+
+Si vous réalisez que beaucoup de ces éléments manquent, ne vous inquiétez pas : construire une communauté à partir de zéro est un processus difficile mais profondément gratifiant. Une communauté Ethereum forte n’apparaît pas du jour au lendemain ; elle nécessite de la patience, de la cohérence et une vision claire. Voici comment vous pouvez commencer :
+
+- **Créez un canal de communication** — cela peut être Telegram, Signal, WhatsApp, WeChat ou un serveur Discord, selon ce qui est le plus populaire là où vous vous trouvez, afin que les gens puissent se connecter, poser des questions et partager des ressources.
+- **Trouvez vos premiers utilisateurs.** Identifiez quelques personnes passionnées par Ethereum et web3. Ils deviendront vos principaux supporters et collaborateurs.
+- **Organisez des événements petits et réguliers.** Commencez par des rencontres informelles, des groupes d’étude ou des ateliers. La cohérence est essentielle : même si le groupe est petit au début, des événements réguliers renforcent la confiance et la dynamique.
+- **Essayez de contacter des entreprises locales**, des établissements d’enseignement ou des espaces de coworking pour qu’ils vous fournissent un espace gratuitement. Si vous ne trouvez pas d’intervenants de votre pays, invitez des intervenants en ligne mais rassemblez les gens physiquement. Il est essentiel de garder votre public physiquement présent au même endroit.
+- **Collaborez avec les communautés technologiques existantes.** S'il existe déjà des groupes de développeurs, des écosystèmes de startups ou des rencontres blockchain, associez-vous à eux pour présenter des sujets liés à Ethereum et étendre votre portée.
+- **Partagez du contenu éducatif** sur le potentiel d’Ethereum.
+- **Contactez les communautés mondiales.** Connectez-vous avec des groupes et des projets Ethereum établis dans le monde entier pour obtenir du soutien, un mentorat et une collaboration potentielle. Les communautés Ethereum du monde entier ont au moins une chose en commun : elles sont toutes désireuses d’aider.
+- **Essayez d'obtenir un financement** — que ce soit auprès d'entreprises web3 locales ou via un programme de subventions tel que [ESP](https://esp.ethereum.foundation/).
+
+### Si oui, comment l'entretenir et le faire grandir ? {#if-yes-how-to-maintain-and-grow-it}
+
+Une fois que vous avez une communauté établie, le travail ne s’arrête pas – en fait, il ne fait que commencer. Maintenir une communauté active, engagée et en croissance nécessite des efforts et une créativité continus. L’un des éléments clés pour maintenir l’implication de la communauté est d’expérimenter constamment de nouveaux formats et de nouvelles idées.
+
+Voici quelques stratégies pour maintenir une communauté Ethereum dynamique :
+
+- **Diversifiez les formats de vos événements :** Ne vous limitez pas à un seul type de rassemblement. Mélangez les choses avec des rencontres, de courts hackathons, des tables rondes et des événements de réseautage. Vous pouvez essayer d’organiser des journées de travail en équipe ou des cours éducatifs.
+- **Diversifier les sujets :** Ethereum n’est pas seulement une technologie ; c’est aussi un ensemble de valeurs qui implique les aspects juridique, marketing et commercial.
+- **Demandez à votre communauté** des commentaires et des idées.
+- **Interagissez avec différents segments d'audience**. Adaptez le contenu et les événements à différents niveaux d'expérience, des débutants explorant Ethereum pour la première fois aux développeurs et entrepreneurs chevronnés.
+
+En offrant diverses opportunités d’apprentissage, de collaboration et de croissance, vous vous assurez que votre communauté reste active et prête pour des initiatives plus importantes comme l’organisation d’une conférence.
+
+## Événement {#event}
+
+### Quel est le bon moment pour organiser un événement ? {#when-is-the-right-time-to-organize-an-event}
+
+La réussite de l'organisation d'un événement Ethereum repose sur un timing et des réflexions minutieuses. Le choix du moment adéquat repose sur différents facteurs, qui contribuent au succès global de l'événement.
+
+Vous devez prendre en considération la maturité de la communauté, les conditions du marché, le fait que vous ayez une équipe ou non, et l'existence d'une scène locale (p. ex. sponsors potentiels).
+
+### KYC - Connaître votre communauté {#kyc-know-your-community}
+
+L'une des étapes essentielles pour l'organisation d'un événement est de bien appréhender votre communauté. Tout comme Connaître Vos Clients (KYC en anglais, CVC en français) pour les services financiers, Connaître Votre Communauté (KYC en anglais, CVC en français) implique de prendre le temps de comprendre les besoins spécifiques, les préférences, et les caractéristiques de votre public local. Cette compréhension vous aidera à adapter votre conférence afin de garantir son succès et sa pertinence.
+
+Il est tentant de viser immédiatement des événements à grande échelle, mais commencer à plus petite échelle se révèle souvent être la meilleure approche. Vous trouverez la meilleure solution en analysant objectivement l'état de votre communauté, mais également en vous penchant sur des aspects qui, a priori paraissent moins pertinents, par exemple : le pays est-il une destination touristique ou le coût de l'hébergement.
+
+Durant la première année, la majeure partie de votre public sera une communauté locale, ainsi tout ce que vous ferez pour organiser un plus grand événement devra répondre aux besoins et à la taille de cette communauté.
+
+### Par où commencer {#where-to-start}
+
+Les premières étapes de l'organisation d'une conférence peuvent vous sembler fastidieuses. Mais avec un plan clair et une structure établie, vous pourrez diviser le processus en tâches simples et accessibles. Nous allons décomposer chacune d'entre elles.
+
+Commencer avec un plan structuré vous aidera à rester organisé et à réduire le stress tout au long des diverses étapes de l'organisation de votre événement. Chaque décision doit vous amener à proposer une expérience qui répondra aux besoins de votre communauté.
+
+**La première étape est de constituer une équipe avec des rôles et des responsabilités clairs et définis.**
+
+Une autre étape importante avant de commencer à construire une programmation ou à chercher des sponsors est de choisir une date. Même si cela peut sembler évident, il y a un certain nombre de facteurs à prendre en compte. Parmi eux :
+
+- **Éviter une date déjà prise par d'autres conférences ou événements importants**
+- **Tenir compte les conditions et temporalités locales (ex : la saison de l'année, les vacances, etc.)**
+- **Tenir compte des conditions du marché**
+- **Se donner suffisamment de temps pour tout organiser - au moins neuf mois**
+
+### Comment réunir une équipe {#how-to-assemble-a-team}
+
+Choisissez des personnes qui partagent votre vision et complètent vos compétences. Certaines équipes travaillent collectivement, lorsque d'autres préfèrent définir clairement les rôles - Trouvez ce qui fonctionne le mieux pour vous. Une communication régulière et des attentes clairement exprimées sont essentielles. Même s'il est tentant de se reposer sur des plateformes de planification événementielle, nous vous suggérons de choisir une plateforme de gestion de tâches (comme Notion, Basecamp, Trello, Asana, ou encore ce bon vieux Google Sheet) pour organiser et suivre ce qui doit l'être. Il est crucial d'avoir une équipe fonctionnelle et bien organisée.
+
+Toutes les équipes d'organisation d'événements Ethereum changent dans leur structure, mais toutes ont en commun de s'appuyer sur des personnes pour travailler sur la logistique, le budget, le marketing, la programmation, le design, et les partenariats.
+
+### La programmation : un élément clef pour un événement réussi {#the-program-a-key-element-of-a-successful-event}
+
+Lorsque l'on veut organiser une conférence véritablement qualitative et dont on se souviendra, **la programmation est la clef**. Vous ne pouvez pas faire de compromis à ce sujet. Alors que les sponsors sont importants, voire essentiels pour financer votre événement, c'est l'expérience du public et la valeur qu'il en retirera qui doivent primer. Une programmation saturée de contenus promotionnels et de discours interminables des sponsors ennuiera votre public et nuira à la crédibilité de votre événement.
+
+Chaque session, panel, atelier doit informer, inspirer et engager la communauté. Écoutez votre public - comprenez leurs intérêts, besoins et défis. Quels sujets les intéressent ? Dans le même temps, introduisez de nouvelles perspectives et des formats innovants pour maintenir le dynamisme de la programmation. Gardez un équilibre entre sujets classiques et d'autres plus inédits portés par des idées novatrices, en veillant à proposer un programme complet qui couvre les différents aspects de l'écosystème Ethereum - des analyses techniques approfondies et des sessions de renforcement de la communauté, aux discussions politiques et ateliers pratiques. De plus, prenez en considération de la langue de la conférence - alors que l'anglais est la langue par défaut pour la plupart des événements Ethereum, proposer des sessions en langue locale peut rendre l'événement plus accessible pour les développeurs et enthousiastes locaux.
+
+**Lors de la sélection des intervenants, lancez votre appel au moins six mois avant la conférence pour attirer des candidatures de qualité et avoir le temps d'élaborer au mieux votre programmation.** La personne responsable de la sélection des intervenants doit avoir une expérience significative dans le secteur et une fine connaissance de l'écosystème. Cela vous garantit d'identifier les contributions pertinentes et enrichissantes, et de maintenir un niveau élevé de qualité de contenu.
+
+### Où trouver du soutien financier {#where-to-find-financial-support}
+
+Organiser une conférence de qualité entraîne des coûts importants - location de salle, matériel promotionnel, nourriture et boisson, production, et d'innombrables autres postes de dépenses. Il est essentiel d'obtenir un soutien financier dès le début afin de garantir que votre événement réponde aux normes professionnelles, et offre une expérience de qualité à votre public.
+
+#### Comment créer un deck de sponsoring ? {#how-to-create-a-sponsorship-deck}
+
+Tout d'abord, vous allez avoir besoin d'un deck (une présentation). **Demandez conseil à d'autres organisateurs de conférences**, et demandez-leur même de partager leurs decks afin de pouvoir créer vos forfaits sur cette base. Vous devez être réaliste quant à la tarification des forfaits et viser à couvrir les coûts, et non à gagner de l'argent, surtout au début.
+
+**Chaque deck de sponsoring doit fournir un aperçu clair et convaincant de l'événement**, en s'assurant que les sponsors potentiels comprennent sa portée, son objectif et sa valeur. Commencez par les éléments fondamentaux — le lieu, la date et les détails sur l'équipe d'organisation — pour asseoir votre crédibilité. Ensuite, mettez en évidence l'objectif principal de l'événement, car les différentes conférences Ethereum s'adressent à des publics différents. Certaines sont fortement orientées vers les développeurs, avec des discussions techniques approfondies, tandis que d'autres peuvent se concentrer davantage sur la DeFi, les organisations autonomes décentralisées (DAO) ou les sujets politiques.
+
+Au-delà de la simple description de l'événement, fixez des attentes claires. **Indiquez le nombre de participants prévu et les principaux intervenants déjà confirmés**, car cela aide les sponsors à évaluer leur portée potentielle. Surtout, définissez clairement ce qu'ils recevront en échange de leur parrainage — un espace de stand, des opportunités de prise de parole, une promotion sur les réseaux sociaux, une visibilité de la marque ou un accès exclusif au réseautage. Un deck bien structuré non seulement informe, mais enthousiasme également les sponsors potentiels quant à l'opportunité de participer à votre événement.
+
+#### Qui pourrait soutenir votre événement ? {#who-might-support-your-event}
+
+Commencez par contacter les entreprises de l'Ethereum et de l'écosystème technologique plus large de votre ville ou de votre pays. Ces **organisations ont souvent un intérêt direct à soutenir les événements locaux** qui favorisent la croissance et l'innovation de la communauté. Elles sont également plus susceptibles de reconnaître la valeur d'un investissement dans l'écosystème local et de voir votre conférence comme une opportunité de se connecter avec des talents, des partenaires et des utilisateurs.
+
+Une fois que vous avez obtenu un soutien local, élargissez votre champ d'action aux acteurs mondiaux de l'espace web3. **Les protocoles établis, les organisations autonomes décentralisées (DAO) et les fonds de l'écosystème allouent souvent des budgets pour les événements communautaires**. Cela peut être un peu difficile pour les organisateurs pour la première fois, car ils n'ont pas encore construit de bilan à présenter, mais essayez d'élaborer un ensemble de parrainage convaincant qui décrit clairement les avantages du soutien de votre événement - visibilité de la marque, possibilités de prise de parole et engagement significatif avec un public ciblé. Essayez de trouver votre valeur unique que les autres n'ont peut-être pas.
+
+#### Formes alternatives de financement de votre événement {#alternative-forms-of-funding-your-event}
+
+Les subventions sont une autre source de financement potentielle que de nombreux organisateurs négligent. Des programmes tels que le [Ecosystem Support Program](https://esp.ethereum.foundation/) (ESP) de la Fondation Ethereum et [d'autres initiatives de subventions](https://ethereum.org/community/grants/#ethereum-grants) existent pour soutenir les événements communautaires.
+
+Au-delà des parrainages financiers, envisagez des partenariats en nature, en particulier pour la nourriture et les boissons. Les marques qui s'alignent sur la culture locale ou la communauté technologique peuvent être d'excellents partenaires pour votre événement. Les marques de café, les entreprises de boissons ou même les pizzerias locales pourraient être disposées à fournir des produits en échange d'une visibilité lors de l'événement. Ces collaborations peuvent aider à réduire les coûts tout en améliorant l'expérience des participants.
+
+Puisque nous parlons de finances, n'oubliez pas ceci : chaque dollar que vous investissez pour créer une expérience exceptionnelle pour les participants sera rentabilisé de manière exponentielle. Une production de haute qualité, des lieux confortables, des cadeaux bien pensés et des événements parallèles bien organisés contribuent à une expérience mémorable dont les participants parleront longtemps après la fin de la conférence. Les participants heureux deviennent vos plus grands défenseurs et assurent le succès à long terme de votre événement.
+
+### Logistique {#logistics}
+
+Parallèlement à l'obtention du financement, votre objectif principal devrait être la logistique. Une conférence bien organisée nécessite une planification méticuleuse dans de nombreux domaines, de l'aménagement du lieu à l'expérience des participants. Avoir quelqu'un ayant une solide expérience dans l'organisation d'événements - pas nécessairement les événements web3, mais les événements en général - peut faire une énorme différence. Un responsable logistique expérimenté peut anticiper les problèmes potentiels et les résoudre avant qu'ils ne deviennent des problèmes, ce qui permet d'économiser du temps, de l'argent et du stress.
+
+Une personne responsable de la logistique doit choisir un lieu, une société de production et différents fournisseurs de nourriture, de boissons et de marchandises, ainsi qu'un système de billetterie en ligne facile à utiliser qui permet aux participants de s'inscrire et de payer en cryptomonnaie.
+
+### Infrastructure de localisation {#location-infrastructure}
+
+Lors du choix d'un lieu pour votre conférence, il est important de penser au-delà du lieu lui-même et de prendre en compte l'infrastructure plus large de la ville et du pays. Des facteurs tels que la météo, la mobilité, la sécurité et l'environnement politique jouent un rôle énorme dans l'élaboration de l'expérience des participants.
+
+Pour les endroits moins connus, cela devient particulièrement crucial. Les participants et les sponsors du monde entier doivent être sûrs de pouvoir voyager facilement et en toute sécurité. Examinez des aspects tels que la connectivité aéroportuaire, les transports en commun et les options d'hébergement. Il est également sage de prendre en compte le climat culturel et politique de la région pour éviter toute complication qui pourrait dissuader les participants internationaux, comme la politique des visas.
+
+### Comment promouvoir l'événement {#how-to-promote-the-event}
+
+Promouvoir efficacement votre événement est essentiel pour attirer le bon public et susciter l'enthousiasme. Une stratégie de promotion bien pensée garantit à votre conférence la visibilité et l'engagement qu'elle mérite. Le design joue également un rôle important pour votre marque, vous devriez donc absolument prévoir un budget pour cela.
+
+#### Réseaux sociaux {#social-media}
+
+X.com sera l'épine dorsale de votre promotion sur les réseaux sociaux. Essayez d'être actif et cohérent en y publiant, mais engagez également différentes conversations, à la fois avec votre compte personnel et avec le compte de votre organisation.
+
+Bien que LinkedIn ne semble pas être le choix le plus évident pour la promotion, vous pouvez y atteindre un public complètement différent, ou même certains sponsors.
+
+#### Partenariats avec d'autres communautés Ethereum {#partnerships-with-other-ethereum-communities}
+
+Les partenariats avec d'autres organisateurs Ethereum peuvent aider à amplifier votre portée en exploitant les réseaux existants, surtout lorsque vous partez de zéro. Offrez des réductions communautaires, une promotion croisée avec d'autres événements et invitez des partenaires à co-organiser des événements ou des ateliers parallèles.
+
+#### Sensibilisation universitaire {#university-outreach}
+
+Contactez les facultés d'ingénierie et d'économie de la ville par l'intermédiaire de clubs étudiants ou de professeurs pour promouvoir l'événement. S'engager avec les universités peut aider à attirer de jeunes talents, des chercheurs et de futurs professionnels de l'industrie, favorisant ainsi une connexion plus forte entre le monde universitaire et l'écosystème Ethereum. C'est particulièrement formidable si vous organisez un hackathon, car les étudiants apportent souvent des idées nouvelles, de l'enthousiasme et de solides bases techniques.
+
+#### Médias {#media}
+
+Contactez les médias et les newsletters axés sur le web3 pour la couverture de l'événement. Bien que les médias web3 s'attendent à être payés pour leurs articles de relations publiques, vous pouvez leur offrir des billets gratuits ou des interviews avec des conférenciers et des sponsors de haut niveau si vous n'avez pas de budget pour la promotion payante. Créez un package de relations publiques avec un communiqué de presse et quelques visuels prêts à être promus sur les médias sociaux ou sur un site Web dans différents formats. De plus, élargissez le champ d'action aux journalistes locaux ou même aux créateurs de contenu (tant qu'ils ont une réputation décente) qui peuvent couvrir la technologie, car cela peut s'avérer crucial pour présenter l'événement à un public plus large. Cela aide à combler le fossé entre l'industrie de la cryptographie et le grand public, attirant l'intérêt des communautés technologiques et commerciales traditionnelles.
+
+### Devriez-vous également organiser un hackathon ? {#should-you-organize-a-hackathon-as-well}
+
+Organiser un hackathon peut être bénéfique car les hackathons constituent un excellent moyen d'impliquer la communauté des développeurs et de stimuler l'innovation. Cela offre également des opportunités pratiques de collaborer et de construire des projets, ce qui pourrait conduire à des résultats tangibles pour l'écosystème. Les hackathons attirent des développeurs qui n'assistent généralement pas aux conférences, mais qui sont passionnés par le défi de construire et de tester de nouvelles idées. Si votre conférence s'adresse aux développeurs, à l'innovation et aux projets pratiques, l'organisation d'un hackathon est un choix naturel.
+
+Mais, avant d'en organiser un, demandez-vous si vous avez suffisamment de ressources et de temps. **Un hackathon nécessite des ressources importantes en termes de temps, de main-d'œuvre et d'investissement financier**. Assurez-vous d'avoir une équipe dédiée pour le gérer, surtout si vous gérez également une conférence. Vérifiez également s'il y a de l'intérêt dans votre communauté. Si votre communauté est davantage orientée vers les constructeurs, il est alors probablement judicieux de l'organiser.
+
+Bien qu'il y ait de nombreux avantages à l'organiser, prenez en considération que, selon l'ampleur de la conférence, l'ajout d'un hackathon pourrait s'avérer écrasant. Vous devez évaluer si la gestion des deux ne diluera pas la qualité de l'un ou de l'autre. Vous pouvez opter pour un hackathon plus petit et ciblé, ou échelonner les événements sur différents mois.
+
+### Les défis (presque inévitables) que vous rencontrerez {#almost-inevitable-challenges-that-you-will-face}
+
+L'un des plus grands défis lors de l'organisation d'une conférence, en particulier dans l'espace Ethereum, est d'obtenir un financement suffisant. **De nombreux organisateurs d'événements ont du mal à réunir le capital nécessaire pour couvrir les frais de location**, la restauration et les autres dépenses logistiques. Le parrainage est souvent essentiel, mais établir des relations et convaincre les entreprises d'investir dans votre événement peut prendre du temps. De plus, la difficulté d'attirer des sponsors peut s'accroître lors des baisses du marché, car les entreprises peuvent être moins enclines à investir dans des activités non essentielles.
+
+Gérer efficacement le budget est la clé. **Des dépenses imprévues**, telles que des changements de lieu de dernière minute et des exigences techniques supplémentaires pour l'événement, peuvent rapidement faire exploser votre budget.
+
+Pour les nouveaux événements, **obtenir des intervenants de grande qualité peut s'avérer particulièrement difficile**. Des leaders d'opinion ou des influenceurs établis dans l'espace Ethereum peuvent déjà avoir des horaires complets et hésiter à s'engager dans un nouvel événement sans antécédents avérés. Soyez prêt à passer du temps à réseauter et à contacter des intervenants potentiels bien avant l'événement.
+
+De plus, en ce qui concerne les intervenants, ayez une communication claire et constante avec eux — fixez la date limite d'envoi des présentations et évitez tout changement de dernière minute.
+
+Une conférence réussie nécessite une équipe dévouée capable de gérer la logistique, le marketing, les parrainages, le support technique et la gestion des participants. Trouver des personnes ayant de l'expérience dans l'organisation d'événements technologiques peut s'avérer difficile, surtout si vous travaillez avec un petit budget ou, dans la plupart des cas, sans budget, sur une base bénévole.
+
+### Vous ne devriez pas le faire seul. Vous avez besoin de bénévoles. {#you-shouldnt-do-it-alone-you-need-volunteers}
+
+L'organisation d'un événement Ethereum nécessite une équipe diversifiée et dévouée pour gérer la logistique, les inscriptions, la coordination des intervenants, le soutien aux participants, et bien plus encore. Avec des équipes allant de 3 à 15 personnes seulement, il devient clair que les bénévoles sont essentiels au bon déroulement de l'événement.
+
+Les bénévoles constituent souvent l'épine dorsale de nombreuses conférences, apportant un soutien essentiel, surtout lorsque vous travaillez avec un budget limité. Ils peuvent tout gérer, de la tenue des bureaux d'inscription à l'aide à l'installation de l'événement, en s'assurant que l'événement se déroule de la manière la plus fluide possible.
+
+Bien qu'il soit difficile d'offrir une compensation monétaire aux bénévoles, il est essentiel de leur fournir quelque chose de valeur qui rendra leur expérience enrichissante. Envisagez de leur offrir des opportunités de réseautage, un développement de compétences, des avantages exclusifs, des certificats ou des lettres de recommandation.
+
+### L'essentiel de la conformité pour les organisateurs d'événements {#compliance-essentials-for-event-organizers}
+
+Lors de l'organisation d'un événement, il y a plusieurs considérations juridiques et logistiques essentielles à garder à l'esprit :
+
+- **Accord de parrainage** – Assurez-vous d'avoir un contrat clair pour les sponsors, incluant une politique d'annulation bien définie.
+- **Code de conduite** - Préparer un code de conduite adapté au type d'événement spécifique (conférence/hackathon, maisons de hackers, etc.).
+- **Politique de confidentialité** – Rédigez une politique de confidentialité pour votre site Web afin de vous conformer aux réglementations sur la protection des données et le droit à l'image.
+- **Notification aux autorités locales** – Même si votre événement est un rassemblement privé, il est conseillé de le signaler au commissariat de police local.
+- **Accord de billetterie** – Établissez un accord formel avec votre fournisseur de services de billetterie pour clarifier les conditions et les responsabilités.
+- **Conformité réglementaire** – Vérifiez à l'avance si le pays où vous organisez la conférence a des réglementations ou des restrictions spécifiques pour l'industrie de la cryptomonnaie.
+- **Dédouanement des marchandises** – Si vous importez des marchandises de sponsors, il est recommandé d'engager un agent en douane pour gérer le processus efficacement.
+- **Politique en matière de photographie et de médias** – Définissez clairement les directives concernant la photographie et la couverture médiatique, en vous assurant que les participants sont informés du consentement et des options de retrait.
+
+## Après l'événement : quelle est la suite ? {#after-the-event-whats-next}
+
+Une fois l'événement terminé, il est crucial de recueillir les commentaires des participants, des intervenants et des sponsors, et de créer un rapport interne afin d'être mieux préparé pour les événements futurs. Cela aide à identifier ce qui a bien fonctionné et où des améliorations peuvent être apportées. Utilisez des sondages ou des entretiens individuels pour recueillir des informations précieuses qui guideront les itérations futures. Prenez le temps de passer en revue les erreurs ou les domaines d'inefficacité, car ils peuvent être évités lors de la prochaine conférence, rendant le processus plus fluide.
+
+La clé est de garder l'élan vivant. Continuez à vous engager avec votre communauté, partagez des mises à jour sur les progrès que vous faites en fonction de leurs commentaires et créez de l'enthousiasme pour le prochain événement. En maintenant cette connexion, vous vous assurez que l'impact de la conférence s'étend au-delà de l'événement lui-même, renforçant les relations et préparant le terrain pour un succès futur.
+
+## Remerciements {#acknowledgement}
+
+Un grand merci à tous ceux qui ont contribué à cet article en partageant leurs idées : Slavo Fabisik d'ETHBratislava ; Lola de l'ETH Kipu et de l'ETH Latam ; Tanja Mladenovic de l'ETH Belgrade, Juan David de Ethereum Bogota ; Monika Zając de l'ETHWarsaw ; Raffaele Orefice de NapulETH ; Xiao Wu(Ling) de l'ETH Riyadh ; Marco de urbe.eth ; Caolán Walsh de l'ETH Dublin ; Alex Males de l'ETHCluj ; et Stanko Devic de l'ETH Slovénie.
+
+## Ressources {#resources}
+
+Podcast : Comment organiser et promouvoir un événement ETH de A à Z :
+
+- [L'étude de cas ETHWarsaw, par Out of Ordinary](https://www.youtube.com/watch?v=io2Dx1ouz8o)
+
+Espace Twitter :
+
+- [AMA de la communauté ETH](https://x.com/NapulETH/status/1905732699094151623)
+
+Articles :
+
+- [Construire ETHKL, par Danny H.](https://sekto.tech/ethkl24)
+- [Guide des événements POKT](https://docs.pokt.network/community/pokt-events-playbook)
\ No newline at end of file
diff --git a/public/content/translations/fr/community/get-involved/index.md b/public/content/translations/fr/community/get-involved/index.md
index 052cb4ba431..b63596cb68d 100644
--- a/public/content/translations/fr/community/get-involved/index.md
+++ b/public/content/translations/fr/community/get-involved/index.md
@@ -1,50 +1,50 @@
 ---
 title: Comment s'impliquer ?
-description: Comment s'impliquer dans la communauté Ethereum.
+description: "Comment s'impliquer dans la communauté Ethereum."
 lang: fr
 ---
 
-# Comment s'impliquer ? {#get-involved}
+# Comment s'impliquer ? S’impliquer {#get-involved}
 
 La communauté Ethereum comprend des personnes d'horizons et de compétences très différents. Que vous soyez développeur, artiste ou comptable, il existe des moyens de vous impliquer. Voici une liste de suggestions qui pourraient vous aider à démarrer.
 
-Commencez à lire la mission et les valeurs d'ethereum.org dans notre [code de conduite](/community/code-of-conduct).
+Commencez par lire la mission et les valeurs d'ethereum.org dans notre [code de conduite](/community/code-of-conduct).
 
-## Développeurs <Emoji text=":computer:" size={1} /> {#developers}
+## Développeurs <Emoji text=":computer:" size={1} />‍ {#developers}
 
 - Découvrez et essayez Ethereum sur [ethereum.org/developers/](/developers/)
-- Participez à un hackathon [ETHGlobal](http://ethglobal.co/) près de chez vous !
+- Participez à un hackathon [ETHGlobal](http://ethglobal.co/) près de chez vous !
 - Consultez les [projets liés à votre domaine d'expertise ou au langage de programmation de votre choix](/developers/docs/programming-languages/)
-- Regardez ou participez aux [appels des couches de consensus et d'exécution](https://www.youtube.com/@EthereumProtocol/streams)
+- Regardez ou participez aux [appels sur la couche de consensus et d'exécution](https://www.youtube.com/@EthereumProtocol/streams)
 - [Liste de souhaits du programme de soutien à l'écosystème](https://esp.ethereum.foundation/wishlist/) - domaines d'outillage, de documentation et d'infrastructure où le programme de soutien à l'écosystème Ethereum recherche activement des demandes de subvention
-- [Web3Bridge](https://www.web3bridge.com/) - rejoignez la communauté Web3 en herbe dans son initiative visant à identifier, former et soutenir des centaines de développeurs et de membres de la communauté à travers l'Afrique
-- Rejoignez le [Discord d'Eth R&D](https://discord.com/invite/VmG7Uxc)
-- Rejoignez le Discord [Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu)
+- [Web3Bridge](https://www.web3bridgeafrica.com) - rejoignez la communauté Web3 en herbe dans son initiative visant à identifier, former et soutenir des centaines de développeurs et de membres de la communauté à travers l'Afrique
+- Rejoignez le [Discord Eth R&D](https://discord.com/invite/VmG7Uxc)
+- Rejoignez le [Discord des Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu)
 
-## Chercheurs et universitaires <Emoji text=":mag:" size={1} /> {#researchers-and-academics}
+## Chercheurs et universitaires <Emoji text=":mag:" size={1} />‍ {#researchers-and-academics}
 
 Avez-vous une formation en mathématiques, en cryptographie ou en économie ? Vous pourriez être intéressé par certains des travaux de pointe réalisés au sein de l'écosystème Ethereum :
 
-- Rejoignez le [Discord d'Eth R&D](https://discord.com/invite/VmG7Uxc)
+- Rejoignez le [Discord Eth R&D](https://discord.com/invite/VmG7Uxc)
 - Écrivez ou relisez une proposition d'amélioration d'Ethereum (EIP)
   - Écrivez une EIP
-    1. Soumettez votre idée aux [Ethereum Magicians](https://ethereum-magicians.org)
-    2. Lisez l'[EIP-1](https://eips.ethereum.org/EIPS/eip-1) - **Oui, lisez bien _tout_ le document.**
+    1. Soumettez votre idée sur [Ethereum Magicians](https://ethereum-magicians.org)
+    2. Lisez l'[EIP-1](https://eips.ethereum.org/EIPS/eip-1) - **Oui, c'est l'_intégralité_ du document.**
     3. Suivez les consignes de l'EIP-1. Référencez-le lorsque vous rédigez votre brouillon.
-  - Apprenez comment devenir un [Rédacteur d'EIP](https://eips.ethereum.org/EIPS/eip-5069)
-    - Vous pouvez participer à une revue des EIP par les pairs dès maintenant ! Trouvez [des PR ouvertes comportant le libellé `e-review`](https://github.com/ethereum/EIPs/pulls?q=is%3Apr+is%3Aopen+label%3Ae-review). Fournissez un retour technique sur le lien `discussion-to`.
-  - Participez à la [Gouvernance des EIP](https://github.com/ethereum-cat-herders/EIPIP)
-    - Rejoignez le Discord [Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu)
-  - [Plus d'infos les EIP](/eips/)
-- [Challenges.ethereum.org](https://challenges.ethereum.org/) - une série de primes de recherche de grande valeur, où vous pouvez gagner >100 000 USD
+  - Apprenez à devenir un [éditeur d'EIP](https://eips.ethereum.org/EIPS/eip-5069)
+    - Vous pouvez participer à une revue des EIP par les pairs dès maintenant ! Consultez les [PR ouvertes avec l'étiquette `e-review`](https://github.com/ethereum/EIPs/pulls?q=is%3Apr+is%3Aopen+label%3Ae-review). Fournissez des commentaires techniques sur le lien `discussion-to`.
+  - Participez à la [gouvernance des EIP](https://github.com/ethereum-cat-herders/EIPIP)
+    - Rejoignez le [Discord des Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu)
+  - [En savoir plus sur les EIP](/eips/)
+- [Challenges.ethereum.org](https://challenges.ethereum.org/) - une série de primes de recherche de grande valeur, où vous pouvez gagner plus de 100 000 $ USD
 - [Ethresear.ch](https://ethresear.ch) - le principal forum de recherche d'Ethereum et le forum le plus influent au monde pour la cryptoéconomie
-- [EF Research AMA](https://old.reddit.com/r/ethereum/comments/vrx9xe/ama_we_are_ef_research_pt_8_07_july_2022) - Une série de questions-réponses avec des chercheurs. Dès l'ouverture de chaque partie suivante, tout le monde peut poster des questions.
-- [Liste de souhaits du programme de soutien à l'écosystème](https://esp.ethereum.foundation/wishlist/) - domaines de recherche dans lesquels le programme de soutien à l'écosystème Ethereum recherche activement des demandes de subvention
-- [AllWalletDevs](https://allwallet.dev) - un forum pour les développeurs et les concepteurs Ethereum, ainsi que pour les utilisateurs intéressés, afin de se réunir régulièrement et de discuter des portefeuilles
+- [AMA de l'équipe de recherche de l'EF](https://old.reddit.com/r/ethereum/comments/vrx9xe/ama_we_are_ef_research_pt_8_07_july_2022) - Une série de questions-réponses en cours avec les chercheurs. Dès l'ouverture de chaque partie suivante, tout le monde peut poster des questions.
+- [Liste de souhaits du Programme de soutien de l'écosystème](https://esp.ethereum.foundation/wishlist/) - domaines de recherche pour lesquels le Programme de soutien de l'écosystème Ethereum recherche activement des demandes de subvention
+- [AllWalletDevs](https://allwallet.dev) - un forum pour les développeurs, les concepteurs et les utilisateurs intéressés d'Ethereum qui se réunissent régulièrement pour discuter des portefeuilles
 
-[Explorer des domaines de recherche plus actifs](/community/research/).
+[Explorez d'autres domaines de recherche actifs](/community/research/).
 
-## Compétences non techniques <Emoji text=":briefcase:" size={1} /> {#non-technical}
+## Compétences non techniques <Emoji text=":briefcase:" size={1} />‍ {#non-technical}
 
 Si vous n'êtes pas développeur, il peut être difficile de savoir par où commencer avec Ethereum. Voici quelques suggestions, ainsi que des ressources pour des parcours professionnels spécifiques.
 
@@ -55,18 +55,18 @@ Si vous n'êtes pas développeur, il peut être difficile de savoir par où comm
 ### Rédiger du contenu sur Ethereum {#write-content}
 
 - Ethereum a besoin de bons écrivains qui peuvent expliquer sa valeur en langage clair
-- Pas prêt à publier vos propres articles ? Envisagez de contribuer au contenu existant sur les ressources communautaires ou [proposez de nouveaux contenus pour ethereum.org](/contributing/) !
+- Pas prêt à publier vos propres articles ? Envisagez de contribuer au contenu existant sur les ressources communautaires, ou [proposez du nouveau contenu pour ethereum.org](/contributing/) !
 
 ### Proposer de prendre des notes pour les appels communautaires {#take-notes}
 
-- Il existe de nombreux appels communautaires open source, et avoir des preneurs de notes est d'une grande aide. Si vous êtes intéressé, rejoignez le [Discord Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu) et présentez-vous !
+- Il existe de nombreux appels communautaires open source, et avoir des preneurs de notes est d'une grande aide. Si vous êtes intéressé, rejoignez le [discord des Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu) et présentez-vous !
 
-### Traduire le contenu Ethereum dans votre langue maternelle {#translate-ethereum}
+### Traduire le contenu d'Ethereum dans votre langue maternelle {#translate-ethereum}
 
 - ethereum.org maintient un programme de traduction qui traduit le site Web et d'autres ressources dans de nombreuses langues différentes
 - Découvrez comment vous impliquer [ici](/contributing/translation-program)
 
-### Ajouter un nœud {#run-a-node}
+### Exécuter un nœud {#run-a-node}
 
 Rejoignez des milliers d'opérateurs de nœuds pour aider à décentraliser davantage Ethereum.
 
@@ -76,57 +76,57 @@ Rejoignez des milliers d'opérateurs de nœuds pour aider à décentraliser dava
 
 En misant votre ETH, vous pouvez gagner des récompenses tout en aidant à sécuriser le réseau Ethereum.
 
-- [Plus d'infos sur la mise en jeu](/staking/)
+- [En savoir plus sur la mise en jeu](/staking/)
 
-### Soutenir les projets {#support-projects}
+### Soutenir des projets {#support-projects}
 
 L'écosystème Ethereum a pour mission de financer des biens publics et des projets ayant un impact certain. Avec de très petits dons, vous pouvez montrer votre soutien et permettre la réalisation d'un travail important.
 
 - [Gitcoin](https://gitcoin.co/fund)
-- [clr.fond](https://clr.fund/#/about)
+- [clr.fund](https://clr.fund/#/about)
 
-## Professionnels de la finance et comptables <Emoji text=":chart_with_upwards_trend:" size={1} /> {#financial-professionals}
+## Professionnels de la finance et comptables <Emoji text=":chart_with_upwards_trend:" size={1} />‍ {#financial-professionals}
 
-- Ethereum abrite l'écosystème « Finance décentralisée » - un réseau de protocoles et d'applications qui offrent un système financier alternatif. Si vous êtes un professionnel de la finance, consultez certaines applications DeFi sur [DeFi Llama](https://defillama.com/) ou [ DeFiPrime](https://defiprime.com).
-- Comptable? Les actifs sur Ethereum - ETH, jetons, DeFi, etc. - introduisent de nombreux nouveaux problèmes comptables. Vous pouvez commencer par consulter certains projets qui visent à aider les utilisateurs de cryptomonnaie à résoudre leur comptabilité & défis comptables, comme [Rotki](https://rotki.com/)
+- Ethereum abrite l'écosystème « Finance décentralisée » - un réseau de protocoles et d'applications qui offrent un système financier alternatif. Si vous êtes un professionnel de la finance, découvrez des applications DeFi sur [DeFi Llama](https://defillama.com/) ou [DeFiPrime](https://defiprime.com)
+- Comptable? Les actifs sur Ethereum - ETH, jetons, DeFi, etc. - introduisent de nombreux nouveaux problèmes comptables. Vous pourriez commencer par consulter certains projets qui visent à aider les utilisateurs de cryptomonnaie à résoudre leurs problèmes de tenue de livres et de comptabilité, comme [Rotki](https://rotki.com/)
 
-## Chefs de produit <Emoji text=":fountain_pen:" size={1} /> {#product-managers}
+## Chefs de produit <Emoji text=":fountain_pen:" size={1} />‍ {#product-managers}
 
-- L'écosystème Ethereum a besoin de vos talents ! De nombreuses entreprises embauchent pour des postes de chef de produit. Si vous souhaitez commencer à contribuer à un projet open source, contactez les [Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu) ou [RaidGuild](https://www.raidguild.org/)
+- L'écosystème Ethereum a besoin de vos talents ! De nombreuses entreprises embauchent pour des postes de chef de produit. Si vous souhaitez commencer par contribuer à un projet open source, contactez les [Ethereum Cat Herders](https://discord.com/invite/Nz6rtfJ8Cu) ou [RaidGuild](https://www.raidguild.org/)
 
-## Marketing <Emoji text=":megaphone:" size={1} /> {#marketing}
+## Marketing <Emoji text=":megaphone:" size={1} />‍ {#marketing}
 
 - Il existe de nombreux postes en marketing et communication dans l'écosystème Ethereum !
 
 ## Emplois Ethereum {#ethereum-jobs}
 
-**Vous souhaitez trouver un emploi en rapport avec Ethereum ?**
+**Vous souhaitez trouver un emploi dans l'écosystème Ethereum ?**
 
-- [Emplois ethereum.org](/about/#open-jobs)
-- [Offres d'emploi de l'Ethereum Foundation](https://jobs.ashbyhq.com/ethereum-foundation)
+- [Offres d'emploi sur ethereum.org](/about/#open-jobs)
+- [Offres d'emploi de la Fondation Ethereum](https://jobs.ashbyhq.com/ethereum-foundation)
 - [JobStash](https://jobstash.xyz)
-- [Offres Cryptocurrency Jobs](https://cryptocurrencyjobs.co/ethereum/)
+- [Ethereum Job Board](https://www.ethereumjobboard.com/)
+- [Cryptocurrency Jobs](https://cryptocurrencyjobs.co/ethereum/)
 - [Carrières chez ConsenSys](https://consensys.net/careers/)
-- [Offres Crypto Jobs List](https://cryptojobslist.com/ethereum-jobs)
-- [Offres d'emploi Bankless](https://pallet.xyz/list/bankless/jobs)
-- [Offres Web3 Jobs](https://web3.career)
-- [Offres Web3 Army](https://web3army.xyz/)
-- [Offres Crypto Valley Jobs](https://cryptovalley.jobs/)
-- [Jobs Ethereum](https://startup.jobs/ethereum-jobs)
+- [Crypto Jobs List](https://cryptojobslist.com/ethereum-jobs)
+- [Tableau des offres d'emploi de Bankless](https://pallet.xyz/list/bankless/jobs)
+- [Web3 Jobs](https://web3.career)
+- [Web3 Army](https://web3army.xyz/)
+- [Crypto Valley Jobs](https://cryptovalley.jobs/)
+- [Ethereum Jobs](https://startup.jobs/ethereum-jobs)
 
-## Rejoindre une organisation autonome décentralisée (DAO) {#decentralized-autonomous-organizations-daos}
+## Rejoindre une DAO {#decentralized-autonomous-organizations-daos}
 
 Les « DAO » sont des organisations autonomes décentralisées. Ces groupes tirent parti de la technologie Ethereum pour faciliter l'organisation et la collaboration. Par exemple, pour contrôler l'adhésion, voter sur des propositions ou gérer des actifs mis en commun. Bien que les DAO soient encore expérimentales, elles vous offrent la possibilité de trouver des groupes auxquels vous vous identifiez, de trouver des collaborateurs et d'accroître votre impact sur la communauté Ethereum. [En savoir plus sur les DAO](/dao/)
 
-- [DAOSquare](https://daosquare.io/) [@DAOSquare](https://twitter.com/DAOSquare) - _Promouvoir le concept de DAO dans le domaine non technologique et aider les personnes à créer de la valeur grâce au DAO_
-- [Développeur DAO](https://www.developerdao.com/) [@developer_dao](https://twitter.com/developer_dao) - _Communauté de constructeurs qui croient en la propriété collective d'Internet_
-- [dOrg](https://dOrg.tech) [@dOrg_tech](https://twitter.com/dOrg_tech) - *Collectif de développement Web3 indépendant travaillant en tant que DAO*
-- [HausDAO](https://daohaus.club) [@nowdaoit](https://twitter.com/nowdaoit) - *Gouvernance communautaire de DAOhaus*
-- [LexDAO](https://lexdao.org) [@lex_DAO](https://twitter.com/lex_DAO) - *Ingénierie juridique*
-- [MetaCartel Ventures](https://metacartel.xyz) [@VENTURE_DAO](https://twitter.com/VENTURE_DAO) - *Venture pour des projets de crypto pré-amorçage*
-- [MetaGame](https://metagame.wtf) [@MetaFam](https://twitter.com/MetaFam) - *Mécaniques de jeu MMORPG pour la vraie vie*
-- [MetaFactory](https://metafactory.ai) [@TheMetaFactory](https://twitter.com/TheMetaFactory) - *Marques de vêtements digiphysiques*
-- [MolochDAO](https://molochdao.com) [@MolochDAO](https://twitter.com/MolochDAO) - *Communauté axée sur le financement du développement d'Ethereum*
-- [Guilde Raid](https://raidguild.org) [@RaidGuild](https://twitter.com/RaidGuild) - *Collectif de constructeurs Web3*
-
-À chaque fois et quelle que soit la façon dont vous contribuez à ethereum.org, pensez à respecter le [code de conduite](/community/code-of-conduct) !
+- [DAOSquare](https://daosquare.io/) [@DAOSquare](https://twitter.com/DAOSquare) - _Promouvoir le concept de DAO dans les domaines non technologiques et aider les gens à créer de la valeur grâce aux DAO_
+- [Developer DAO](https://www.developerdao.com/) [@developer_dao](https://twitter.com/developer_dao) - _Communauté de créateurs qui croient en la propriété collective d'Internet_
+- [dOrg](https://dOrg.tech) [@dOrg_tech](https://twitter.com/dOrg_tech) - _Collectif de développeurs Web3 indépendants fonctionnant comme une DAO_
+- [HausDAO](https://daohaus.club) [@nowdaoit](https://twitter.com/nowdaoit) - _Gouvernance communautaire de DAOhaus_
+- [LexDAO](https://lexdao.org) [@lex_DAO](https://twitter.com/lex_DAO) - _Ingénierie juridique_
+- [MetaCartel Ventures](https://metacartel.xyz) [@VENTURE_DAO](https://twitter.com/VENTURE_DAO) - _Capital-risque pour les projets crypto en phase de pré-amorçage_
+- [MetaFactory](https://metafactory.ai) [@TheMetaFactory](https://twitter.com/TheMetaFactory) - _Marques de vêtements digiphysiques_
+- [MolochDAO](https://molochdao.com) [@MolochDAO](https://twitter.com/MolochDAO) - _Communauté axée sur le financement du développement d'Ethereum_
+- [Raid Guild](https://raidguild.org) [@RaidGuild](https://twitter.com/RaidGuild) - _Collectif de créateurs Web3_
+
+Pensez à respecter le [code de conduite](/community/code-of-conduct) d'ethereum.org, à chaque fois et quelle que soit la façon dont vous contribuez à ethereum.org !
diff --git a/public/content/translations/fr/community/grants/index.md b/public/content/translations/fr/community/grants/index.md
index a6fd5c97d10..9ee69c30e5a 100644
--- a/public/content/translations/fr/community/grants/index.md
+++ b/public/content/translations/fr/community/grants/index.md
@@ -1,6 +1,6 @@
 ---
-title: Ethereum Foundation & programmes de subventions communautaires
-description: Une liste des programmes de subvention de l'écosystème Ethereum.
+title: "Programmes de subventions de la Fondation Ethereum et de la communauté"
+description: "Une liste des programmes de subventions pour l'écosystème Ethereum."
 lang: fr
 ---
 
@@ -10,36 +10,59 @@ Les programmes énumérés ci-dessous offrent une variété de subventions de fi
 
 Elle est supervisée par notre communauté. S'il y a quelque chose manquant ou incorrect, veuillez modifier cette page!
 
-## Ethereum : un large écosystème {#broad-ethereum-ecosystem}
+<Alert variant="update" className="mt-8">
+<Emoji text="🎗️" />
+<div>Fondateurs, vous avez besoin d'aide pour accélérer votre entreprise ? [Rendez-vous sur le support aux fondateurs](/founders/)</div>
+</Alert>
+
+## Vaste écosystème Ethereum {#broad-ethereum-ecosystem}
 
 Ces programmes soutiennent le vaste écosystème Ethereum en offrant des subventions à un large éventail de projets. Il s'agit notamment de solutions pour l'évolutivité, la création de communautés, la sécurité, la confidentialité, etc. Ces subventions ne sont pas spécifiques à une seule plateforme Ethereum et constituent un bon point de départ si vous n'êtes pas sûr.
 
 - [Programme de soutien de l'écosystème EF](https://esp.ethereum.foundation) - _Financement de projets open source qui bénéficient à Ethereum, avec un intérêt particulier pour les outils universels, l'infrastructure, la recherche et les biens publics_
-- [DAO Moloch](https://www.molochdao.com/) - _Confidentialité, mise à l'échelle de la couche 2, sécurité du client, etc._
-- [Subventions DAO](https://docs.google.com/spreadsheets/d/1XHc-p_MHNRdjacc8uOEjtPoWL86olP4GyxAJOFO0zxY/edit#gid=0) - _Feuille de calcul Google regroupant les organisations offrant des subventions_
-- [Academic Grants](https://esp.ethereum.foundation/academic-grants) - _Subventions pour soutenir les travaux universitaires liés à Ethereum_
+- [Subventions universitaires](https://esp.ethereum.foundation/academic-grants) - _Subventions pour soutenir les travaux universitaires liés à Ethereum_
+
+## Agrégateurs et plateformes de listes de subventions {#grant-list-aggregators}
+
+Ces ressources compilent et organisent diverses opportunités de subventions à travers l’écosystème Ethereum, ce qui facilite la découverte de financements correspondant aux besoins de votre projet. Nous les avons organisées par profil afin de vous aider à trouver plus facilement les ressources les plus pertinentes en fonction de vos besoins de financement spécifiques.
+
+### Pour tous les demandeurs de subventions : répertoires complets {#comprehensive-directories}
+
+Ces plateformes générales offrent une couverture étendue des subventions dans l’ensemble de l’écosystème Web3 et constituent d’excellents points de départ pour toute personne à la recherche de financements :
+
+- [Blockworks Grantfarm](https://blockworks.co/grants/programs) - _Blockworks a compilé un répertoire complet de toutes les subventions, appels d'offres et primes pour la découverte de bugs._
+- [Blockchain Grants](https://www.blockchaingrants.org/) - _Répertoire des subventions blockchain et crypto_
+- [Karma Funding Map](https://gap.karmahq.xyz/funding-map) - Répertoire de tous les programmes de subventions Web3, mis à jour chaque semaine
+
+### Pour les développeurs et les bâtisseurs {#for-developers-and-builders}
+
+- [Grant Programs Viewer](https://airtable.com/shr86elKgWTSCP4AY) - _Base de données publique Airtable des programmes de subventions_
+- [Web3 Grants Spreadsheet](https://docs.google.com/spreadsheets/d/1c8koZCI-GLnD8MG-eFcXPOBCNu1v8-aXIfwAAvc7AMc/edit#gid=0) - _Feuille de calcul Google des opportunités de subventions Web3_
+- [Arbitrum Grants](https://arbitrum.foundation/grants) — DAO Arbitrum et [The Arbitrum Foundation](https://arbitrum.foundation/)
+
+### Pour les projets DeFi et les applications financières {#for-defi-projects}
+
+- [LlamaoGrants](https://wiki.defillama.com/wiki/LlamaoGrants) - _Répertoire du programme de subventions de DeFi Llama_
+- [AlphaGrowth Grants](https://alphagrowth.io/crypto-web3-grants-list) - _Liste complète des subventions crypto et Web3_
+- [Uniswap Foundation Grants](https://www.uniswapfoundation.org/build) - _Subventions Unichain et Uniswap v4 et soutien aux bâtisseurs DeFi_
 
-## Projets spécifiques {#project-specific}
+### Pour les contributeurs aux DAO et les innovateurs en gouvernance {#for-dao-contributors}
 
-Ces projets ont crée leurs propres subventions pour encourager d'autres projets à développer et expérimenter leur propre technologie.
+Ressources pour les projets communautaires et les expérimentations en gouvernance :
 
-- [Programme de subventions Aave](https://aavegrants.org/) – _Subventions DAO [Aave](https://aave.com/)_
-- [Balancer](https://grants.balancer.community/) – _Fonds pour l'écosystème [Balancer](https://balancer.fi/)_
-- [Programme de subventions de décentralisation](https://governance.decentraland.org/grants/) – _[Decentraland](https://decentraland.org/) Metaverse DAO_
-- [Organisme de subvention Lido Ecosystem Grants Organisation (LEGO)](https://lido.fi/lego) – _Écosystème financier [Lido](https://lido.fi/)_
-- [Programme MetaMask](https://metamaskgrants.org/) - _[MetaMask](https://metamask.io/) DAO de subventions gérées par les employés_
-- [Programme de subventions SKALE Network](https://skale.space/developers#grants) - _Écosystème [SKALE Network](https://skale.space/)_
-- [Programme de subvention de la fondation Swarm](https://www.ethswarm.org/grants) - _Écosystème de la [fondation Swarm](https://www.ethswarm.org/)_
-- [TheGraph](https://thegraph.com/ecosystem/grants/) – _Écosystème [TheGraph](https://thegraph.com/)_
-- [Programme de subventions Uniswap](https://www.uniswapfoundation.org/grants) – _Communauté [Uniswap](https://uniswap.org/)_
+- [DAO Grants](https://docs.google.com/spreadsheets/d/1XHc-p_MHNRdjacc8uOEjtPoWL86olP4GyxAJOFO0zxY/edit#gid=0) - _Feuille de calcul Google des organisations proposant des subventions_
+- [MetaGov Database](https://docs.google.com/spreadsheets/d/1e5g-dlWWsK2DZoZGBgfxyfGNSddLk-V7sLEgfPjEhbA/edit#gid=780420708) - _Carte complète des subventions Web3_
 
-## Financement quadratique {#quadratic-funding}
+### Biens publics et impact {#public-goods-and-impact}
 
-Les sources ouvertes d'Ethereum ont conduit à la croissance d'un nouveau modèle intéressant de collecte de fonds : le financement quadratique. Ce modèle a le potentiel d'améliorer la façon dont nous finançons tous les types de biens publics à l'avenir. Le financement quadratique veille à ce que les projets qui reçoivent le plus de financement soient ceux dont la demande est la plus unique. En d'autres termes, des projets qui visent à améliorer la vie du plus grand nombre de personnes. [Plus de détails sur le financement quadratique.](/defi/#quadratic-funding)
+Ces programmes se concentrent sur le financement de projets qui bénéficient la communauté au sens large, aux biens publics et aux initiatives à impact. Cela inclut des fournisseurs de subventions, ainsi que des plateformes de dons utilisant des mécanismes d’allocation de financement en chaîne, notamment le [financement quadratique](/defi/#quadratic-funding) :
 
-- [Gitcoin](https://gitcoin.co/grants)
-- [clr.fund](https://clr.fund/)
+- [Gitcoin](https://www.gitcoin.co/program) - _Gitcoin Grants utilise plusieurs mécanismes d'allocation de capitaux pour financer des projets open source et des biens publics dans l'écosystème Ethereum_
+- [Octant](https://octant.app/home) - _Écosystème de financement des biens publics qui équilibre le bien commun et l'autonomisation financière individuelle_
+- [Giveth](https://giveth.io/) - _Plateforme de dons en crypto permettant des dons directs à des projets à impact, sans frais supplémentaires_
+- [Artizen](https://artizen.fund/) - _Aide les créateurs à cofinancer de nouveaux projets à la frontière de l'art, de la science, de la technologie et de la culture_
+- [Quadratic Accelerator](https://qacc.giveth.io/) - _Programme d'accélération de start-ups utilisant le financement quadratique pour soutenir des projets au service du bien public_
 
-## Travailler pour Ethereum {#work-in-ethereum}
+## Travailler dans l'écosystème Ethereum {#work-in-ethereum}
 
-Vous n'êtes pas prêt à lancer votre propre projet ? Il y a des centaines d'entreprises qui recherchent activement des personnes passionnées pour travailler et contribuer à l'écosystème Ethereum. Vous cherchez plus d’informations ? [Découvrez les emplois liés à Ethereum](/community/get-involved/#ethereum-jobs)
+Vous n'êtes pas prêt à lancer votre propre projet ? Il y a des centaines d'entreprises qui recherchent activement des personnes passionnées pour travailler et contribuer à l'écosystème Ethereum. Vous cherchez plus d’informations ? [Consultez les offres d'emploi liées à Ethereum](/community/get-involved/#ethereum-jobs)
diff --git a/public/content/translations/fr/community/language-resources/index.md b/public/content/translations/fr/community/language-resources/index.md
index 59b55d2ff90..4ee35dec45d 100644
--- a/public/content/translations/fr/community/language-resources/index.md
+++ b/public/content/translations/fr/community/language-resources/index.md
@@ -1,153 +1,152 @@
 ---
-title: Ressources linguistiques
+title: Ressources non-anglophones
 description: Ressources non anglophones pour en savoir plus sur Ethereum
 lang: fr
 ---
 
-# Ressources non-anglophones {#language-resources}
+# Ressources linguistiques {#language-resources}
 
 La communauté Ethereum est internationale et rassemble des millions de membres non-anglophones.
 
 Notre objectif est de fournir du contenu éducatif dans toutes les langues et d'aider à supprimer les barrières linguistiques qui font de la familiarisation des personnes du monde entier à Ethereum un défi.
 
-Si vous préférez vous documenter dans votre langue maternelle ou connaissez quelqu'un qui ne parle pas anglais, la liste de ressources non-anglophones ci-dessous vous sera utile. Des centaines de milliers de passionnés d'Ethereum se rassemblent sur ces forums en ligne pour partager l'actualité, parler des derniers progrès réalisés, débattre de questions techniques et imaginer l'avenir.
+Si vous préférez vous documenter dans votre langue maternelle ou connaissez quelqu'un qui ne parle pas anglais, la liste de ressources non-anglophones ci-dessous vous sera utile. Des centaines de milliers de passionnés d'Ethereum se rassemblent sur ces forums en ligne pour partager l'actualité, discuter des derniers développements, débattre de questions techniques et imaginer l'avenir.
 
-Vous connaissez une ressource éducative dans votre langue ? [Ouvrez un ticket](https://github.com/ethereum/ethereum-org-website/issues/new/choose) pour l'ajouter à la liste !
+Vous connaissez une ressource éducative dans votre langue ? [Ouvrez un ticket](https://github.com/ethereum/ethereum-org-website/issues/new/choose) pour l'ajouter à la liste !
 
-## Ressources d'Ethereum.org {#ethereum-org}
+## Ressources d'ethereum.org {#ethereum-org}
 
 Ethereum.org est traduit de manière native dans plus de 40 langues que vous pouvez trouver en utilisant notre menu de sélection de langues, situé en haut de chaque page.
 
-![Menu de sélection de la langue](./language-selector-menu.png)
+![Menu du sélecteur de langue](./language-selector-menu.png)
 
-Si vous êtes bilingue et que vous souhaitez nous aider à toucher davantage de personnes, vous pouvez aussi contribuer au [Programme de traduction d'Ethereum.org](/contributing/translation-program/#translation-program) afin de nous aider à traduire le site.
+Si vous êtes bilingue et souhaitez nous aider à toucher plus de monde, vous pouvez également participer au [programme de traduction d'ethereum.org](/contributing/translation-program/#translation-program) et nous aider à traduire le site Web.
 
-## Ressources communautaires {#community}
+## Ressources de la communauté {#community}
 
 ### Portugais brésilien {#br-pt}
 
-**Actualité**
+**Actualités**
 
-- [BeInCrypto](http://www.beincrypto.com.br) - articles sur l'actualité des cryptomonnaies, avec une liste de plateformes d'échange disponibles au Brésil
-- [Cointelegraph](http://cointelegraph.com.br/category/analysis) - version brésilienne de Cointelegraph, un des principaux médias sur les cryptomonnaies
-- [Livecoins](http://www.livecoins.com.br/ethereum) - actualités et outils de cryptomonnaies
-- [Seudinheiro](http://www.seudinheiro.com/criptomoedas/) - actualités et informations sur les cryptomonnaies
-- [Modular Crypto](https://modularcrypto.xyz/) - Actualité des cryptomonnaies et articles éducatifs
+- [BeInCrypto](http://www.beincrypto.com.br) - actualités et articles sur les cryptomonnaies, y compris une liste d'échanges, disponibles au Brésil
+- [Cointelegraph](http://cointelegraph.com.br/category/analysis) - version brésilienne de Cointelegraph, un important média d'information sur les cryptomonnaies
+- [Livecoins](http://www.livecoins.com.br/ethereum) - actualités et outils sur les cryptomonnaies
+- [Seudinheiro](http://www.seudinheiro.com/criptomoedas/) - actualités et rapports sur les cryptomonnaies
+- [Modular Crypto](https://modularcrypto.xyz/) - actualités et articles éducatifs sur les cryptomonnaies
 
-**Formation**
+**Éducation**
 
-- [web3dev](https://www.web3dev.com.br/) - ressources de contenu et communauté Discord pour les développeurs Web3.
+- [web3dev](https://www.web3dev.com.br/) - Pôle de contenu et communauté Discord pour les développeurs web 3.
 - [Web3Brasil](https://github.com/web3brasil/web3brasil) - ressources pour apprendre le Web3 et la DeFi
-- [CriptoFacil](http://www.criptofacil.com/ultimas-noticias/) - informations et ressources éducatives sur les cryptomonnaies, notamment « Ethereum pour les débutants » et « La DeFi pour les débutants »
-- [CriptoAtivos](http://www.criptoativos.wiki.br/) - informations sur l'univers des cryptomonnaies, ainsi que des ressources éducatives et un blog
-- [Cointimes](http://www.cointimes.com.br/) - informations et ressources éducatives sur les cryptomonnaies
-- [Pack de démarrage Web3](https://docs.google.com/document/d/1X8PSTFH7FTw9J-gbKWM6Y430SWCBT8d4t4pJgFQHJ8E/) - un guide répondant aux questions crypto les plus fréquemment posées et les plus fondamentales
+- [CriptoFacil](http://www.criptofacil.com/ultimas-noticias/) - actualités et éducation sur les cryptomonnaies, y compris « Ethereum pour les débutants » et « DeFi pour les débutants »
+- [CriptoAtivos](http://www.criptoativos.wiki.br/) - informations sur l'espace des cryptomonnaies, éducation et blog
+- [Cointimes](http://www.cointimes.com.br/) - actualités et éducation sur les cryptomonnaies
+- [Web3 starter pack](https://docs.google.com/document/d/1X8PSTFH7FTw9J-gbKWM6Y430SWCBT8d4t4pJgFQHJ8E/) - un guide répondant aux questions les plus fréquentes et fondamentales sur la crypto
 
 ### Chinois {#zh}
 
 **Ressources générales**
 
-- [Ethereum.cn](https://www.ethereum.cn/) - contenu maintenu par la communauté, couvrant la mise à jour de la couche de consensus, l'intégralité des notes de réunion de l'équipe de développement, la couche 2, etc.
-- [EthFans](https://github.com/editor-Ajian/EthFans.org-annual-collected-works/) - tout apprendre, des bases aux sujets avancés d'Ethereum
-- [Unitimes](https://mp.weixin.qq.com/s/tvloZSDBSOQN9zDQj_91kA) - contenu maintenu par la communauté, couvrant Ethereum, la DeFi, les NFT, ainsi que des ressources liées au Web3
+- [Ethereum.cn](https://www.ethereum.cn/) - contenu maintenu par la communauté, couvrant la mise à niveau de la couche de consensus, toutes les notes de réunion des développeurs principaux, la couche 2, etc.
+- [EthFans](https://github.com/editor-Ajian/EthFans.org-annual-collected-works/) - apprenez tout, des bases aux sujets avancés sur Ethereum
+- [Unitimes](https://mp.weixin.qq.com/s/tvloZSDBSOQN9zDQj_91kA) - contenu maintenu par la communauté, couvrant Ethereum, la DeFi, les NFT et les connaissances liées au Web3
 - [123ETH](https://123eth.org/) - un portail vers l'écosystème Ethereum
 - [Zhen Xiao](http://zhenxiao.com/blockchain/) - cours en ligne gratuits sur la cryptomonnaie et ses applications
-- [Livre blanc d'Ethereum](https://ethereum.org/whitepaper//[%E4%B8%AD%E6%96%87]-%E4%BB%A5%E5%A4%AA%E5%9D%8A%E7%99%BD%E7%9A%AE%E4%B9%A6) - version chinoise du livre blanc d'Ethereum
 
 **Écosystème Ethereum**
 
-- [ETHPlanet](https://www.ethplanet.org/) - hackathons en ligne et sur place, proposant un entraînement aux étudiants universitaires
-- [PrimitivesLane](https://www.primitiveslane.org/) - un groupe de recherche à but non lucratif, axée sur la technologie blockchain
-- [Ethereum Translation Community CN](https://www.notion.so/Ethereum-Translation-Community-CN-05375fe0a94c4214acaf90f42ba40171) - communauté consacrée à la traduction de contenu éducatif sur Ethereum
+- [ETHPlanet](https://www.ethplanet.org/) - hackathons en ligne et en personne, proposant des formations aux étudiants universitaires
+- [PrimitivesLane](https://www.primitiveslane.org/) - un groupe de recherche à but non lucratif, axé sur la technologie blockchain
+- [Communauté de traduction chinoise d'Ethereum](https://www.notion.so/Ethereum-Translation-Community-CN-05375fe0a94c4214acaf90f42ba40171) - une communauté consacrée à la traduction de contenu éducatif sur Ethereum
 
 **Pour les développeurs**
 
-- [DappLearning](https://github.com/Dapp-Learning-DAO/Dapp-Learning) - un groupe d'apprentissage pour étudier les principaux projets dApp, échanger et partager des idées et des observations sur une base hebdomadaire
-- [LearnBlockchain](https://learnblockchain.cn/) - une communauté pour les développeurs, pour partager des informations autour de la technologie blockchain
+- [DappLearning](https://github.com/Dapp-Learning-DAO/Dapp-Learning) - un groupe d'apprentissage pour étudier les projets de dapps grand public et partager des réflexions et des commentaires chaque semaine
+- [LearnBlockchain](https://learnblockchain.cn/) - une communauté pour les développeurs, partageant des informations sur la technologie blockchain
 
 **Pour les chercheurs en cryptographie**
 
-- [SecbitLabs](https://mp.weixin.qq.com/s/69_tqBJpr_sbaKtR1sBRMw) - un groupe WeChat à propos de la cryptographie, de la sécurité, etc.
-- [Sparkbyte](https://mp.weixin.qq.com/s/9KgKTc_jtJ7bWKdbNPoqvQ) - un groupe WeChat à propos de la technologie ZK
+- [SecbitLabs](https://mp.weixin.qq.com/s/69_tqBJpr_sbaKtR1sBRMw) - un compte WeChat, expliquant la cryptographie, la sécurité, etc.
+- [Sparkbyte](https://mp.weixin.qq.com/s/9KgKTc_jtJ7bWKdbNPoqvQ) - un compte WeChat, expliquant la technologie zk
 
 ### Tchèque {#cs}
 
-- [Gwei.cz](https://gwei.cz) - communauté locale autour du Web3, création du contenu éducatif, organisation des événements en ligne et en présentiel
-- [Gwei.cz Příručka](https://prirucka.gwei.cz/) - guide Ethereum pour débutants
-- [DAO Příručka](https://dao.gwei.cz/) - guide pour débutants en DAO
-- [Maîtriser Ethereum](https://ipfs.io/ipfs/bafybeidvuxhnsgfx3tncpfxheqglkjwmdxclknlgd7s7qggd2a6bzgb27m) - Maîtriser Ethereum en tchèque
+- [Gwei.cz](https://gwei.cz) - communauté locale autour du Web3, crée du contenu éducatif, organise des événements en ligne et en personne
+- [Gwei.cz Příručka](https://prirucka.gwei.cz/) - guide Ethereum pour les débutants
+- [DAO Příručka](https://dao.gwei.cz/) - guide du débutant pour les DAO
+- [Mastering Ethereum](https://ipfs.io/ipfs/bafybeidvuxhnsgfx3tncpfxheqglkjwmdxclknlgd7s7qggd2a6bzgb27m) - Mastering Ethereum en tchèque
 
 ### Français {#fr}
 
-- [Ethereum France](https://www.ethereum-france.com/) - Ethereum France organise des événements, crée du contenu et favorise les échanges autour d'Ethereum
-- [Ethereum.fr](https://ethereum.fr/) - actualité et ressources éducatives sur Ethereum
-- [BanklessFR](https://banklessfr.substack.com/) - lettre d'information de Bankless en français
-- [CryptoFR](https://cryptofr.com/category/44/ethereum-general) - forum sur les cryptomonnaies avec une rubrique consacrée à l'Ethereum
+- [Ethereum France](https://www.ethereum-france.com/) - Ethereum France organise des événements, crée du contenu et encourage les discussions autour d'Ethereum
+- [Ethereum.fr](https://ethereum.fr/) - actualités et éducation sur Ethereum
+- [BanklessFR](https://banklessfr.substack.com/) - newsletter Bankless en français
+- [CryptoFR](https://cryptofr.com/category/44/ethereum-general) - forum sur les cryptomonnaies avec une sous-page Ethereum
 
 ### Allemand {#de}
 
-- [Microsoft Learn (Solidity)](https://docs.microsoft.com/de-de/learn/modules/blockchain-learning-solidity/) - utiliser Solidity
-- [Microsoft Learn (smart contracts)](https://docs.microsoft.com/de-de/learn/modules/blockchain-solidity-ethereum-smart-contracts/) - écrire des contrats intelligents Ethereum avec Solidity
-- [Microsoft Learn (Ethereum networks)](https://docs.microsoft.com/de-de/learn/modules/blockchain-ethereum-networks/) - se connecter et déployer des réseaux Ethereum
-- [Microsoft Learn (blockchains)](https://docs.microsoft.com/de-de/learn/paths/ethereum-blockchain-development/) - introduction au développement de la blockchain
+- [Microsoft Learn (Solidity)](https://docs.microsoft.com/de-de/learn/modules/blockchain-learning-solidity/) - utilisation de Solidity
+- [Microsoft Learn (contrats intelligents)](https://docs.microsoft.com/de-de/learn/modules/blockchain-solidity-ethereum-smart-contracts/) - rédiger des contrats intelligents Ethereum avec Solidity
+- [Microsoft Learn (réseaux Ethereum)](https://docs.microsoft.com/de-de/learn/modules/blockchain-ethereum-networks/) - se connecter et déployer des réseaux Ethereum
+- [Microsoft Learn (blockchains)](https://docs.microsoft.com/de-de/learn/paths/ethereum-blockchain-development/) - introduction au développement blockchain
 
 ### Hébreu {#he}
 
-- [Udi Wertheimer - Ce que les utilisateurs Bitcoin peuvent apprendre d'Ethereum](https://www.cryptojungle.co.il/udi-wertheimer-what-bitcoiners-can-learn-from-ethereum/)
-- [Omer Greismen (OpenZeppelin) - Comment nous avons évité le piratage d'un contrat intelligent d'une valeur de 15 milliards de dollars](https://www.cryptojungle.co.il/omer-greisman-openzeppelin/)
-- [Timide Datika (INX) - Tokenisation et le futur de la sécurité, incluant la sécurité Ethereum](https://www.cryptojungle.co.il/shy-datika-tokenization/)
-- [Roy Confino (Limonade) - Assurance @ Ethereum](https://www.cryptojungle.co.il/roy-confino-insurance/)
-- [Idan Ofrat (Fireblocks) - Adoption Institutionnel](https://www.cryptojungle.co.il/idan-ofrat-fireblocks/)
-- [Gal Weizman (MetaMask) - Qu'est-ce que MetaMask](https://www.cryptojungle.co.il/gal-weizman-metamask/)
+- [Udi Wertheimer - Ce que les bitcoineurs peuvent apprendre d'Ethereum](https://www.cryptojungle.co.il/udi-wertheimer-what-bitcoiners-can-learn-from-ethereum/)
+- [Omer Greismen (OpenZeppelin) - Comment nous avons empêché le piratage d'un contrat intelligent de 15 milliards de dollars](https://www.cryptojungle.co.il/omer-greisman-openzeppelin/)
+- [Shy Datika (INX) - La tokenisation et l'avenir des titres, et la question de savoir si Ethereum est un titre](https://www.cryptojungle.co.il/shy-datika-tokenization/)
+- [Roy Confino (Lemonade) - L'assurance sur Ethereum](https://www.cryptojungle.co.il/roy-confino-insurance/)
+- [Idan Ofrat (Fireblocks) - Adoption institutionnelle](https://www.cryptojungle.co.il/idan-ofrat-fireblocks/)
+- [Gal Weizman (MetaMask) - Qu'est-ce que MetaMask ?](https://www.cryptojungle.co.il/gal-weizman-metamask/)
 - [Dror Aviely (Consensys) - Le centre d'Ethereum](https://www.cryptojungle.co.il/dror-aviely-ethereum-center/)
-- [Nir Rozin - Être un Cryptopunk](https://www.cryptojungle.co.il/nir-rozin-cryptopunk/)
-- [Adan Kedem - Jeux video & Metaverse](https://www.cryptojungle.co.il/adan-kedem-web3-gaming/)
-- [Uri Kolodny (Starkware) - Ethereum et les couches de la blockchain](https://www.cryptojungle.co.il/uri-kolodny-starkware/)
+- [Nir Rozin - Être un cryptopunk](https://www.cryptojungle.co.il/nir-rozin-cryptopunk/)
+- [Adan Kedem - Jeux et métavers](https://www.cryptojungle.co.il/adan-kedem-web3-gaming/)
+- [Uri Kolodny (Starkware) - Les couches d'Ethereum et de la blockchain](https://www.cryptojungle.co.il/uri-kolodny-starkware/)
 - [Udi Wertheimer - Ethereum 2.0 face à la concurrence](https://www.cryptojungle.co.il/udi-on-eth2/)
-- [Ben Samocha (moi-même) - Ethereum 2.0 - une opportunité ?](https://www.cryptojungle.co.il/etherurm2-week-summary/)
-- [Alon Muroch (Bloxstaking) - Qu'est-ce qu'Ethereum 2.0 ?](https://www.cryptojungle.co.il/alon-moroch-eth2/)
-- [Eilon Aviv (Collider Ventures) - Les risques potentiels d'Ethereum 2.0](https://www.cryptojungle.co.il/eilon-aviv-eth2-0/)
-- [Eilon Aviv (Collider Ventures) - Pouquoi avons-nous besoin d'Ethereum 2.0](https://www.cryptojungle.co.il/eilon-aviv-ethereum-2-0/)
+- [Ben Samocha (moi-même) - Ethereum 2.0 - une opportunité ?](https://www.cryptojungle.co.il/etherurm2-week-summary/)
+- [Alon Muroch (Bloxstaking) - Qu'est-ce qu'Ethereum 2.0 ?](https://www.cryptojungle.co.il/alon-moroch-eth2/)
+- [Eilon Aviv (Collider Ventures) - Qu'est-ce qui peut mal tourner avec Ethereum 2.0](https://www.cryptojungle.co.il/eilon-aviv-eth2-0/)
+- [Eilon Aviv (Collider Ventures) - Pourquoi avons-nous besoin d'Ethereum 2.0](https://www.cryptojungle.co.il/eilon-aviv-ethereum-2-0/)
 
 ### Italien {#it}
 
-- [Ethereum Italia](https://www.ethereum-italia.it/) - formations, événements et actualités Ethereum, axés sur les contrats intelligents et la technologie blockchain
-- [Ethereum Italia Podcast](https://www.ethereum-italia.it/podcast/) - podcast sur Ethereum en italien
-- [Microsoft Learn (Solidity)](https://docs.microsoft.com/it-it/learn/modules/blockchain-learning-solidity/) - apprendre à utiliser Solidity
-- [Microsoft Learn (Smart contracts)](https://docs.microsoft.com/it-it/learn/modules/blockchain-solidity-ethereum-smart-contracts/) - écrire des contrats intelligents Ethereum avec Solidity
-- [Microsoft Learn (dApps)](https://docs.microsoft.com/it-it/learn/modules/blockchain-create-ui-decentralized-apps/) - créer une interface utilisateur avec des applications décentralisées
+- [Ethereum Italia](https://www.ethereum-italia.it/) - éducation, événements et actualités sur Ethereum, axés sur les contrats intelligents et la technologie blockchain
+- [Podcast Ethereum Italia](https://www.ethereum-italia.it/podcast/) - podcast Ethereum en italien
+- [Microsoft Learn (Solidity)](https://docs.microsoft.com/it-it/learn/modules/blockchain-learning-solidity/) - apprenez à utiliser Solidity
+- [Microsoft Learn (Contrats intelligents)](https://docs.microsoft.com/it-it/learn/modules/blockchain-solidity-ethereum-smart-contracts/) - apprenez à rédiger des contrats intelligents en utilisant Solidity
+- [Microsoft Learn (dapps)](https://docs.microsoft.com/it-it/learn/modules/blockchain-create-ui-decentralized-apps/) - créer une interface utilisateur avec des applications décentralisées
 
 ### Japonais {#ja}
 
-- [Association japonaise d'échange d'actifs virtuels et de cryptomonnaies (JVCEA)](https://jvcea.or.jp/)
-- [Association des entreprises de cryptoactifs du Japon (JCBA)](https://cryptocurrency-association.org/)
-- [Get started with blockchain development - Learn | Microsoft Docs](https://docs.microsoft.com/ja-jp/learn/paths/ethereum-blockchain-development/) - Ce parcours vous initie à la blockchain et au développement sur la plateforme Ethereum
-- [Mastering Ethereum](https://www.oreilly.co.jp/books/9784873118963/) - Livre « Mastering Ethereum » en japonais
-- [Hands-On Smart Contract Development with Solidity and Ethereum](https://www.oreilly.co.jp/books/9784873119342/) - Livre « Hands-On Smart Contract Development with Solidity and Ethereum » en japonais
+- [Association japonaise d'échange d'actifs virtuels et de crypto-actifs](https://jvcea.or.jp/)
+- [Association japonaise des entreprises de crypto-actifs](https://cryptocurrency-association.org/)
+- [Débuter avec le développement blockchain - Learn | Microsoft Docs](https://docs.microsoft.com/ja-jp/learn/paths/ethereum-blockchain-development/) - Ce parcours d'apprentissage vous présente la blockchain et le développement sur la plateforme Ethereum
+- [Mastering Ethereum](https://www.oreilly.co.jp/books/9784873118963/) - Mastering Ethereum en japonais
+- [Hands-On Smart Contract Development with Solidity and Ethereum](https://www.oreilly.co.jp/books/9784873119342/) - Hands-On Smart Contract Development with Solidity and Ethereum en japonais
 
 ### Russe {#ru}
 
-- [Cyber Academy](https://cyberacademy.dev) - espace éducatif pour les constructeurs web3
-- [Forklog](https://forklog.com) - nouveautés et articles à but pédagogique sur la cryptomonnaie en général, les technologies existantes et les futurs mises à jour des différentes blockchains
-- [BeInCrypto](https://ru.beincrypto.com) - nouveautés, analyse des prix des cryptomonnaies et articles non-technique avec explications simples sur tout ce qui concerne la crypto
+- [Cyber Academy](https://cyberacademy.dev) - espace éducatif pour les bâtisseurs web3
+- [Forklog](https://forklog.com) - actualités et articles éducatifs sur la crypto en général, les technologies existantes et les futures mises à niveau de différentes blockchains
+- [BeInCrypto](https://ru.beincrypto.com) - actualités, analyse des prix des cryptos et articles non techniques avec des explications simples sur tout ce qui concerne la crypto
 
 ### Espagnol {#es}
 
-- [Ethereum Madrid](https://ethereummadrid.com/) - cours, événements et blog sur la gouvernance, la DeFi et la blockchain
-- [Cointelegraph](https://es.cointelegraph.com/ethereum-for-beginners) - guide Ethereum en espagnol pour les débutants
-- [Tutoriales online](https://tutoriales.online/curso/solidity) - apprendre Solidity et programmer sur Ethereum
-- [Curso Introducción a Ethereum Development](https://youtube.com/playlist?list=PLTqiwJDd_R8y9pfUBjhkVa1IDMwyQz-fU) - Les bases de Solidity, le test et le deploiement de votre premier contrat intelligent
-- [Curso Introducción a Seguridad y Hacking en Ethereum](https://youtube.com/playlist?list=PLTqiwJDd_R8yHOvteko_DmUxUTMHnlfci) - comprendre les vulnérabilités communes et les failles de sécurité dans les contrats intelligents réels
-- [Curso Introducción a DeFi Development](https://youtube.com/playlist?list=PLTqiwJDd_R8zZiP9_jNdaPqA3HqoW2lrS) - apprendre comment les contrats intelligents DeFi fonctionnent avec Solidity et créer votre propre Automated Market Maker
-- [Cryptoversidad](https://www.youtube.com/c/Cryptoversidad) - ressources d'éducation non-technique sur la blockchain, de débutant à confirmé. Tout savoir sur les crypto-monnaies et Ethereum.
+- [Ethereum Madrid](https://ethereummadrid.com/) - cours, événements et blog sur la blockchain, la DeFi et la gouvernance
+- [Cointelegraph](https://es.cointelegraph.com/ethereum-for-beginners) - guide Ethereum pour débutants en espagnol
+- [Tutoriales online](https://tutoriales.online/curso/solidity) - apprenez Solidity et la programmation sur Ethereum
+- [Curso Introducción a Ethereum Development](https://youtube.com/playlist?list=PLTqiwJDd_R8y9pfUBjhkVa1IDMwyQz-fU) - les bases de Solidity, le test et le déploiement de votre premier contrat intelligent
+- [Curso Introducción a Seguridad y Hacking en Ethereum](https://youtube.com/playlist?list=PLTqiwJDd_R8yHOvteko_DmUxUTMHnlfci) - comprendre les vulnérabilités courantes et les problèmes de sécurité des contrats intelligents réels
+- [Curso Introducción a DeFi Development](https://youtube.com/playlist?list=PLTqiwJDd_R8zZiP9_jNdaPqA3HqoW2lrS) - apprenez comment fonctionnent les contrats intelligents DeFi dans Solidity et créez votre propre teneur de marché automatisé
+- [Cryptoversidad](https://www.youtube.com/c/Cryptoversidad) - Éducation non technique à la blockchain, du niveau débutant à avancé. Tout savoir sur les crypto-monnaies et Ethereum.
 
 ### Turc {#tr}
 
-- [BTK Akademi](https://www.btkakademi.gov.tr/portal/course/blokzincir-ve-kripto-paralar-10569#!/about) - cours axés sur la cryptomonnaie et la blockchain
-- [The great renaming: what happened to Eth2?](https://miningturkiye.org/konu/ethereum-madenciligi-bitiyor-mu-onemli-gelisme.655/) - traduction turque du grand blog de renommage, expliquant l'abandon de la terminologie « Eth2 »
+- [BTK Akademi](https://www.btkakademi.gov.tr/portal/course/blokzincir-ve-kripto-paralar-10569#!/about) - cours axé sur la blockchain et la cryptomonnaie
+- [Le grand changement de nom : qu'est-il arrivé à Eth2 ?](https://miningturkiye.org/konu/ethereum-madenciligi-bitiyor-mu-onemli-gelisme.655/) - traduction turque de l'article de blog sur le grand changement de nom, expliquant l'abandon de la terminologie « Eth2 »
 
 ### Vietnamien {#vi}
 
-- [Tino Group](https://wiki.tino.org/ethereum-la-gi/) - aperçu d'Ethereum, des dApps, portefeuilles et FAQ
-- [Tap Chi Bitcoin](https://tapchibitcoin.io/tap-chi/tin-tuc-ethereum-eth) - plateforme Web comportant des rubriques consacrées à l'actualité et aux ressources éducatives sur Ethereum
-- [Coin68](https://coin68.com/ethereum-tieu-diem/) - portail sur les cryptomonnaies comportant des ressources éducatives et l'actualité relative à Ethereum
+- [Tino Group](https://wiki.tino.org/ethereum-la-gi/) - aperçu d'Ethereum, des dapps, des portefeuilles et FAQ
+- [Tap Chi Bitcoin](https://tapchibitcoin.io/tap-chi/tin-tuc-ethereum-eth) - plateforme web avec des sous-pages pour les actualités et l'éducation sur Ethereum
+- [Coin68](https://coin68.com/ethereum-tieu-diem/) - portail de cryptomonnaies avec des actualités et du contenu éducatif sur Ethereum
diff --git a/public/content/translations/fr/community/online/index.md b/public/content/translations/fr/community/online/index.md
index 33f121ec407..38ff2cf316b 100644
--- a/public/content/translations/fr/community/online/index.md
+++ b/public/content/translations/fr/community/online/index.md
@@ -1,6 +1,6 @@
 ---
-title: Communautés en ligne
-description: Une liste des programmes de subventions pour l'écosystème Ethereum.
+title: "Communautés en ligne"
+description: "Découvrez des forums en ligne, des salons de discussion et des communautés sur les réseaux sociaux où les passionnés d’Ethereum se réunissent pour échanger et collaborer."
 lang: fr
 ---
 
@@ -8,69 +8,66 @@ lang: fr
 
 Des centaines de milliers de passionnés d'Ethereum se rassemblent sur ces forums en ligne pour partager l'actualité, discuter des derniers développements, débattre de questions techniques et imaginer l'avenir.
 
-## Règles de listage {#listing-policy}
+## Politique de référencement {#listing-policy}
 
 Pour maintenir l'intégrité et la valeur des communautés listées, ethereum.org suit une politique stricte pour déterminer l'éligibilité :
 
-### Critère d'éligibilité {#eligibility-criteria}
+### Critères d'éligibilité {#eligibility-criteria}
 
 - **Pertinence** : La communauté doit être directement liée à Ethereum et à son écosystème.
-- **Niveau d'activité** : La communauté doit être active, avec des interactions, publications ou discussions régulières. Les communautés dormantes ou inactives peuvent être supprimées.
+- **Niveau d'activité** : La communauté doit être active, avec des interactions, des publications ou des discussions régulières. Les communautés dormantes ou inactives peuvent être supprimées.
 - **Inclusivité** : La communauté doit favoriser un environnement accueillant qui respecte la diversité et encourage la participation de personnes de tous horizons.
-- **Orientation non commerciale** : Les listings sont destinés aux espaces communautaires plutôt qu'aux plateformes commerciales ou promotionnelles.
+- **Orientation non commerciale** : Les référencements sont destinés à des espaces communautaires plutôt qu'à des plateformes commerciales ou promotionnelles.
 
-### Directives relatives au contenu {#content-guidelines}
+### Directives sur le contenu {#content-guidelines}
 
-- **Contenu approprié** : Les communautés doivent disposer de leurs propres lignes directrices de modération, évitant le spam, les discours de haine, le harcèlement ou tout contenu promouvant des activités illégales.
+- **Contenu approprié** : Les communautés doivent avoir leurs propres directives de modération, en évitant le spam, les discours de haine, le harcèlement ou tout contenu faisant la promotion d'activités illégales.
 - **Langue** : Bien que l'anglais soit la langue principale, les communautés dans d'autres langues sont encouragées à soumettre leur candidature tant qu'elles maintiennent une atmosphère inclusive et respectueuse.
 - **Transparence** : Des informations claires sur l'objectif, les règles et les modérateurs de la communauté doivent être disponibles pour les membres.
 
-### Recommandations complémentaires {#other-recommendations}
+### Autres recommandations {#other-recommendations}
 
 - **Accessibilité** : Les forums communautaires doivent être accessibles à tous pour lecture sans inscription ou enregistrement.
-- **Invitations sur les serveurs Discord** : Il est recommandé de n'ajouter que des invitations fiables sur les serveurs Discord sur ethereum.org. Idéalement, ces invitations devraient renvoyer à une page communautaire sur le site web (par exemple, [ethglobal.com/discord](https://ethglobal.com/discord)) ou provenir d'une URL officielle (par exemple, [discord.gg/ethstaker](https://discord.gg/ethstaker) ou [discord.com/invite/ethstaker](https://discord.com/invite/ethstaker)).
-
-Si vous pensez qu'une communauté devrait être ajoutée ou supprimée selon ces directives, veuillez [ouvrir un ticket dans notre dépôt GitHub](https://github.com/ethereum/ethereum-org-website/issues).
+- **Invitations au serveur Discord** : Il est recommandé que seules des invitations fiables à un serveur Discord soient ajoutées à ethereum.org. Idéalement, ces invitations devraient renvoyer vers une page de la communauté sur le site web (par exemple, [ethglobal.com/discord](https://ethglobal.com/discord)) ou provenir d'une URL officielle (par exemple, [discord.gg/ethstaker](https://discord.gg/ethstaker) ou [discord.com/invite/ethstaker](https://discord.com/invite/ethstaker)).
 
+Si vous pensez qu'une communauté devrait être ajoutée ou supprimée sur la base de ces directives, veuillez [ouvrir un ticket sur notre dépôt GitHub](https://github.com/ethereum/ethereum-org-website/issues).
 
 ## Forums {#forums}
 
-<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethereum">r/ethereum</Link> - tout sur Ethereum</SocialListItem>
-<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethfinance/">r/ethfinance</Link> - le côté financier d'Ethereum, y compris DeFi</SocialListItem>
-<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethdev/">r/ethdev</Link> - axé sur le développement Ethereum</SocialListItem>
-<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethtrader/">r/ethtrader</Link> - tendances & analyse de marché</SocialListItem>
-<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethstaker/">r/ethstaker</Link> - bienvenue à tous ceux qui s'intéressent au staking sur Ethereum</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://ethereum-magicians.org">Fellowship of Ethereum Magicians</Link> - communauté axée sur les normes techniques sur Ethereum</SocialListItem>
+<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethereum">r/ethereum</Link> - tout ce qui concerne Ethereum</SocialListItem>
+<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethfinance/">r/ethfinance</Link> - l'aspect financier d'Ethereum, y compris la DeFi</SocialListItem>
+<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethdev/">r/ethdev</Link> - axé sur le développement d'Ethereum</SocialListItem>
+<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethtrader/">r/ethtrader</Link> - tendances et analyse du marché</SocialListItem>
+<SocialListItem socialIcon="reddit"><Link href="https://www.reddit.com/r/ethstaker/">r/ethstaker</Link> - bienvenue à tous ceux qui s'intéressent à la mise en jeu sur Ethereum</SocialListItem>
+<SocialListItem socialIcon="webpage"><Link href="https://ethereum-magicians.org">Fellowship of Ethereum Magicians</Link> - communauté orientée autour des normes techniques dans Ethereum</SocialListItem>
 <SocialListItem socialIcon="stackExchange"><Link href="https://ethereum.stackexchange.com">Ethereum Stackexchange</Link> - discussion et aide pour les développeurs Ethereum</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://ethresear.ch">Ethereum Research</Link> - le forum le plus influent de la recherche cryptoéconomique</SocialListItem>
+<SocialListItem socialIcon="webpage"><Link href="https://ethresear.ch">Ethereum Research</Link> - le forum de discussion le plus influent pour la recherche en cryptoéconomie</SocialListItem>
 
 ## Salons de discussion {#chat-rooms}
 
-<SocialListItem socialIcon="discord"><Link href="https://discord.com/invite/Nz6rtfJ8Cu">Ethereum Cat Herders</Link> - communauté orientée autour de l'offre de soutien à la gestion de projet concernant le développement d'Ethereum</SocialListItem>
-<SocialListItem socialIcon="discord"><Link href="https://ethglobal.com/discord">Hackers Ethereum</Link> - Salon Discord administré par ETHGlobal : une communauté en ligne pour les hackers Ethereum dans le monde entier</SocialListItem>
-<SocialListItem socialIcon="discord"><Link href="https://discord.gg/5W5tVb3">CryptoDevs</Link> - Communauté Discord axée sur le développement Ethereum</SocialListItem>
-<SocialListItem socialIcon="discord"><Link href="https://discord.gg/ethstaker">Le serveur Discord d'EthStaker</Link> - orientation par la communauté, éducation, soutien et ressources pour les stakeurs et stakeurs potentiels.</SocialListItem>
-<SocialListItem socialIcon="discord"><Link href="https://discord.gg/ethereum-org">Équipe du site web Ethereum.org</Link> - consultez et discutez du développement et du design du site web ethereum.org avec l'équipe et les membres de la communauté</SocialListItem>
-<SocialListItem socialIcon="discord"><Link href="https://discord.matos.club/">Discord Matos</Link> - Communauté de créateurs Web3 où les bâtisseurs, les chefs de file industriels et les passionnés d'Ethereum se rencontrent. Nous sommes passionnés par le développement du Web3, sa conception et sa culture. Venez le bâtir avec nous.</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://app.element.io/#/room/#solidity:matrix.org">Solidity Matrix</Link> - forum de discussion pour le développement Solidity (Gitter)</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://matrix.to/#/#ethereum_solidity:gitter.im">Solidity Matrix</Link> - forum de discussion pour le développement Solidity (Matrix)</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://ethereum.stackexchange.com/">Ethereum Stack Exchange</Link> *- forum de questions-réponses*</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://app.peera.ai/">Forum communautaire Peera</Link> *- forum décentralisé de questions-réponses*</SocialListItem>
+<SocialListItem socialIcon="discord"><Link href="https://discord.com/invite/Nz6rtfJ8Cu">Ethereum Cat Herders</Link> - communauté orientée autour du soutien à la gestion de projet pour le développement d'Ethereum</SocialListItem>
+<SocialListItem socialIcon="discord"><Link href="https://ethglobal.com/discord">Ethereum Hackers</Link> - chat Discord géré par ETHGlobal : une communauté en ligne pour les hackers Ethereum du monde entier</SocialListItem>
+<SocialListItem socialIcon="discord"><Link href="https://discord.gg/5W5tVb3">CryptoDevs</Link> - communauté Discord axée sur le développement d'Ethereum</SocialListItem>
+<SocialListItem socialIcon="discord"><Link href="https://discord.gg/ethstaker">EthStaker Discord</Link> - conseils, éducation, soutien et ressources gérés par la communauté pour les validateurs actuels et potentiels</SocialListItem>
+<SocialListItem socialIcon="discord"><Link href="https://discord.gg/ethereum-org">Ethereum.org website team</Link> - passez discuter du développement web et du design d'ethereum.org avec l'équipe et les membres de la communauté</SocialListItem>
+<SocialListItem socialIcon="discord"><Link href="https://discord.matos.club/">Matos Discord</Link> - communauté de créateurs web3 où les bâtisseurs, les figures de proue de l'industrie et les passionnés d'Ethereum se retrouvent. Nous sommes passionnés par le développement du Web3, sa conception et sa culture. Venez bâtir avec nous.</SocialListItem>
+<SocialListItem socialIcon="webpage"><Link href="https://matrix.to/#/#ethereum_solidity:gitter.im">Solidity Matrix</Link> - chat pour le développement Solidity (Matrix)</SocialListItem>
+<SocialListItem socialIcon="webpage"><Link href="https://ethereum.stackexchange.com/">Ethereum Stack Exchange</Link> <i>- forum de questions et réponses</i></SocialListItem>
+<SocialListItem socialIcon="webpage"><Link href="https://app.peera.ai/">Peera Community Forum</Link> <i>- forum de questions et réponses décentralisé</i></SocialListItem>
 
 ## YouTube et X (anciennement Twitter) {#youtube-and-twitter}
 
-<SocialListItem socialIcon="youtube"><Link href="https://www.youtube.com/c/EthereumFoundation">Ethereum Foundation</Link> - Tenez-vous au courant des dernières nouvelles de la fondation Ethereum</SocialListItem>
-<SocialListItem socialIcon="twitter"><Link href="https://x.com/ethereum">@ethereum</Link> - Compte principal Ethereum pour la communauté</SocialListItem>
+<SocialListItem socialIcon="youtube"><Link href="https://www.youtube.com/c/EthereumFoundation">Ethereum Foundation</Link> - Restez à jour avec les dernières nouvelles de la Fondation Ethereum</SocialListItem>
+<SocialListItem socialIcon="twitter"><Link href="https://x.com/ethereum">@ethereum</Link> - Compte Ethereum principal pour la communauté</SocialListItem>
 <SocialListItem socialIcon="twitter"><Link href="https://x.com/ethereumfndn">@ethereumfndn</Link> - Compte officiel de la Fondation Ethereum</SocialListItem>
-<SocialListItem socialIcon="twitter"><Link href="https://x.com/ethdotorg">@ethdotorg</Link> - Le portail vers Ethereum, construit pour notre communauté mondiale grandissante</SocialListItem>
-<SocialListItem socialIcon="webpage"><Link href="https://hive.one/c/ethereum?page=1">Liste des comptes Twitter Ethereum influents</Link></SocialListItem>
+<SocialListItem socialIcon="twitter"><Link href="https://x.com/ethdotorg">@ethdotorg</Link> - Le portail vers Ethereum, construit pour notre communauté mondiale en pleine croissance</SocialListItem>
 
 <Divider />
 
 <Callout emoji=":classical_building:" titleKey="page-community:page-community-daos-callout-title" descriptionKey="page-community:page-community-daos-callout-description">
   <div>
     <ButtonLink href="/community/get-involved/#decentralized-autonomous-organizations-daos">
-      En savoir plus sur les DAOs
+      En savoir plus sur les DAO
     </ButtonLink>
-  </div>
+</div>
 </Callout>
diff --git a/public/content/translations/fr/community/research/index.md b/public/content/translations/fr/community/research/index.md
index 652c92be405..ad94a0bf328 100644
--- a/public/content/translations/fr/community/research/index.md
+++ b/public/content/translations/fr/community/research/index.md
@@ -1,6 +1,6 @@
 ---
 title: Les domaines de recherche actifs d'Ethereum
-description: Explorez les différents domaines de la recherche ouverte et apprenez comment y participer.
+description: "Explorez les différents domaines de la recherche ouverte et apprenez comment y participer."
 lang: fr
 ---
 
@@ -39,7 +39,7 @@ Outre des recherches prospectives, certaines refontes fondamentales du protocole
 
 #### Lecture de fond {#background-reading}
 
-- [Introduction à la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
+- Introduction à la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
 - [Article Casper-FFG](https://arxiv.org/abs/1710.09437)
 - [Explication Casper-FFG](https://medium.com/unitychain/intro-to-casper-ffg-9ed944d98b2d)
 - [Article Gasper](https://arxiv.org/abs/2003.03052)
@@ -57,7 +57,7 @@ La couche d'exécution est chargée d'exécuter les transactions, d'exécuter la
 
 - développement d'un support client léger ;
 - Recherche sur les limites de gaz ;
-- et incorporation de nouvelles structures de données (exemple : Verkle Tries).
+- et en incorporant de nouvelles structures de données (p. ex., les arbres de Verkle).
 
 #### Lecture de fond {#background-reading-1}
 
@@ -83,14 +83,14 @@ Un nœud Ethereum est nécessaire pour faire fonctionner deux logiciels :
 1. un client de consensus chargé de suivre la tête de la blockchain, de propager les blocs et de gérer la logique de consensus
 2. un client d'exécution permettant de prendre en charge la machine virtuelle Ethereum et d'exécuter des transactions et des contrats intelligents
 
-Voir la [page des nœuds et des clients] (/developers/docs/nodes-and-clients/) pour plus de détails sur les nœuds et les clients et pour une liste de toutes les implémentations clients actuelles. Vous pouvez également consulter l'historique de toutes les mises à jour d'Ethereum sur la [page Historique](/ethereum-forks/).
+Voir la [page des nœuds et des clients](/developers/docs/nodes-and-clients/) pour plus de détails sur les nœuds et les clients et pour une liste de toutes les implémentations clients actuelles. Vous pouvez également consulter l'historique de toutes les mises à jour d'Ethereum sur la [page Historique](/ethereum-forks/).
 
 ### Clients d'exécution {#execution-clients}
 
 - [Spécification du client d'exécution](https://github.com/ethereum/execution-specs)
 - [Spécification de l'API d'exécution](https://github.com/ethereum/execution-apis)
 
-### Clients de consensus {#consensus-clients}
+### Clients de consensus {#consensus-clients}
 
 - [Spécification du client de consensus](https://github.com/ethereum/consensus-specs)
 - [Spécification de l'API de la chaîne phare](https://ethereum.github.io/beacon-APIs/#/Beacon/getStateRoot)
@@ -266,7 +266,7 @@ Les validateurs utilisent l'actif natif d'Ethereum (l'ether) comme collatéral c
 
 ### Mise en jeu libre et ses dérivés {#liquid-staking-and-derivatives}
 
-La mise en jeu libre permet aux utilisateurs possédant moins de 32 ETH de recevoir des rendements de mise en jeu en échangeant de l'ether contre un jeton représentant de l'ether mis en jeu susceptible d'être utilisé dans la DeFi. Cependant, les incitations et la dynamique du marché associées à la mise en jeu libre sont encore en phase de découverte, tout comme son effet sur la sécurité d'Ethereum (par exemple, les risques de centralisation).
+La mise en jeu libre permet aux utilisateurs possédant moins de 32 ETH de recevoir des rendements de mise en jeu en échangeant de l'ether contre un jeton représentant de l'ether mis en jeu susceptible d'être utilisé dans la DeFi. Cependant, les incitations et la dynamique du marché associées à la mise en jeu liquide sont encore en cours de découverte, ainsi que son effet sur la sécurité d'Ethereum (p. ex., les risques de centralisation).
 
 #### Lectures de référence {#background-reading-12}
 
@@ -377,7 +377,7 @@ Les piratages sur Ethereum exploitent généralement des vulnérabilités dans d
 
 - [Rapport sur l'attaque de Wormhole](https://blog.chainalysis.com/reports/wormhole-hack-february-2022/)
 - [Liste des post-mortems des piratages de contrats Ethereum](https://forum.openzeppelin.com/t/list-of-ethereum-smart-contracts-post-mortems/1191)
-- [Rekt News](https://twitter.com/RektHQ?s=20&t=3otjYQdM9Bqk8k3n1a1Adg)
+- [Rekt News](https://x.com/RektHQ?s=20&t=3otjYQdM9Bqk8k3n1a1Adg)
 
 #### Recherche récente {#recent-research-19}
 
diff --git a/public/content/translations/fr/community/support/index.md b/public/content/translations/fr/community/support/index.md
index b61d715c4de..b4bfd3eb295 100644
--- a/public/content/translations/fr/community/support/index.md
+++ b/public/content/translations/fr/community/support/index.md
@@ -1,16 +1,16 @@
 ---
 title: Assistance Ethereum
-description: Obtenez de l'aide sur l'écosystème Ethereum.
+description: "Obtenez de l'aide sur l'écosystème Ethereum."
 lang: fr
 ---
 
 # Assistance Ethereum {#support}
 
-## Asistance officielle Ethereum {#official-support}
+## Assistance Ethereum officielle {#official-support}
 
 Vous recherchez l'assistance officielle Ethereum ? La première chose que vous devez savoir est le fait qu'Ethereum est décentralisé. Cela signifie qu'aucune organisation, entité ou personne n'est propriétaire d'Ethereum et, de ce fait, il n'existe aucune assistance officielle.
 
-Comprendre la nature décentralisée d’Ethereum est essentiel car **toute personne prétendant être le support officiel d’Ethereum essaie probablement de vous arnaquer !** La meilleure protection contre les escrocs est de vous informer et de prendre la sécurité au sérieux.
+Comprendre la nature décentralisée d’Ethereum est essentiel car **toute personne prétendant être une assistance officielle pour Ethereum essaie probablement de vous arnaquer !** La meilleure protection contre les escrocs est de vous informer et de prendre la sécurité au sérieux.
 
 <DocLink href="/security/">
   Sécurité d'Ethereum et prévention des arnaques
@@ -20,11 +20,11 @@ Comprendre la nature décentralisée d’Ethereum est essentiel car **toute pers
   Apprendre les fondamentaux d'Ethereum
 </DocLink>
 
-Malgré le manque d'assistance officielle, de nombreux groupes, communautés et projets à travers l'écosystème Ethereum sont heureux de vous aider. Vous pouvez trouver beaucoup d'informations et de ressources utiles sur cette page. Vous avez d'autres questions ? Rejoignez le [Discord ethereum.org](https://discord.gg/ethereum-org) et nous essaierons de vous aider.
+Malgré le manque d'assistance officielle, de nombreux groupes, communautés et projets à travers l'écosystème Ethereum sont heureux de vous aider. Vous pouvez trouver beaucoup d'informations et de ressources utiles sur cette page. Vous avez d'autres questions ? Rejoignez le [Discord ethereum.org](https://discord.gg/ethereum-org), et nous essaierons de vous aider.
 
-## Questions fréquemment posées {#faq}
+## Foire aux questions {#faq}
 
-### J'ai transféré mes ETH vers le mauvais portefeuille {#wrong-wallet}
+### J'ai envoyé des ETH au mauvais portefeuille {#wrong-wallet}
 
 Les transactions effectuées sur Ethereum sont irréversibles. Malheureusement, si vous avez envoyé des ETH au mauvais portefeuille, il n'y a aucun moyen de récupérer ces fonds. Aucune organisation centrale, entité ou personne n'est propriétaire d'Ethereum, ce qui signifie que personne ne peut annuler les transactions. Pour cette raison, il est primordial de vérifier deux fois vos transactions avant de les effectuer.
 
@@ -38,29 +38,29 @@ Les concours Ethereum sont des arnaques conçues pour récupérer vos ETH. Ne vo
 
 Les transactions sur Ethereum peuvent parfois se bloquer si vous avez soumis des frais de transactions inférieurs à ceux requis en raison de la demande du réseau. De nombreux portefeuilles offrent la possibilité de renvoyer la même transaction avec des frais de transaction plus élevés, afin de permettre à celle-ci d'être traitée. Vous pouvez aussi annuler une transaction en cours en envoyant une transaction vers votre propre adresse en utilisant le même nonce que la transaction en cours.
 
-[Comment accélérer ou annuler une transaction en cours via MetaMask](https://metamask.zendesk.com/hc/en-us/articles/360015489251-How-to-speed-up-or-cancel-a-pending-transaction)
+[Comment accélérer ou annuler une transaction en attente sur MetaMask](https://metamask.zendesk.com/hc/en-us/articles/360015489251-How-to-speed-up-or-cancel-a-pending-transaction)
 
-[Comment annuler des transactions Ethereum en cours](https://info.etherscan.com/how-to-cancel-ethereum-pending-transactions/)
+[Comment annuler les transactions Ethereum en attente](https://info.etherscan.com/how-to-cancel-ethereum-pending-transactions/)
 
 ### Comment miner de l'Ethereum ? {#mining-ethereum}
 
-Le minage d'Ethereum n'est plus possible. La possibilité de miner a disparu lors du passage d'Ethereum de la [preuve de travail](/glossary/#pow) à la [preuve d'enjeu](/glossary/#pos). Désormais, en place des mineurs, Ethereum dispose de validateurs. Tout le monde peut [mettre en jeu](/glossary/#staking) de l'ETH et recevoir des récompenses de mise en jeu en exécutant un programme de validation pour sécuriser le réseau.
+Le minage d'Ethereum n'est plus possible. Le minage a été désactivé lorsqu'Ethereum est passé de la [preuve de travail](/glossary/#pow) à la [preuve d'enjeu](/glossary/#pos). Désormais, en place des mineurs, Ethereum dispose de validateurs. Tout le monde peut [mettre en jeu](/glossary/#staking) des ETH et recevoir des récompenses de mise en jeu en exécutant un logiciel de validateur pour sécuriser le réseau.
 
 ### Comment devenir un validateur / faire fonctionner un validateur ? {#how-to-stake}
 
-Pour devenir un validateur, vous devez miser 32 ETH dans le contrat de dépôt Ethereum et mettre en place un nœud de validateur. Davantage d'informations sont disponibles sur nos [pages de staking](/staking) et sur [la plateforme de lancement de staking](https://launchpad.ethereum.org/).
+Pour devenir un validateur, vous devez miser 32 ETH dans le contrat de dépôt Ethereum et mettre en place un nœud de validateur. Plus d'informations sont disponibles sur nos [pages de staking](/staking) et sur [le launchpad de staking](https://launchpad.ethereum.org/).
 
-## Créer des applications décentralisées {#building-support}
+## Créer des dapps {#building-support}
 
 Le développement d'une application décentralisée peut être difficile. Voici quelques espaces axés sur leur création, avec des développeurs Ethereum chevronnés qui seront heureux de vous faire part de leur expérience.
 
 - [Alchemy University](https://university.alchemy.com/#starter_code)
 - [Discord CryptoDevs](https://discord.com/invite/5W5tVb3)
-- [StackExchange Ethereum](https://ethereum.stackexchange.com/)
+- [Ethereum StackExchange](https://ethereum.stackexchange.com/)
 - [Web3 University](https://www.web3.university/)
 - [LearnWeb3](https://discord.com/invite/learnweb3)
 
-Vous pouvez aussi consulter notre documentation ainsi que des guides de développement dans notre section [Ressources pour les développeurs Ethereum](/developers/).
+Vous pouvez également trouver de la documentation et des guides de développement dans notre section [ressources pour les développeurs Ethereum](/developers/).
 
 ### Outils {#dapp-tooling}
 
@@ -101,4 +101,4 @@ La plupart des équipes qui créent des clients Ethereum disposent aussi d'espac
 - [Lodestar](https://discord.gg/aMxzVcr)
 - [Grandine](https://discord.gg/H9XCdUSyZd)
 
-Vous pouvez aussi [apprendre comment exécuter un nœud ici](/developers/docs/nodes-and-clients/run-a-node/).
+Vous pouvez également [apprendre à exécuter un nœud ici](/developers/docs/nodes-and-clients/run-a-node/).
diff --git a/public/content/translations/fr/contributing/adding-desci-projects/index.md b/public/content/translations/fr/contributing/adding-desci-projects/index.md
index e77e5b14a02..8de56b234f1 100644
--- a/public/content/translations/fr/contributing/adding-desci-projects/index.md
+++ b/public/content/translations/fr/contributing/adding-desci-projects/index.md
@@ -1,26 +1,26 @@
 ---
 title: Ajout de projets DeSci
-description: La politique utilisée lors de l'ajout de liens vers des projets sur la page DeSci d'ethereum.org
+description: "La politique que nous utilisons lors de l’ajout d’un lien vers des projets sur la page DeSci de ethereum.org"
 lang: fr
 ---
 
-# Ajouter des projets {#adding-projects}
+# Ajout de projets {#adding-projects}
 
 Nous souhaitons présenter une variété de projets et donner un bon aperçu du paysage DeSci.
 
 Chacun est libre de proposer un projet à inscrire sur la page DeSci d'ethereum.org. De même, toute personne qui remarque un projet qui n'est plus pertinent ou qui ne répond plus à nos critères d'éligibilité est libre de suggérer que nous le supprimions.
 
-## Le cadre décisionnel {#the-decision-framework}
+## Le cadre de décision {#the-decision-framework}
 
 ### Critères d'inclusion : les incontournables {#the-must-haves}
 
-- **Code/données open source** - Le code et les données open source sont un principe fondamental de DeSci, les projets DeSci ne doivent pas être en code source fermé. La base de code doit être accessible et idéalement ouverte aux PR.
-- **Les projets DeSci doivent être manifestement décentralisés** - Cela pourrait inclure d'être gouverné par un DAO, ou de construire avec une pile technologique décentralisée comprenant des portefeuilles non-dépositaires. Cela implique vraisemblablement des contrats intelligents vérifiables sur Ethereum.
-- **Informations honnêtes et précises sur les ajouts** - Nous exigeons que tous les nouveaux ajouts proposés par les projets soient accompagnées d'informations honnêtes et précises. Les produits dont les informations d'ajout sont falsifiées (par exemple, déclarer que votre produit est « open source » alors qu'il ne l'est pas) seront supprimés.
+- **Code/données open source** - L'ouverture du code et des données est un principe fondamental de DeSci, les projets DeSci ne doivent donc pas être en code source fermé. La base de code doit être accessible et idéalement ouverte aux PR.
+- **Les projets DeSci doivent être manifestement décentralisés** - Cela pourrait inclure d'être gouverné par une DAO, ou de construire avec une pile technologique décentralisée comprenant des portefeuilles non dépositaires. Cela implique vraisemblablement des contrats intelligents vérifiables sur Ethereum.
+- **Informations honnêtes et précises sur la liste** - Il est attendu que toute suggestion d'inscription de projet soit accompagnée d'informations honnêtes et précises. Les produits dont les informations d'ajout sont falsifiées (par exemple, déclarer que votre produit est « open source » alors qu'il ne l'est pas) seront supprimés.
 - **Engagement manifeste en faveur de l'élargissement de l'accès à la science** - Un projet DeSci doit être en mesure d'expliquer comment il élargit la participation à la science au grand public, et pas seulement aux détenteurs d'un jeton ou d'un NFT.
 - **Accessibilité globale** - Votre projet n'a pas de limitations géographiques ou d'exigences KYC qui excluent certaines personnes de l'accès à votre service.
 - **Site web et documentation informatifs** - Il est important que les visiteurs du site web du projet puissent comprendre ce que le projet fait réellement, comment il contribue à la décentralisation de l'infrastructure scientifique et comment y participer.
-- **Le projet devrait faire partie de l'écosystème Ethereum** - À ethereum.org, nous pensons qu'Ethereum (et ses couches 2) est la couche de base appropriée pour le mouvement DeSci.
+- **Le projet devrait faire partie de l'écosystème Ethereum** - Sur ethereum.org, nous pensons qu'Ethereum (et ses couches 2) est la couche de base appropriée pour le mouvement DeSci.
 - **Le projet est assez bien établi** - Le projet a des utilisateurs réels qui ont pu accéder aux services du projet durant plusieurs mois.
 
 ### Préférable, mais pas obligatoire
@@ -37,8 +37,8 @@ Ethereum étant flexible par nature, les équipes et les produits vont et vienne
 - Veillez à ce que tous les projets répertoriés répondent encore à nos critères
 - Vérifier si des produits suggérés ne répondent pas à plus de nos critères que ceux actuellement répertoriés
 
-Ethereum.org est maintenu par la communauté open source & nous comptons sur la communauté pour nous aider à tenir le site à jour. Si vous remarquez que des informations sur les projets listés doivent être mises à jour, veuillez ouvrir une « Issue » ou une « Pull Récent » sur notre GitHub.
+Ethereum.org est maintenu par la communauté open source et nous comptons sur la communauté pour nous aider à tenir le site à jour. Si vous remarquez que des informations sur les projets listés doivent être mises à jour, veuillez ouvrir une « Issue » ou une « Pull Récent » sur notre GitHub.
 
 ## Conditions d'utilisation {#terms-of-use}
 
-Veuillez également vous reporter à nos [conditions d'utilisation](/terms-of-use/). Les informations sur ethereum.org sont fournies uniquement à des fins d'information générale.
+Veuillez également vous reporter à nos [conditions d'utilisation](/terms-of-use/). Les informations sur ethereum.org sont fournies uniquement à des fins d'information générale.
diff --git a/public/content/translations/fr/contributing/adding-developer-tools/index.md b/public/content/translations/fr/contributing/adding-developer-tools/index.md
index 6e6e12631a9..fca4de401c7 100644
--- a/public/content/translations/fr/contributing/adding-developer-tools/index.md
+++ b/public/content/translations/fr/contributing/adding-developer-tools/index.md
@@ -1,10 +1,10 @@
 ---
-title: Ajouter des outils de développement
+title: "Ajouter des outils de développement"
 lang: fr
-description: Nos critères de référencement des outils de développement sur ethereum.org
+description: "Nos critères de référencement des outils de développement sur ethereum.org"
 ---
 
-# Ajouter des outils de développement {#contributing-to-ethereumorg-}
+# Ajout d'outils de développement {#contributing-to-ethereumorg-}
 
 Nous voulons nous assurer de lister les meilleures ressources de développement possible pour que vous puissiez construire en toute confiance et bénéficier du soutien dont vous avez besoin.
 
@@ -14,48 +14,48 @@ Nous listons actuellement les outils de développement sur notre [portail des d
 
 **N'hésitez pas à proposer de nouveaux ajouts aux pages appropriées.**
 
-## Méthode de sélection {#ways-to-contribute}
+## Comment nous décidons {#ways-to-contribute}
 
 Les propositions d'outils de développement seront évaluées selon les critères suivants :
 
-**Se distingue-t-il de manière pertinente des outils déjà listés ?**
+**Se distingue-t-il de manière pertinente des outils déjà listés?**
 
 - Nouvelles catégories ou nouveaux types d'outils
 - Nouvelles fonctionnalités par rapport aux outils similaires existants
 - Destiné à un cas d'utilisation spécifique qui n'est pas couvert par les outils similaires existants
 
-**L'outil est-il bien documenté ?**
+**L'outil est-il bien documenté?**
 
 - Existe-t-il une documentation ?
 - Est-elle suffisante pour utiliser l'outil ?
 - A-t-elle été récemment mise à jour ?
 
-**L'outil est-il largement utilisé ?**
+**L'outil est-il largement utilisé?**
 
 - Nous tiendrons compte de critères tels que les étoiles GitHub, les statistiques de téléchargement et l'utilisation de l'outil en question par des entreprises ou des projets connus
 
-**L'outil est-il de bonne qualité ?**
+**L'outil est-il de bonne qualité?**
 
 - Existe-t-il des bogues récurrents ?
 - L'outil est-il fiable ?
 - L'outil est-il activement maintenu ?
 
-**L'outil est-il open source ?**
+**L'outil est-il open source?**
 
 De nombreux projets dans l'espace Ethereum sont open source. Nous sommes plus susceptibles de lister des projets open source, qui permettent aux développeurs de la communauté d'inspecter le code et d'y contribuer.
 
 ---
 
-## Ordre des produits {#product-ordering}
+## Commande de produits {#product-ordering}
 
-À moins que les produits ne soient délibérément classés autrement, par exemple par ordre alphabétique, ils seront affichés par ordre d'ajout sur la page : du moins récent au plus récent. En d'autres termes, les derniers produits ajoutés figureront en bas de liste.
+À moins que les produits ne soient délibérément classés autrement, par exemple par ordre alphabétique, ils seront affichés par ordre d'ajout sur la page : du moins récent au plus récent. En d'autres termes, les produits les plus récents sont ajoutés au bas de la liste.
 
 ---
 
-## Ajout de votre outil de développement {#how-decisions-about-the-site-are-made}
+## Ajoutez votre outil de développement {#how-decisions-about-the-site-are-made}
 
 Si vous souhaitez ajouter un outil de développement à ethereum.org et qu'il répond aux critères, créez un ticket sur GitHub.
 
 <ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_dev_tool.yaml">
-  Créez un ticket
+  Créer un ticket
 </ButtonLink>
diff --git a/public/content/translations/fr/contributing/adding-exchanges/index.md b/public/content/translations/fr/contributing/adding-exchanges/index.md
index 60839a5dfb8..2e6cfc6f778 100644
--- a/public/content/translations/fr/contributing/adding-exchanges/index.md
+++ b/public/content/translations/fr/contributing/adding-exchanges/index.md
@@ -1,10 +1,10 @@
 ---
-title: Ajouter des échanges
-description: La politique que nous appliquons pour ajouter des échanges sur ethereum.org
+title: "Ajouter des échanges"
+description: "La politique que nous appliquons pour ajouter des échanges sur ethereum.org"
 lang: fr
 ---
 
-# Ajouter des échanges Ethereum {#adding-ethereum-exchanges}
+# Ajout d'échanges Ethereum {#adding-ethereum-exchanges}
 
 N'importe qui est libre de proposer l'ajout de nouveaux échanges (c'est-à-dire des intermédiaires d'échange) sur ethereum.org.
 
@@ -16,7 +16,7 @@ Cette page permet à un utilisateur de saisir son lieu de résidence afin de voi
 
 Dans cette optique, nous avons besoin d'informations spécifiques lorsque vous proposez un échange.
 
-**REMARQUE :** Si vous souhaitez lister un échange décentralisé, jetez un œil à notre [politique d'ajout de portefeuilles et de DApps](/contributing/adding-products/).
+**REMARQUE :** Si vous souhaitez lister un échange décentralisé, consultez notre [politique d'ajout de portefeuilles et de dapps](/contributing/adding-products/).
 
 ## Ce dont nous avons besoin {#what-we-need}
 
@@ -25,16 +25,16 @@ Dans cette optique, nous avons besoin d'informations spécifiques lorsque vous p
 - Des preuves que l'échange est une société commerciale légitime
 - Toute information supplémentaire que vous pourriez avoir ; il peut s'agir d'informations sur l'entreprise comme son ancienneté, son financement, etc.
 
-Nous avons besoin de ces informations afin de pouvoir correctement [aider les utilisateurs à trouver un échange qu'ils peuvent utiliser](/get-eth/#country-picker).
+Nous avons besoin de ces informations pour [aider les utilisateurs à trouver un échange qu'ils peuvent utiliser](/get-eth/#country-picker) avec précision.
 
 Cela permet également à ethereum.org d'avoir confiance en la légitimité et la sûreté des services fournis par l'échange.
 
 ---
 
-## Ajout de votre échange {#add-exchange}
+## Ajoutez votre échange {#add-exchange}
 
 Si vous souhaitez ajouter un échange sur ethereum.org, créez un ticket sur GitHub.
 
 <ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=content+%3Afountain_pen%3A&template=suggest_exchange.yaml">
-  Créez un ticket
+Créer un ticket
 </ButtonLink>
diff --git a/public/content/translations/fr/contributing/adding-glossary-terms/index.md b/public/content/translations/fr/contributing/adding-glossary-terms/index.md
index bce16ce5567..31ecb483ca9 100644
--- a/public/content/translations/fr/contributing/adding-glossary-terms/index.md
+++ b/public/content/translations/fr/contributing/adding-glossary-terms/index.md
@@ -1,14 +1,14 @@
 ---
 title: Ajouter des termes au glossaire
 lang: fr
-description: Nos critères d'ajout de nouveaux termes au glossaire d'ethereum.org
+description: "Nos critères d'ajout de nouveaux termes au glossaire d'ethereum.org"
 ---
 
 # Ajouter des termes au glossaire {#contributing-to-ethereumorg-}
 
-L'écosystème Ethereum évolue en permanence. De nouveaux termes entrent constamment dans le lexique de ses utilisateurs, et nous avons besoin de votre aide pour fournir un glossaire de référence précis et à jour pour tout ce qui concerne Ethereum. Jetez un œil à l'actuel [glossaire](/glossary/) et lisez la section ci-dessous si vous souhaitez nous aider !
+L'écosystème Ethereum évolue en permanence. De nouveaux termes entrent constamment dans le lexique de ses utilisateurs, et nous avons besoin de votre aide pour fournir un glossaire de référence précis et à jour pour tout ce qui concerne Ethereum. Consultez le [glossaire](/glossary/) actuel et lisez la section ci-dessous si vous souhaitez nous aider !
 
-## Critères {#criteria}
+## Critère {#criteria}
 
 Les propositions pour l'ajout de nouveaux termes seront évaluées selon les critères suivants :
 
@@ -17,10 +17,10 @@ Les propositions pour l'ajout de nouveaux termes seront évaluées selon les cri
 - Le terme et sa définition sont-ils dépourvus de toute publicité ou de tout autre contenu promotionnel ?
 - Le terme et sa définition sont-ils directement liés à Ethereum ?
 - La définition est-elle objective, précise et dépourvue de jugement ou d'opinion ?
-- Quelle est la crédibilité de la source ? Référence-t-elle ses propres sources ?
+- Quelle est la crédibilité de la source ? Référence-t-il ses sources ?
 
 ---
 
-## Ajout d'un terme {#how-decisions-about-the-site-are-made}
+## Ajoutez votre terme {#how-decisions-about-the-site-are-made}
 
-Si vous souhaitez ajouter un terme au glossaire d'ethereum.org et que celui-ci répond aux critères énoncés ci-dessus, [créez un ticket sur GitHub](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_glossary_term.yaml).
+Si vous souhaitez ajouter un terme au glossaire d'ethereum.org et que celui-ci répond aux critères, [créez une « issue » sur GitHub](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_glossary_term.yaml).
diff --git a/public/content/translations/fr/contributing/adding-layer-2s/index.md b/public/content/translations/fr/contributing/adding-layer-2s/index.md
index ec77967918c..a440423031b 100644
--- a/public/content/translations/fr/contributing/adding-layer-2s/index.md
+++ b/public/content/translations/fr/contributing/adding-layer-2s/index.md
@@ -1,33 +1,33 @@
 ---
-title: Ajout de la Couche 2
+title: "Ajouter des réseaux de couche 2"
 description: La politique que nous appliquons pour ajouter une couche de niveau 2 sur ethereum.org
 lang: fr
 ---
 
-# Ajouter une Couche de niveau 2 {#adding-layer-2}
+# Ajout de couches 2 {#adding-layer-2}
 
 Nous voulons nous assurer que nous listons les meilleures ressources possibles afin que les utilisateurs puissent naviguer en toute confiance et sécurité dans l'espace des Couches de niveau 2.
 
-Toute personne est libre de suggérer l'ajout d'une Couche de niveau 2 sur ethereum.org. S'il existe une couche de niveau 2 que nous avons manquée, **[merci de bien vouloir la suggérer](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_layer2.yaml) !**
+Toute personne est libre de suggérer l'ajout d'une Couche de niveau 2 sur ethereum.org. S'il y a une couche 2 que nous avons manquée, **[veuillez la suggérer](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_layer2.yaml) !**
 
 Nous listons actuellement les L2s sur les pages suivantes :
 
-- [Rollups optimisés](/developers/docs/scaling/optimistic-rollups/)
-- [rollups ZK](/developers/docs/scaling/zk-rollups/)
+- [Rollups optimistes](/developers/docs/scaling/optimistic-rollups/)
+- [Rollups ZK](/developers/docs/scaling/zk-rollups/)
 - [Couche 2](/layer-2/)
 
 La Couche de niveau 2 est un paradigme relativement nouveau et excitant pour Ethereum. Nous avons tenté de créer un cadre équitable pour pouvoir s'afficher sur ethereum.org, mais les critères de sélection dans la liste changeront et évolueront au fil du temps.
 
-## Le cadre décisionnel {#decision-framework}
+## Le cadre de décision {#decision-framework}
 
 ### Critères d'inclusion : les incontournables {#criteria-for-inclusion-the-must-haves}
 
 **Liste sur L2BEAT**
 
 - Pour être pris en compte, ce projet doit être listé sur [L2BEAT](https://l2beat.com). L2BEAT fournit une évaluation solide des risques pour les projets de Couche 2 sur lesquels nous nous appuyons pour évaluer ces projets. **Si le projet n'est pas mis en vedette sur L2BEAT, nous ne le listerons pas en tant que Couche de niveau 2 sur ethereum.org.**
-- [Apprenez comment ajouter votre projet de Couche de niveau 2 sur L2BEAT](https://github.com/l2beat/l2beat/blob/master/CONTRIBUTING.md).
+- [Découvrez comment ajouter votre projet L2 à L2BEAT](https://github.com/l2beat/l2beat/blob/master/CONTRIBUTING.md).
 
-**Open Source**
+**Open source**
 
 - Votre code doit être accessible et vous devez accepter les PR de la communauté dans son ensemble.
 
@@ -38,13 +38,13 @@ Nous considérons actuellement les solutions suivantes comme les solutions de Co
 - Rollup optimisé
 - Rollup ZK
 
-_Nous ne considérons pas comme relevant de la couche 2 les autres solutions d'évolutivité qui n'utilisent pas Ethereum pour la disponibilité ou la sécurité des données._
+_Nous ne considérons pas comme relevant de la couche 2 les autres solutions d'évolutivité qui n'utilisent pas Ethereum pour la disponibilité des données ou la sécurité._
 
 **Ethereum pour la disponibilité des données**
 
-- La disponibilité des données est un facteur important de différenciation entre les autres solutions de mise à l'échelle et de couche 2. Un projet **doit** utiliser le réseau principal Ethereum pour que la disponibilité des données soit prise en compte pour l'inscription.
+- La disponibilité des données est un facteur important de différenciation entre les autres solutions de mise à l'échelle et de couche 2. Un projet **doit** utiliser le réseau principal Ethereum pour la disponibilité des données afin d'être pris en compte pour le référencement.
 
-**Passerelles**
+**Ponts**
 
 - Comment les utilisateurs peuvent-ils basculer sur une Couche de niveau 2 ?
 
@@ -70,7 +70,7 @@ _Nous ne considérons pas comme relevant de la couche 2 les autres solutions d'
 
 - Les projets listés nécessitent un explorateur de blocs pour permettre aux utilisateurs de naviguer facilement dans la chaîne.
 
-### Autres critères : c'est toujours un plus de les avoir {#nice-to-haves}
+### Autres critères : les plus {#nice-to-haves}
 
 **Support d'échange pour le projet**
 
@@ -78,7 +78,7 @@ _Nous ne considérons pas comme relevant de la couche 2 les autres solutions d'
 
 **Liens vers des dApps dans l'écosystème de la Couche 2**
 
-- Nous voulons être en mesure de fournir des informations sur ce que les utilisateurs peuvent s'attendre à pouvoir faire sur cette Couche 2. (ex. : https://portal.arbitrum.io/, https://www.optimism.io/apps)
+- Nous voulons être en mesure de fournir des informations sur ce que les utilisateurs peuvent s'attendre à pouvoir faire sur cette Couche 2. (par ex. : https://portal.arbitrum.io/, https://www.optimism.io/apps)
 
 **Listes de contrat de jetons**
 
@@ -88,10 +88,10 @@ _Nous ne considérons pas comme relevant de la couche 2 les autres solutions d'
 
 - Est-ce que des portefeuilles prennent en charge nativement la Couche de niveau 2 ?
 
-## Ajoutez votre Couche de niveau 2 {#add-exchange}
+## Ajoutez votre couche 2 {#add-exchange}
 
 Si vous souhaitez ajouter une Couche 2 sur ethereum.org, créez un ticket sur GitHub.
 
 <ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_layer2.yaml">
-  Créez un ticket
+Créer un ticket
 </ButtonLink>
diff --git a/public/content/translations/fr/contributing/adding-products/index.md b/public/content/translations/fr/contributing/adding-products/index.md
index 1a1e99d0b05..61070410598 100644
--- a/public/content/translations/fr/contributing/adding-products/index.md
+++ b/public/content/translations/fr/contributing/adding-products/index.md
@@ -17,20 +17,20 @@ Les Dapps sont actuellement listés sur:
 
 Bien que nous appréciions les nouveaux ajouts, nous avons choisi les DApps actuelles en fonction d'une expérience que nous essayons de créer pour nos utilisateurs. Ceux-ci sont basés sur certains de nos principes de conception :
 
-- _Inspirant_ : tout ce qui est sur ethereum.org devrait offrir quelque chose de nouveau aux utilisateurs
-- _Une bonne histoire_ : ce qui est répertorié devrait entraîner un moment de révélation (ah, ah !)
-- _Crédible_ : toutes les entreprises/projets doivent être légitimes pour minimiser les risques pour les utilisateurs
+- _Inspirant_: tout contenu sur ethereum.org devrait apporter quelque chose de nouveau aux utilisateurs
+- _Une bonne histoire_ : ce qui est présenté devrait provoquer un déclic, un moment de révélation
+- _Crédible_ : tout doit provenir de projets/d’entreprises légitimes, afin de minimiser les risques pour les utilisateurs
 
-Dans l’ensemble, **ethereum.org souhaite offrir une « expérience d’intégration transparente » aux nouveaux utilisateurs**. C'est pourquoi nous ajoutons des DApps en fonction de leur :
+Dans l'ensemble, **ethereum.org souhaite offrir une « expérience d'intégration transparente » aux nouveaux utilisateurs.** C'est pourquoi nous ajoutons des DApps en fonction de leur :
 
 - facilité d'utilisation
 - interopérabilité avec d'autres produits
 - sécurité
 - longévité
 
-Voici notre cadre de décision plus en détail. N’hésitez pas à nous faire part de vos commentaires ou à suggérer des changements.
+Vous trouverez ci-dessous notre cadre décisionnel plus en détail. N'hésitez pas à nous faire part de vos commentaires ou à suggérer des changements.
 
-## Le cadre décisionnel {#decision-framework}
+## Le cadre de décision {#decision-framework}
 
 ### Critères d'inclusion : les incontournables {#criteria-for-inclusion-the-must-haves}
 
@@ -39,17 +39,17 @@ Voici notre cadre de décision plus en détail. N’hésitez pas à nous faire p
 - **Développé par une équipe toujours active** : cela permet d'assurer la qualité et de garantir qu'un utilisateur obtiendra de l'aide pour ses demandes.
 - **Informations d'ajout honnêtes et exactes** : nous exigeons que les ajouts suggérés par les projets soient accompagnés d'informations honnêtes et exactes. Les produits dont les informations d'ajout sont falsifiées (par exemple, déclarer que votre produit est « open source » alors qu'il ne l'est pas) seront supprimés.
 
-### Critères de classement : les souhaitables {#criteria-for-ranking-the-nice-to-haves}
+### Critères de classement : les points appréciables {#criteria-for-ranking-the-nice-to-haves}
 
 Votre DApp peut ne pas mise en évidence autant que d'autres sur ethereum.org en raison des critères suivants.
 
 **DApps**
 
 - **Possibilité d'y accéder via la majorité des portefeuilles répertoriés** : les DApps devraient fonctionner avec la majorité des portefeuilles répertoriés sur ethereum.org.
-- **Possibilité pour les utilisateurs de les essayer eux-mêmes** : un utilisateur individuel devrait pouvoir utiliser votre DApp et réaliser quelque chose de concret.
+- **Possibilité pour les utilisateurs de l'essayer eux-mêmes** : un utilisateur individuel devrait pouvoir utiliser votre dapp et réaliser quelque chose de concret.
 - **Intégration** : votre produit doit inclure une expérience d'intégration bien conçue pour aider et former les utilisateurs. Autrement, il doit justifier de son contenu pratique comme des articles ou des vidéos d'aide.
 - **Non-dépositaire** : les utilisateurs contrôlent leurs fonds. Si votre produit disparaît, les utilisateurs peuvent toujours accéder à leurs fonds et les déplacer.
-- ** Accessible dans le monde entier** : votre produit n'a pas de restrictions géographiques ou d'exigences de connaissance du client (KYC) qui empêchent certaines personnes d'accéder à votre service.
+- Accessible dans le monde entier : votre produit n'a pas de restrictions géographiques ou d'exigences de connaissance du client (KYC) qui empêchent certaines personnes d'accéder à votre service.
 - **Open source** : votre code doit être accessible et vous devez accepter les demandes PR de la communauté au sens large.
 - **Communauté** : vous avez une communauté dédiée, peut-être un Discord, où les utilisateurs peuvent interagir avec votre équipe pour obtenir de l'aide ou suggérer de nouvelles fonctionnalités.
 
@@ -68,11 +68,11 @@ Autres éléments qui entreront en ligne de compte dans cette décision :
 
 L'ajout de produits est une décision de conception dont ethereum.org est responsable.
 
-Mais rassurez-vous, **il y aura des liens vers d'autres sites web qui classent plus de DApps **
+Mais rassurez-vous, **il y aura des liens vers d'autres sites Web qui classent plus de DApps**.
 
-### Ordre des produits {#product-ordering}
+### Commande de produits {#product-ordering}
 
-À moins que les produits ne soient délibérément classés autrement, par exemple par ordre alphabétique, ils seront affichés par ordre d'ajout sur la page : du plus récent au moins récent. En d'autres termes, les derniers produits ajoutés figureront en bas de liste.
+À moins que les produits ne soient délibérément classés autrement, par exemple par ordre alphabétique, ils seront affichés par ordre d'ajout sur la page : du plus récent au moins récent. En d'autres termes, les produits les plus récents sont ajoutés au bas de la liste.
 
 ### Conditions d'utilisation {#terms-of-use}
 
@@ -82,19 +82,19 @@ Veuillez également vous reporter à nos [conditions d'utilisation](/terms-of-us
 
 Ethereum étant flexible par nature, les équipes et les produits vont et viennent et l'innovation est quotidienne. Nous procéderons donc à des vérifications de routine de notre contenu pour :
 
-- s'assurer que toutes les DApps répertoriées répondent toujours à nos critères 
+- s'assurer que toutes les DApps répertoriées répondent toujours à nos critères
 - vérifier qu'aucun produit suggéré ne répond à plus de nos critères que ceux actuellement répertoriés
 
-Vous pouvez nous aider en vérifiant par vous-même et en nous le faisant savoir. [Créez un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=Type%3A+Feature&template=feature_request.md&title=) ou envoyez un email à l'adresse [website@ethereum.org](mailto:website@ethereum.org)
+Vous pouvez nous aider en vérifiant par vous-même et en nous le faisant savoir. [Créer un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=Type%3A+Feature&template=feature_request.yaml&title=) ou envoyer un email à [website@ethereum.org](mailto:website@ethereum.org)
 
 _Nous étudions également des options de vote afin que la communauté puisse indiquer ses préférences et mettre en évidence les meilleurs produits pour que nous puissions les recommander._
 
 ---
 
-## Ajout de votre produit {#add-your-product}
+## Ajoutez votre produit {#add-your-product}
 
-Si vous souhaitez ajouter une DApp à ethereum.org et qu’elle répond aux critères, créez un ticket sur GitHub.
+Si vous souhaitez ajouter une dapp à ethereum.org et qu'elle répond aux critères, veuillez nous en informer.
 
 <ButtonLink href="https://submitapp.paperform.co/">
-  Créez un ticket
+  Suggérer une application
 </ButtonLink>
diff --git a/public/content/translations/fr/contributing/adding-resources/index.md b/public/content/translations/fr/contributing/adding-resources/index.md
new file mode 100644
index 00000000000..25589d12656
--- /dev/null
+++ b/public/content/translations/fr/contributing/adding-resources/index.md
@@ -0,0 +1,53 @@
+---
+title: Ajouter des ressources
+description: "La politique que nous suivons lors de l’ajout de ressources sur ethereum.org"
+lang: fr
+---
+
+# Ajouter des ressources {#adding-resources}
+
+Nous souhaitons nous assurer de lister les meilleures ressources possibles tout en préservant la sécurité et la confiance des utilisateurs.
+
+Tout le monde est libre de suggérer de nouvelles ressources à ajouter au tableau de bord des ressources sur ethereum.org, actuellement disponible à l’adresse [ethereum.org/resources](/resources/).
+
+Même si nous accueillons volontiers de nouvelles suggestions, les ressources actuelles ont été choisies pour créer une expérience bien précise pour nos utilisateurs. Ceux-ci sont basés sur certains de nos principes de conception :
+
+- _Inspirant_: tout contenu sur ethereum.org devrait apporter quelque chose de nouveau aux utilisateurs
+- _Une bonne histoire_ : ce qui est présenté devrait provoquer un déclic, un moment de révélation
+- _Crédible_ : tout doit provenir de projets/d’entreprises légitimes, afin de minimiser les risques pour les utilisateurs
+
+Dans l’ensemble**ethereum.org cherche à offrir une expérience d’accueil fluide et accessible pour les nouveaux utilisateurs**. C’est pour cette raison que nous ajoutons des ressources en nous basant sur :
+
+- facilité d'utilisation
+- précision
+- maintenance
+
+## Le cadre de décision {#decision-framework}
+
+### Critère {#criteria}
+
+- **Informations honnêtes et précises** – Toute suggestion doit être accompagnée d’informations fiables et exactes. Les produits qui fournissent de fausses informations seront supprimés.
+- **Projet actif** – La ressource doit être maintenue par une équipe dynamique pour garantir la qualité et l’accompagnement des utilisateurs. Les ressources dépassées peuvent être supprimées.
+
+### Commande de produits {#product-ordering}
+
+Nous nous réservons le droit de commander des produits en fonction de leur impact. Les nouveaux produits seront généralement ajoutés en bas de la liste, sauf indication contraire.
+
+## Maintenance {#maintenance}
+
+Au fur et à mesure de l’évolution de l’écosystème Ethereum, nous vérifierons régulièrement notre contenu afin de :
+
+- S’assurer que toutes les ressources listées répondent toujours à nos critères
+- Vérifier si des produits suggérés ne répondent pas à plus de nos critères que ceux actuellement répertoriés
+
+Vous pouvez nous aider en vérifiant par vous-même et en nous le faisant savoir. [Créer un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?template=bug_report.yaml) ou envoyer un email à [website@ethereum.org](mailto:website@ethereum.org).
+
+---
+
+## Ajoutez votre ressource {#add-your-resource}
+
+Si vous souhaitez ajouter une ressource à ethereum.org et qu’elle répond aux critères, créez un ticket sur GitHub.
+
+<ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=resource+📚&template=suggest_resource.yaml">
+Créer un ticket
+</ButtonLink>
diff --git a/public/content/translations/fr/contributing/adding-staking-products/index.md b/public/content/translations/fr/contributing/adding-staking-products/index.md
index e2d819d0838..c8067af4d48 100644
--- a/public/content/translations/fr/contributing/adding-staking-products/index.md
+++ b/public/content/translations/fr/contributing/adding-staking-products/index.md
@@ -1,24 +1,24 @@
 ---
 title: Ajout de produits ou services de mise en jeu
-description: Les conditions générales que nous appliquons pour ajouter des produits ou des services de mise en jeu sur ethereum.org
+description: "Les conditions générales que nous appliquons pour ajouter des produits ou des services de mise en jeu sur ethereum.org"
 lang: fr
 ---
 
-# Ajouter des produits ou services de mise en jeu {#adding-staking-products-or-services}
+# Ajout de produits ou de services de mise en jeu {#adding-staking-products-or-services}
 
 Nous souhaitons nous assurer de lister les meilleures ressources possibles tout en préservant la sécurité et la confiance des utilisateurs.
 
-Toute personne est libre de suggérer l'ajout de produits ou de services mis en jeu sur ethereum.org. S'il en existe que nous avons manqué, **[merci de bien vouloir les suggérer](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_staking_product.yaml) !**
+Toute personne est libre de suggérer l'ajout de produits ou de services mis en jeu sur ethereum.org. Si nous en avons oublié un, **[veuillez le suggérer](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_staking_product.yaml) !**
 
 Nous listons actuellement les produits et services de mise en jeu sur les pages suivantes :
 
 - [Mise en jeu en solo](/staking/solo/)
 - [Mise en jeu en tant que service](/staking/saas/)
-- [Les pools de mise en jeu](/staking/pools/)
+- [Pools de mise en jeu](/staking/pools/)
 
 La preuve d’enjeu sur la Chaîne phare est utilisée depuis le 1er décembre 2020. Bien que la mise en jeu soit encore relativement nouvelle, nous avons essayé de créer un cadre équitable et transparent pour être pris en compte sur ethereum.org cependant, les critères d’inscription changeront et évolueront au fil du temps et restent au final à la discrétion de l’équipe du site ethereum.org.
 
-## Le cadre décisionnel {#the-decision-framework}
+## Le cadre de décision {#the-decision-framework}
 
 La décision de lister un produit sur ethereum.org ne dépend pas d'un seul facteur. Nous utilisons conjointement plusieurs critères de décision pour lister un produit ou un service. Les chances d'être listé sont fonction du nombre de critères satisfaits.
 
@@ -26,7 +26,7 @@ La décision de lister un produit sur ethereum.org ne dépend pas d'un seul fact
 
 - Nœud ou outil client
 - Gestionnaire de clés
-- Mise en jeu en tant que service (SaaS)
+- Mise en jeu en tant que service (SaaS en anglais)
 - Pools de mise en jeu
 
 Actuellement, nous répertorions uniquement des produits ou des services dans ces catégories.
@@ -40,7 +40,7 @@ Les soumissions de produits ou de services de mise en jeu seront évaluées selo
 - Existe-t-il des preuves du moment où le produit ou le service est devenu accessible au public ?
 - Ceci est utilisé pour déterminer le score « battle tested » des produits.
 
-**Le projet fait-il l'objet d'un suivi actif ?**
+**Le projet est-il activement maintenu ?**
 
 - Y a-t-il une équipe active qui développe le projet ? Qui est impliqué ?
 - Seuls les produits activement suivis et mis à jour seront pris en considération.
@@ -57,18 +57,18 @@ Les soumissions de produits ou de services de mise en jeu seront évaluées selo
 
 **Quelles plateformes sont prises en charge ?**
 
-- Par ex. Linux, macOS, Windows, iOS, Android
+- c.-à-d., Linux, macOS, Windows, iOS, Android
 
 #### Logiciels et contrats intelligents {#software-and-smart-contracts}
 
 Pour tout logiciel personnalisé ou contrat intelligent impliqué :
 
-**Est-ce que tout est Open Source ?**
+**Tout est-il open source ?**
 
 - Les projets Open Source doivent proposer un dépôt du code source disponible publiquement.
 - Ceci est utilisé pour déterminer le score « open source » des produits.
 
-**Le produit est-il issu du développement d'une version _bêta_ ?**
+**Le produit est-il sorti de sa phase de développement _bêta_ ?**
 
 - Où se situe le produit dans son cycle de développement ?
 - Les produits en phase bêta ne sont pas considérés comme pouvant être inclus sur ethereum.org
@@ -78,30 +78,30 @@ Pour tout logiciel personnalisé ou contrat intelligent impliqué :
 - Dans le cas contraire, y a-t-il des projets pour procéder à un audit externe ?
 - Ceci est utilisé pour déterminer la note « d'audit » des produits.
 
-**Est-ce que le projet a un programme de récompenses pour les bogues trouvés ?**
+**Le projet dispose-t-il d'un programme de primes aux bogues ?**
 
 - Dans le cas contraire, est-il prévu de créer une prime au bogue de sécurité ?
 - Ceci est utilisé pour déterminer le score « prime de bogue » des produits.
 
-#### Nœud ou logiciel outil {#node-or-client-tooling}
+#### Outils pour nœud ou client {#node-or-client-tooling}
 
 Pour les produits logiciels liés à la configuration de nœuds ou de clients, la gestion ou la migration :
 
-**Quels clients de la couche de consensus (c'est-à-dire  Lighthouse, Teku, Nimbus, Prysm, Grandine) sont pris en charge ?**
+**Quels clients de couche de consensus (c.-à-d. Lighthouse, Teku, Nimbus, Prysm, Grandine) sont pris en charge ?**
 
 - Quels sont les clients pris en charge ? L'utilisateur peut-il choisir ?
 - Ceci est utilisé pour déterminer le score « multi-client » des produits.
 
 #### Mise en jeu en tant que service {#staking-as-a-service}
 
-Pour les listes de [mise en jeu en tant que service](/staking/saas/) (c'est-à-dire les opérations de nœuds délégués) :
+Pour les listes de [mise en jeu en tant que service](/staking/saas/) (c.-à-d. opération de nœud déléguée) :
 
 **Quels sont les frais associés à l'utilisation du service ?**
 
-- Quelle est la structure des frais, par exemple y a-t-il des frais mensuels pour le service ?
+- Quelle est la structure des frais, p. ex. y a-t-il des frais mensuels pour le service ?
 - Des exigences supplémentaires pour la mise en jeu ?
 
-**Les utilisateurs doivent-ils s'inscrire à un compte ?**
+**Les utilisateurs doivent-ils créer un compte ?**
 
 - Quelqu'un peut-il utiliser le service sans permission ou sans KYC (Connaissance du client) ?
 - Ceci est utilisé pour déterminer le score « sans autorisation » des produits.
@@ -117,15 +117,15 @@ Pour les listes de [mise en jeu en tant que service](/staking/saas/) (c'est-à-d
 - Depuis la dernière modification, Prysm est le client de couche de consensus exécutée par une majorité d'opérateurs de nœuds, ce qui est dangereux pour le réseau. Si une couche de consensus client est actuellement utilisée par plus de 33 % du réseau, nous demandons des données relatives à son utilisation.
 - Ceci est utilisé pour déterminer le score « diversité de clients » des produits.
 
-#### Pools de mise en jeu {#staking-pool}
+#### Pool de mise en jeu {#staking-pool}
 
-Pour les [services de mise en commun des mises en jeu](/staking/pools/) :
+Pour les [services de mise en jeu en pool](/staking/pools/) :
 
-**Quel est le minimum d'ETH requis pour les mises en jeu ?**
+**Quel est le montant minimum d'ETH requis pour la mise en jeu ?**
 
-- Par exemple : 0,01 ETH
+- p. ex., 0,01 ETH
 
-**Quels sont les frais ou les exigences de mise en jeu ?**
+**Quels sont les frais et les exigences de mise en jeu ?**
 
 - Quel pourcentage de récompenses est retiré sous la forme de frais ?
 - Des exigences supplémentaires pour la mise en jeu ?
@@ -141,23 +141,23 @@ Pour les [services de mise en commun des mises en jeu](/staking/pools/) :
 - Cela exige-t-il une autorisation de la part d'une personne, d'une entreprise ou d'une DAO ?
 - Ceci est utilisé pour déterminer le score « nœuds sans autorisation » des produits.
 
-**Quelle est la diversité des clients des opérateurs de nœuds groupés ?**
+**Quelle est la diversité des clients des opérateurs de nœuds du pool ?**
 
 - Quel pourcentage d'opérateurs de nœuds utilisent un client de couche de consensus (CL) majoritaire ?
 - Depuis la dernière modification, Prysm est le client de couche de consensus exécutée par une majorité d'opérateurs de nœuds, ce qui est dangereux pour le réseau. Si une couche de consensus client est actuellement utilisée par plus de 33 % du réseau, nous demandons des données relatives à son utilisation.
 - Ceci est utilisé pour déterminer le score « diversité de clients » des produits.
 
-### Autres critères : c'est toujours un plus de les avoir {#other-criteria}
+### Autres critères : les atouts {#other-criteria}
 
 **Quelles sont les interfaces utilisateur prises en charge ?**
 
-- Par ex. Application pour navigateur, application de bureau, application pour mobile, CLI
+- c.-à-d., application de navigateur, application de bureau, application mobile, CLI
 
-**Pour les outils de nœuds, le logiciel offre-t-il un moyen facile de basculer entre les clients ?**
+**Pour les outils pour nœuds, le logiciel fournit-il un moyen facile de basculer entre les clients ?**
 
 - L'utilisateur peut-il changer facilement et en toute sécurité de clients à l'aide de l'outil ?
 
-**Pour les SaaS, combien de validateurs sont actuellement opérationnels sur le service ?**
+**Pour le SaaS, combien de validateurs sont actuellement opérés par le service ?**
 
 - Cela nous donne une idée de la portée de votre service à ce stade.
 
@@ -165,12 +165,12 @@ Pour les [services de mise en commun des mises en jeu](/staking/pools/) :
 
 Les [critères d'inclusion](#criteria-for-inclusion) ci-dessus sont utilisés pour calculer un score cumulé pour chaque produit ou service. Ceci est utilisé comme un moyen de trier et de présenter des produits qui répondent à certains critères objectifs. Plus il y a de critères pour lesquels des preuves sont fournies, plus un produit sera listé haut, les ex æquo étant affichés aléatoirement au chargement.
 
-La logique de code et les pondérations de ces critères sont actuellement contenus dans [ce composant JavaScript](https://github.com/ethereum/ethereum-org-website/blob/dev/src/components/Staking/StakingProductsCardGrid/index.tsx#L350) sur notre dépôt.
+La logique de code et les pondérations de ces critères se trouvent actuellement dans [ce composant JavaScript](https://github.com/ethereum/ethereum-org-website/blob/dev/src/components/Staking/StakingProductsCardGrid/index.tsx#L350) de notre dépôt.
 
 ## Ajoutez votre produit ou service {#add-product}
 
 Si vous souhaitez ajouter un produit ou un service de mise en jeu sur ethereum.org, il vous suffit de créer un ticket sur GitHub.
 
 <ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A%2Ccontent+%3Afountain_pen%3A&template=suggest_staking_product.yaml">
-  Créez un ticket
+Créer un ticket
 </ButtonLink>
diff --git a/public/content/translations/fr/contributing/adding-wallets/index.md b/public/content/translations/fr/contributing/adding-wallets/index.md
index b71b0fedd90..32097ac1f27 100644
--- a/public/content/translations/fr/contributing/adding-wallets/index.md
+++ b/public/content/translations/fr/contributing/adding-wallets/index.md
@@ -4,7 +4,7 @@ description: La politique que nous utilisons lors de l'ajout d'un portefeuille s
 lang: fr
 ---
 
-# Ajout de portefeuilles {#adding-wallets}
+# Ajouter des portefeuilles {#adding-wallets}
 
 Nous souhaitons nous assurer de présenter une gamme diversifiée de portefeuilles couvrant de nombreuses fonctionnalités, afin que les utilisateurs puissent naviguer sur Ethereum en confiance.
 
@@ -16,41 +16,42 @@ Les portefeuilles sont actuellement listés sur :
 
 Les portefeuilles évoluent rapidement sur Ethereum. Nous avons tenté de créer un cadre équitable pour pouvoir s'afficher sur ethereum.org, mais les critères de sélection dans la liste changeront et évolueront au fil du temps.
 
-## Le cadre décisionnel {#the-decision-framework}
+## Le cadre de décision {#the-decision-framework}
 
 ### Critères d'inclusion : les incontournables {#the-must-haves}
 
-- **Un produit dont la sécurité a été testée** - que ce soit par le biais d'un audit, d'une équipe de sécurité interne, d'un code source ouvert ou d'une autre méthode, la sécurité de votre portefeuille doit être fiable. Cela réduit les risques pour nos utilisateurs et nous montre que vous prenez la sécurité au sérieux.
+- **Un produit dont la sécurité a été testée** - que ce soit par le biais d'un audit, d'une équipe de sécurité interne, d'un code open source ou d'une autre méthode, la sécurité de votre portefeuille doit être fiable. Cela réduit les risques pour nos utilisateurs et nous montre que vous prenez la sécurité au sérieux.
 - **Un portefeuille qui est « en ligne » depuis plus de six mois OU publié par un groupe réputé** - c'est une autre indication de sécurité. Six mois est un bon délai pour la découverte de bogues et de failles critiques. Nous demandons six mois pour filtrer les fourches qui sont rapidement abandonnés en tant que projets.
-- **Développé par une équipe toujours active** : cela permet d'assurer la qualité et de garantir qu'un utilisateur obtiendra de l'aide pour ses demandes.
+- **Développé par une équipe toujours active** : cela permet d'assurer la qualité et de garantir qu'un utilisateur obtiendra de l'aide pour ses demandes.
 - **Informations d'ajout honnêtes et exactes** : nous exigeons que les ajouts suggérés par les projets soient accompagnés d'informations honnêtes et exactes. Les produits dont les informations d'ajout sont falsifiées (par exemple, déclarer que votre produit est « open source » alors qu'il ne l'est pas) seront supprimés.
 - **Point de contact** - Un point de contact pour le portefeuille nous aidera grandement à obtenir des informations précises lorsque des changements sont apportés. Cela permettra de continuer à mettre à jour ethereum.org raisonnablement lors de la collecte d'informations futures.
-- **Transactions EIP-1559 (type 2)** - votre portefeuille doit prendre en charge les transactions EIP-1559 (type 2) pour les transactions sur le réseau principal Ethereum
+- **Transactions EIP-1559 (type 2)** - votre portefeuille doit prendre en charge les transactions EIP-1559 (type 2) pour les transactions sur le réseau principal Ethereum.
 - **Bonne expérience utilisateur** - Bien que l'expérience utilisateur (UX) soit subjective, si plusieurs membres de l'équipe principale testent le produit et le trouvent compliqué à utiliser, nous nous réservons le droit de rejeter le portefeuille et fournirons à la place des suggestions utiles pour l'améliorer. L'objectif est de protéger notre base d'utilisateurs qui est principalement composée de débutants.
+- **Axé sur Ethereum** - Un portefeuille doit offrir une expérience principalement axée sur Ethereum. Cela signifie qu'Ethereum (ou n'importe quelle L2) est défini comme le réseau par défaut, que les actifs ERC sont correctement pris en charge et que les fonctionnalités sont alignées sur l'écosystème Ethereum. Les portefeuilles qui donnent la priorité dans l'interface utilisateur aux couches 1 alternatives ne seront pas répertoriés.
 
-### Retraits de produits {#product-removals}
+### Suppressions de produits {#product-removals}
 
 - **Informations mises à jour** - Les fournisseurs de portefeuilles sont responsables de la nouvelle soumission des informations de leur portefeuille tous les 6 mois pour garantir la validité et la pertinence des informations fournies (même s'il n'y a aucun changement à leur produit). Si l'équipe produit ne le fait pas, ethereum.org peut retirer le projet de la page.
 
-### Autres critères : c'est toujours un plus de les avoir {#the-nice-to-haves}
+### Autres critères : les atouts {#the-nice-to-haves}
 
 - **Accessibilité globale** - votre portefeuille n'a pas de limitations géographiques ou d'exigences KYC qui empêchent certaines personnes d'accéder à votre service.
 - **Disponible en plusieurs langues** - votre portefeuille est traduit en plusieurs langues, ce qui permet aux utilisateurs du monde entier d'y accéder.
 - **Open source** - l'ensemble de la base de code de votre projet (et pas seulement les modules) doit être accessible et vous devez accepter les PR de la communauté au sens large.
-- **Non-dépositaire** - les utilisateurs contrôlent leurs fonds. Si votre produit disparaît, les utilisateurs peuvent toujours accéder à leurs fonds et les déplacer.
+- **Non dépositaire** - les utilisateurs contrôlent leurs fonds. Si votre produit disparaît, les utilisateurs peuvent toujours accéder à leurs fonds et les déplacer.
 - **Prise en charge des portefeuilles matériels** - les utilisateurs peuvent connecter leur portefeuille matériel pour signer des transactions.
-- **WalletConnect** - les utilisateurs doivent pouvoir se connecter aux DApps en utilisant WalletConnect.
+- **WalletConnect** - les utilisateurs peuvent se connecter aux dapps en utilisant WalletConnect.
 - **Importation des points de terminaison RPC d'Ethereum** - les utilisateurs peuvent importer les données RPC d'un nœud, leur permettant de se connecter à un nœud de leur choix, ou à d'autres réseaux compatibles EVM.
-- **NFTs** - les utilisateurs sont en mesure de visualiser et d'interagir avec leurs NFTs dans le portefeuille.
+- **NFT** - les utilisateurs sont en mesure de visualiser et d'interagir avec leurs NFT dans le portefeuille.
 - **Connexion aux applications Ethereum** - les utilisateurs sont en mesure de se connecter à des applications Ethereum et de les utiliser.
 - **Mise en jeu** - les utilisateurs peuvent mettre en jeu directement via le portefeuille.
-- **Échanges** - les utilisateurs peuvent échanger des tokens directement via le portefeuille.
-- **Réseaux multichaînes** - votre portefeuille prend en charge par défaut l'accès à plusieurs réseaux blockchain.
-- **Réseaux de couche 2** - votre portefeuille prend en charge par défaut l'accès aux réseaux de seconde couche par défaut.
-- **Personnalisation des frais de gaz** - votre portefeuille permet aux utilisateurs de personnaliser les frais de gaz pour leurs transactions (frais de base, frais prioritaires, frais maximum).
+- **Échanges** - les utilisateurs peuvent échanger des jetons via le portefeuille.
+- **Réseaux multichaînes** - votre portefeuille permet aux utilisateurs d'accéder à plusieurs réseaux blockchain par défaut.
+- **Réseaux de couche 2** - votre portefeuille permet aux utilisateurs d'accéder par défaut aux réseaux de couche 2.
+- **Personnalisation des frais de gaz** - votre portefeuille permet aux utilisateurs de personnaliser les frais de gaz pour leurs transactions (frais de base, frais de priorité, frais maximum).
 - **Support ENS** - votre portefeuille permet aux utilisateurs d'envoyer des transactions à des noms ENS.
-- **Support ERC-20** - votre portefeuille permet aux utilisateurs d'importer des contrats de jetons ERC-20 ou d'afficher automatiquement les jetons ERC-20.
-- **Acheter de la crypto** - votre portefeuille permet aux utilisateurs d'acheter directement de la crypto.
+- **Support ERC-20** - votre portefeuille permet aux utilisateurs d'importer des contrats de jetons ERC-20, ou interroge et affiche automatiquement les jetons ERC-20.
+- **Acheter des cryptomonnaies** - votre portefeuille aide les utilisateurs à acheter directement des cryptomonnaies et facilite leurs premiers pas.
 - **Vente en fiat** - votre portefeuille permet aux utilisateurs de vendre et de retirer en fiat directement sur une carte ou un compte bancaire.
 - **Multisig** - votre portefeuille prend en charge des signatures multiples lors de la signature d'une transaction.
 - **Récupération sociale** - votre portefeuille prend en charge les gardiens et un utilisateur peut récupérer son portefeuille s'il perd sa phrase de récupération en utilisant ces gardiens.
@@ -62,7 +63,7 @@ Les portefeuilles évoluent rapidement sur Ethereum. Nous avons tenté de créer
 Si vous souhaitez ajouter un portefeuille sur ethereum.org, créez un ticket sur GitHub.
 
 <ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=wallet+%3Apurse%3A&template=suggest_wallet.yaml">
-  Créez un ticket
+Créer un ticket
 </ButtonLink>
 
 ## Maintenance {#maintenance}
@@ -72,9 +73,8 @@ Ethereum étant flexible par nature, les équipes et les produits vont et vienne
 - s'assurer que tous les portefeuilles et dapps listés répondent toujours à nos critères
 - vérifier qu'aucun produit suggéré ne répond à plus de nos critères que ceux actuellement répertoriés
 
-Ethereum.org est maintenu par la communauté open source & nous comptons sur la communauté pour nous aider à tenir le site à jour. Si vous remarquez que des informations sur les portefeuilles listés doivent être mises à jour, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=wallet+%3Apurse%3A&template=suggest_wallet.yaml) ou une [pull request](https://github.com/ethereum/ethereum-org-website/pulls) !
-
+ethereum.org est maintenu par la communauté open source et nous comptons sur la communauté pour nous aider à le maintenir à jour. Si vous remarquez des informations sur les portefeuilles répertoriés qui doivent être mises à jour, veuillez [ouvrir une issue](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=wallet+%3Apurse%3A&template=suggest_wallet.yaml) ou faire une [pull request](https://github.com/ethereum/ethereum-org-website/pulls) !
 
 ## Conditions d'utilisation {#terms-of-use}
 
-Veuillez également vous reporter à nos [conditions d'utilisation](/terms-of-use/). Les informations sur ethereum.org sont fournies uniquement à des fins d'information générale.
+Veuillez également vous reporter à nos [conditions d'utilisation](/terms-of-use/). Les informations sur ethereum.org sont fournies uniquement à des fins d'information générale.
diff --git a/public/content/translations/fr/contributing/content-resources/index.md b/public/content/translations/fr/contributing/content-resources/index.md
index 8d1f6574770..5f8c8442090 100644
--- a/public/content/translations/fr/contributing/content-resources/index.md
+++ b/public/content/translations/fr/contributing/content-resources/index.md
@@ -1,16 +1,16 @@
 ---
 title: Ajouter des ressources de contenu
 lang: fr
-description: Nos critères pour lister des ressources de contenu sur ethereum.org
+description: "Nos critères pour lister des ressources de contenu sur ethereum.org"
 ---
 
-# Ajouter des ressources de contenu {#adding-content-resources}
+# Ajout de ressources de contenu {#adding-content-resources}
 
 Nous ne pouvons espérer couvrir tout le sujet Ethereum et nous essayerons donc de mettre en valeur certains des meilleurs articles, tutoriels, bulletins d'information, offres d'emploi et diverses ressources de contenu que la communauté aura créés. Ils fournissent souvent des informations plus approfondies sur des sujets qui peuvent intéresser les utilisateurs.
 
 Si vous pensez qu'une ressource de contenu devrait être ajoutée à une page, n'hésitez pas à la suggérer sur la page appropriée.
 
-## Méthode de sélection {#how-we-decide}
+## Comment nous décidons {#how-we-decide}
 
 Les ressources d'apprentissage seront évaluées selon les critères suivants :
 
@@ -19,14 +19,14 @@ Les ressources d'apprentissage seront évaluées selon les critères suivants :
 - Les informations sont-elles exactes ? S'agit-il de faits ou d'opinions ?
 - L'auteur est-il crédible ? Référence-t-il ses sources ?
 - Ce contenu ajoute-t-il une valeur distincte que les ressources ou liens existants ne couvrent pas déjà ?
-- Ce contenu est-il utile à l'une de nos [catégories d'utilisateurs](https://www.notion.so/efdn/Ethereum-org-User-Persona-Memo-b44dc1e89152457a87ba872b0dfa366c) ?
+- Ce contenu est-il destiné à l'un de nos [personas d'utilisateurs](https://www.notion.so/efdn/Ethereum-org-User-Persona-Memo-b44dc1e89152457a87ba872b0dfa366c) ?
 
 ---
 
-## Ajout de votre ressource de contenu {#add-your-content-resource}
+## Ajoutez votre ressource de contenu {#add-your-content-resource}
 
 Si vous souhaitez ajouter une ressource de contenu à ethereum.org et qu'elle répond aux critères, créez un ticket sur GitHub.
 
 <ButtonLink href="https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=Type%3A+Feature&template=feature_request.yaml&title=">
-  Créez un ticket
+Créer un ticket
 </ButtonLink>
diff --git a/public/content/translations/fr/contributing/design-principles/index.md b/public/content/translations/fr/contributing/design-principles/index.md
index 74288b6587c..2f852de33c9 100644
--- a/public/content/translations/fr/contributing/design-principles/index.md
+++ b/public/content/translations/fr/contributing/design-principles/index.md
@@ -1,12 +1,12 @@
 ---
 title: Principes de conception
 lang: fr
-description: Les principes derrière les décisions concernant la conception et le contenu d'ethereum.org
+description: "Les principes derrière les décisions concernant la conception et le contenu d'ethereum.org"
 ---
 
 # Nos principes de conception {#contributing-to-ethereumorg-}
 
-<Emoji text=":wave:" size={1} /> Bonjour et bienvenue dans la découverte des principes de conception pour ethereum.org. Cela fait partie d'un processus continu visant à faire évoluer et à améliorer ethereum.org.
+<Emoji text=":wave:" size={1} /> Bonjour et bienvenue aux principes de conception d'ethereum.org. Cela fait partie d'un processus continu visant à faire évoluer et à améliorer ethereum.org.
 
 Nos principes informent quant à l'apparence et la convivialité du site et du contenu qui s'y trouve.
 
@@ -16,21 +16,21 @@ Lisez-les avant de [contribuer à ethereum.org](/contributing/).
 
 Ne vous inquiétez pas, ils sont assez simples ! **Les principes de conception** sont un ensemble de lignes directrices auxquelles nous nous référons lors de la conception (c'est-à-dire la création, la maintenance ou la mise à jour) de quelque chose.
 
-Dans le contexte d'ethereum.org, ces principes de conception sont la base de ce que nous voulons que le site web représente et projette au monde. Ils sont à la fois ambitieux **et** fonctionnels. Il ne s'agit pas seulement de l'_apparence_ du site, mais également de son _fonctionnement_, et même de ce qu'une personne _ressent_ en le parcourant. Tout, des couleurs aux mises en page en passant par la façon dont nous parlons d'Ethereum sur le site web, doit s'appuyer sur ces principes.
+Dans le contexte d'ethereum.org, ces principes de conception sont la base de ce que nous voulons que le site web représente et projette au monde. Ils sont à la fois ambitieux **et** fonctionnels. Il ne s'agit pas seulement de la façon dont le site web _paraît_, mais aussi de son _fonctionnement_ et même de ce qu'il _fait ressentir._ Tout, des couleurs aux mises en page en passant par la façon dont nous parlons d'Ethereum sur le site web, doit s'appuyer sur ces principes.
 
 ## Les principes en pratique {#how-decisions-about-the-site-are-made}
 
-Prenons un exemple. L'un des principes est « crédible », ce qui signifie que nous voulons que les visiteurs du site _sentent_ et _ sachent_ que le site est digne de confiance - tout comme, plus largement, l'écosystème Ethereum. Au sein même de ce principe, nous avons 3 « sous-principes » fonctionnels qui, selon nous, sont des mesures concrètes que nous pouvons prendre pour rendre le site crédible :
+Prenons un exemple. L'un des principes est « Crédible », ce qui signifie que nous voulons que les visiteurs du site _ressentent_ et _sachent_ que le site est digne de confiance, tout comme l'écosystème Ethereum au sens large. Au sein même de ce principe, nous avons 3 « sous-principes » fonctionnels qui, selon nous, sont des mesures concrètes que nous pouvons prendre pour rendre le site crédible :
 
 - _« Actuel »_, c'est-à-dire maintenir le contenu à jour.
-- _« Apportant une preuve sociale »_, c'est-à-dire montrer la taille, la diversité et l'activité de l'écosystème (vous savez, la progression de la mise à niveau d'Ethereum, la DeFi, les jeux, tous les hackathons, etc.)
-- _« Cohérent »_, c'est-à-dire assurer une cohérence dans la conception du site et dans le ton et la précision de l'écriture.
+- _« Preuve sociale »_, c'est-à-dire montrer la taille, la diversité et l'activité de l'écosystème (par exemple : la progression des mises à niveau d'Ethereum, la DeFi, les jeux, tous les hackathons, etc.)
+- _« Cohérent »_, c'est-à-dire la cohérence dans la conception du site, le ton et l'exactitude de la rédaction.
 
 Ainsi, lorsque nous prenons des décisions de conception ou de rédaction, nous pouvons alors faire référence au principe « crédible » et nous poser les questions suivantes :
 
-- _« Le site reflète-t-il les informations actuelles ? »_
-- _« Comment et où montrons-nous la taille et l'activité de l'écosystème ? »_
-- _« Les nouvelles contributions proposées par un membre de la communauté sont-elles cohérentes avec la conception et l'écriture actuelles sur le site ? »_
+- _« Le site reflète-t-il les informations actuelles ? »_
+- _« Comment et où montrons-nous la taille et l'activité de l'écosystème ? »_
+- _« Les nouvelles contributions proposées par un membre de la communauté que j'examine sont-elles conformes à la conception et à la rédaction actuelles du site ? »_
 
 ## Les principes de conception d'ethereum.org {#contributors}
 
@@ -39,7 +39,7 @@ Ainsi, lorsque nous prenons des décisions de conception ou de rédaction, nous
 Le site doit inspirer les utilisateurs à rêver de la façon dont Ethereum peut changer le monde. Il doit motiver les gens à explorer, jouer et bricoler avec les outils et les applications de l'écosystème Ethereum.
 
 - **Radical :** le site doit communiquer les objectifs ambitieux d'Ethereum pour changer le monde de manière significative. Il doit être clair qu'Ethereum n'est pas seulement une nouvelle pile technologique, mais une technologie transformationnelle.
-- **Renforcement par l'éducation :** le site doit informer les gens afin qu'ils puissent comprendre le potentiel d'Ethereum, trouver leur place dans l'écosystème et sentir qu'ils ont les moyens d'y participer.
+- **Autonomisation par l'éducation :** le site doit informer les gens afin qu'ils puissent comprendre le potentiel d'Ethereum, trouver leur place dans l'écosystème et se sentir habilités à y participer.
 
 Direction visuelle • Contenu
 
@@ -47,18 +47,18 @@ Direction visuelle • Contenu
 
 Ethereum est un projet mondial et décentralisé, et notre public le reflète. Le site doit aspirer à être accessible à tous et sensible aux nombreuses cultures du monde.
 
-- **Accessible :** le site doit suivre les directives d'accessibilité, y compris pour les personnes ayant des connexions à faible bande passante.
-- **Simple :** le site doit être simple et sans ambiguïté. Le texte ne doit pas utiliser un langage qui pourrait être mal interprété ou entraîner des problèmes de traduction.
-- **Ethereum a plusieurs facettes :** Ethereum est un projet, une base de code, une communauté et une vision. Ethereum est précieux pour différentes personnes pour différentes raisons, et il existe de nombreuses façons de s'impliquer.
+- **Accessible :** le site doit suivre les directives d'accessibilité, y compris pour les personnes disposant de connexions à faible bande passante.
+- **Clair et direct :** le site doit être simple et sans ambiguïté. Le texte ne doit pas utiliser un langage qui pourrait être mal interprété ou entraîner des problèmes de traduction.
+- **Ethereum a de multiples facettes :** Ethereum est un projet, une base de code, une communauté et une vision. Ethereum est précieux pour différentes personnes pour différentes raisons, et il existe de nombreuses façons de s'impliquer.
 
-Systèmes d'écriture • Utilisation de la couleur • Direction visuelle • Contenu
+Systèmes d'écriture • Utilisation de la couleur • Orientation visuelle • Contenu
 
-### 3. Une « bonne histoire » {#3-a-good-story}
+### 3. Une belle histoire {#3-a-good-story}
 
 Le site web devrait fonctionner comme une bonne histoire. Les visiteurs sont en voyage, et le contenu auquel vous contribuez en fait partie. Vos contributions doivent s'inscrire dans un récit clair : un début (introduction/point d'entrée), un milieu (ensemble d'enseignements et d'idées) et une fin (un lien vers des ressources pertinentes ou des étapes suivantes).
 
-- **Hiérarchique :** une architecture d'information claire et hiérarchisée aide les visiteurs d'ethereum.org à naviguer sur le site « comme une histoire » au fur et à mesure qu'ils cherchent à accéder à ce qu'ils souhaitent.
-- **Un tremplin :** nous sommes un premier pas, un tremplin pour tous ceux qui recherchent des réponses. Nous ne voulons pas remplacer ou devenir un substitut des nombreuses ressources qui existent déjà. Nous donnons des réponses et indiquons des pistes sérieuses pour la suite.
+- **Hiérarchique** : une architecture de l'information claire et hiérarchisée aide les visiteurs d'ethereum.org à naviguer sur le site "comme une histoire" alors qu'ils cherchent à atteindre leurs objectifs.
+- **Un tremplin :** nous sommes un tremplin pour quiconque cherche des réponses. Nous ne voulons pas remplacer ou devenir un substitut des nombreuses ressources qui existent déjà. Nous donnons une réponse et proposons des étapes suivantes fiables.
 
 Voyages de l'utilisateur • Contenu
 
@@ -66,9 +66,9 @@ Voyages de l'utilisateur • Contenu
 
 Les gens peuvent chercher à découvrir l'écosystème Ethereum ou ils peuvent être sceptiques. Reconnaissez cette responsabilité dans la façon dont vous communiquez. Assurez-vous que ces deux catégories de personnes quitteront la page avec une plus grande confiance dans l'écosystème Ethereum.
 
-- **Actuel :** toujours à jour.
-- **Apportant une preuve sociale :** montre la taille, la diversité et l'activité de l'écosystème.
-- **Cohérent :** la cohérence dans la conception et le contenu assure la crédibilité.
+- **Actuel :** toujours à jour.
+- **Preuve sociale :** montrer la taille, la diversité et l'activité de l'écosystème.
+- **Cohérent :** la cohérence dans la conception et le contenu communique la crédibilité.
 
 Direction visuelle • Contenu
 
@@ -76,18 +76,18 @@ Direction visuelle • Contenu
 
 Le site web est le produit de nombreux contributeurs, tout comme l'écosystème dans son ensemble.
 
-- **Ouvert :** célébrez la transparence du code source, des processus et des projets dans l'ensemble de l'écosystème.
-- **Extensible :** la modularité est un élément clé derrière tout ce que nous faisons et les contributions devraient donc également être modulaires. La conception de base, le code des composants et la mise en œuvre du site devraient permettre de l'étendre facilement à l'avenir.
-- **Expérimental :** nous expérimentons, testons et itérons en permanence.
-- **Collaboratif :** ce projet nous réunit tous.
-- **Durable :** préparer une maintenance à long terme par la communauté.
+- **Ouvert :** célébrer la transparence du code source, des processus et des projets à travers l'écosystème.
+- **Extensible :** la modularité est un axe essentiel de tout ce que nous faisons, et les contributions doivent donc également être modulaires. La conception de base, le code des composants et la mise en œuvre du site devraient permettre de l'étendre facilement à l'avenir.
+- **Expérimental :** nous expérimentons, testons et itérons en permanence.
+- **Collaboratif :** ce projet nous rassemble tous.
+- **Durable :** mettre en place une maintenance à long terme par la communauté.
 
-Vous pouvez voir nos principes de conception en action [dans l'ensemble de notre site](/).
+Vous pouvez voir nos principes de conception en action [sur l'ensemble de notre site](/).
 
-## Donnez-nous votre avis {#give-feedback}
+## Donner votre avis {#give-feedback}
 
-**Partagez vos commentaires sur ce document !** L'un des principes que nous proposons est l'« **amélioration collaborative** », ce qui signifie que nous voulons que le site web soit le produit de nombreux contributeurs. Dans l'esprit de ce principe, nous voulons donc partager ces principes de conception avec la communauté Ethereum.
+**Partagez vos commentaires sur ce document !** L'un de nos principes proposés est « **Amélioration collaborative** », ce qui signifie que nous voulons que le site web soit le fruit du travail de nombreux contributeurs. Dans l'esprit de ce principe, nous voulons donc partager ces principes de conception avec la communauté Ethereum.
 
-Bien que ces principes soient axés sur le site web ethereum.org, nous espérons que beaucoup d'entre eux sont représentatifs des valeurs de l'écosystème Ethereum dans son ensemble. Peut-être voudrez-vous même incorporer certains d'entre eux dans votre propre projet !
+Bien que ces principes soient axés sur le site web ethereum.org, nous espérons que nombre d'entre eux sont représentatifs des valeurs de l'écosystème Ethereum dans son ensemble. Peut-être voudrez-vous même incorporer certains d'entre eux dans votre propre projet !
 
-Faites-nous part de vos commentaires sur le [serveur Discord](https://discord.gg/ethereum-org) ou en [créant un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=Type%3A+Feature&template=feature_request.yaml&title=).
+Faites-nous part de vos réflexions sur le [serveur Discord](https://discord.gg/ethereum-org) ou en [créant un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=Type%3A+Feature&template=feature_request.yaml&title=).
diff --git a/public/content/translations/fr/contributing/design/adding-design-resources/index.md b/public/content/translations/fr/contributing/design/adding-design-resources/index.md
index 3643266e869..bb8b8cb4fb4 100644
--- a/public/content/translations/fr/contributing/design/adding-design-resources/index.md
+++ b/public/content/translations/fr/contributing/design/adding-design-resources/index.md
@@ -1,12 +1,12 @@
 ---
 title: Ajout de ressources de conception
-description: Directives et exigences pour garantir la qualité des matériaux de conception sur ethereum.org
+description: "Directives et exigences pour garantir la qualité des matériaux de conception sur ethereum.org"
 lang: fr
 ---
 
 # Ajout de ressources de conception {#adding-design-resources}
 
-Toute personne peut suggérer de nouveaux matériaux de conception à la page [Design et UX dans le web3](/developers/docs/design-and-ux/).
+Tout le monde peut proposer de nouveaux supports de conception pour la [page sur le design et l'UX dans le Web3](/developers/docs/design-and-ux/).
 
 Il est important de noter que l'objectif de cette page est de fournir une aide aux utilisateurs aspirant à devenir des concepteurs web3. Cette section n'est pas destinée à faire la publicité de vos services, produits ou plateformes.
 
@@ -56,7 +56,7 @@ a. L'objectif principal de l'article devrait être de partager des informations
 
 a. Les avantages de devenir membre devraient être affichés de manière notable.
 
-**Exemples** : recevoir des retours sur son travail, accéder à des opportunités d'emploi ou des primes, partager des connaissances en conception et en recherche.
+**Exemples** : recevoir des retours sur son travail, accéder à des opportunités d'emploi ou à des primes, partager des connaissances en conception et en recherche.
 
 3. Communication Active et Dynamique sur Discord
 
diff --git a/public/content/translations/fr/contributing/design/index.md b/public/content/translations/fr/contributing/design/index.md
index c85dbb697c4..75c0a78bd0e 100644
--- a/public/content/translations/fr/contributing/design/index.md
+++ b/public/content/translations/fr/contributing/design/index.md
@@ -1,10 +1,10 @@
 ---
-title: Contribuer à la conception
-description: Contribuer à la conception d'ethereum.org
+title: "Contribuer à la conception"
+description: "Contribuer à la conception d'ethereum.org"
 lang: fr
 ---
 
-# Contribuer à la conception d'ethereum.org {#design-contributions}
+# Contribution au design d'ethereum.org {#design-contributions}
 
 La conception est une composante essentielle de tout projet, et en consacrant votre temps et vos compétences en la matière à ethereum.org, vous pouvez contribuer à améliorer l'expérience utilisateur de nos visiteurs. Contribuer à un projet open-source offre l'opportunité d'acquérir une expérience pertinente et de développer vos compétences dans un environnement collaboratif. Vous aurez l'occasion de travailler avec d'autres concepteurs, développeurs et membres de la communauté, chacun ayant ses propres perspectives et idées uniques.
 
@@ -12,15 +12,15 @@ Finalement, c'est une excellente façon de construire un portfolio diversifié e
 
 ## Comment contribuer ?
 
-### <Emoji text=":one:" size={1} /> &nbsp;Fournir des commentaires sur les prototypes de conception {#design-critique}
+### <Emoji text=":one:" size={1} /> &nbsp;Fournissez des commentaires sur les premiers prototypes de conception {#design-critique}
 
 Nous avons parfois besoin d'aide pour tester nos nouveautés. C'est une excellente manière de contribuer sans avoir de connaissances techniques.
 
-1. L'équipe de conception partagera une maquette sur le [Discord](https://discord.com/invite/ethereum-org) et sur [GitHub](https://github.com/ethereum/ethereum-org-website/labels/design%20required%20%F0%9F%8E%A8).
+1. L'équipe de conception partagera une maquette sur [Discord](https://discord.com/invite/ethereum-org) et sur [GitHub](https://github.com/ethereum/ethereum-org-website/labels/design%20required%20%F0%9F%8E%A8).
 2. Vous serez guidé à travers les conceptions pour fournir des commentaires via la fonction de commentaires.
 3. Le résultat sera partagé dans une demande GitHub puis fermé par l'équipe.
 
-### <Emoji text=":two:" size={1} /> &nbsp;Participer à des enquêtes de recherche {#answer-surveys}
+### <Emoji text=":two:" size={1} /> &nbsp;Participez aux enquêtes {#answer-surveys}
 
 Fournir des commentaires sur notre site web en :
 
@@ -28,28 +28,28 @@ Fournir des commentaires sur notre site web en :
 2. Cliquant sur le bouton de commentaire dans le coin inférieur droit et en répondant aux questions liées à la conception et au contenu.
 3. Se concentrer sur les questions de format libre.
 
-### <Emoji text=":three:" size={1} /> &nbsp;Trouver des problèmes liés à la conception du site web et les signaler {#report-design-issues}
+### <Emoji text=":three:" size={1} /> &nbsp;Trouvez les problèmes de conception sur le site web et signalez-les {#report-design-issues}
 
 ethereum.org est un site web en pleine expansion avec de nombreuses fonctionnalités et contenus. Certaines des interfaces utilisateur peuvent facilement devenir obsolètes ou pourraient être améliorées. Si vous rencontrez un tel cas, veuillez le signaler afin que nous y portions notre attention.
 
 1. Parcourir le site web et observer avec attention sa conception.
 2. Prenez des captures d'écran et des notes si vous voyez des problèmes visuels ou d'expérience utilisateur.
-3. Signalez les problèmes trouvés en utilisant un [rapport de bug](https://github.com/ethereum/ethereum-org-website/issues/new/choose).
+3. Signalez les problèmes trouvés à l'aide d'un [rapport de bogue](https://github.com/ethereum/ethereum-org-website/issues/new/choose).
 
 ### <Emoji text=":four:" size={1} /> &nbsp;Proposez des modifications de conception {#propose-design-changes}
 
-Si vous en avez l'envie, vous pouvez relever des défis de conception. Visitez notre tableau des problèmes sur GitHub et opérez un filtrage pour les [problèmes liés à la conception](https://github.com/ethereum/ethereum-org-website/labels/design%20required%20%F0%9F%8E%A8).
+Si vous êtes à l'aise avec les défis de conception, vous pouvez consulter notre tableau des problèmes sur GitHub et filtrer les [problèmes liés à la conception](https://github.com/ethereum/ethereum-org-website/labels/design%20required%20%F0%9F%8E%A8).
 
-1. Parcourez notre site web et prêtez attention à sa conception ou rendez-vous sur notre dépôt GitHub et examinez les problèmes marqués avec le tag [« Design required »](https://github.com/ethereum/ethereum-org-website/labels/design%20required%20%F0%9F%8E%A8).
+1. Parcourez notre site web et prêtez attention à sa conception ou rendez-vous sur notre dépôt GitHub et examinez les problèmes signalés avec [l'étiquette « Design required »](https://github.com/ethereum/ethereum-org-website/labels/design%20required%20%F0%9F%8E%A8).
 2. Réfléchissez à la solution et concevez-la. (idéalement en utilisant notre [système de conception](https://www.figma.com/community/file/1134414495420383395)).
-3. Proposez la solution dans le problème correspondant sur GitHub ou [créez-en une nouvelle.](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A&template=feature_request.yaml&title=Feature+request)
+3. Proposez la solution dans le problème GitHub correspondant ou [créez-en un nouveau.](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=feature+%3Asparkles%3A&template=feature_request.yaml&title=Feature+request)
 4. Attendez que l'équipe de conception l'examine.
 
-### <Emoji text=":five:" size={1} /> &nbsp;Construisons le système de conception ensemble {#Contribute-to-design-system}
+### <Emoji text=":five:" size={1} /> &nbsp;Construisez le système de conception ensemble {#Contribute-to-design-system}
 
 Notre système de concep rend la conception d'ethereum.org amusante et facile. Si vous êtes un concepteur expérimenté, vous pouvez nous aider à préparer de nombreux composants pour le site web.
 
-1. Sélectionnez un problème sur lequel travailler à partir du [tableau du système de conception](https://github.com/ethereum/ethereum-org-website/labels/design%20system) sur GitHub ou créez-en un nouveau.
+1. Sélectionnez un problème sur lequel travailler depuis le [tableau du système de conception](https://github.com/ethereum/ethereum-org-website/labels/design%20system) sur GitHub ou créez-en un nouveau.
 2. Demandez à ce que le ticket sélectionné vous soit attribué.
 3. Commencez à concevoir la maquette demandée sur Figma.
 4. Partagez-le avec l'équipe de conception sur GitHub lorsque vous avez besoin d'une revue ou de conseils.
@@ -58,10 +58,10 @@ Notre système de concep rend la conception d'ethereum.org amusante et facile. S
 
 ### <Emoji text=":six:" size={1} /> &nbsp;Rédigez du contenu lié à la conception sur le site web {#write-design-articles}
 
-La communauté des développeurs Ethereum est solide, mais la communauté des designers est un peu à la traîne. Si vous êtes un concepteur avec des connaissances en web3, envisagez de partager vos découvertes avec toute la communauté afin que nous puissions tous grandir et nous améliorer ensemble ; nous avons [une page sur la conception pour Ethereum](/developers/docs/design-and-ux/) à laquelle vous pouvez contribuer. Vous pouvez également consulter nos [politiques de référencement](/contributing/design/adding-design-resources).
+La communauté des développeurs Ethereum est solide, mais la communauté des designers est un peu à la traîne. Si vous êtes un concepteur avec des connaissances en web3, nous vous invitons à partager vos apprentissages avec la communauté au sens large afin que nous puissions tous grandir et nous améliorer ensemble ; nous avons [une page sur la conception pour Ethereum](/developers/docs/design-and-ux/) à laquelle vous pouvez contribuer. Vous pouvez également consulter nos [politiques de référencement](/contributing/design/adding-design-resources).
 
 1. Réfléchissez sur les sujets de conception qui devraient être abordés sur ethereum.org et qui seraient bénéfiques pour les concepteurs dans ce domaine.
-2. Rendez-vous sur notre dépôt GitHub et [soumettez un problème](https://github.com/ethereum/ethereum-org-website/issues/new) en proposant un sujet (ne rédigez pas encore le contenu).
+2. Rendez-vous sur notre dépôt GitHub et [ouvrez un problème](https://github.com/ethereum/ethereum-org-website/issues/new) pour proposer un sujet (ne rédigez pas encore le contenu).
 3. Attendez que l'équipe de conception donne son approbation.
 4. Une fois approuvé, rédigez le contenu.
 5. Soumettez-le dans le ticket GitHub correspondant.
@@ -71,7 +71,7 @@ La communauté des développeurs Ethereum est solide, mais la communauté des de
 Les images sont l'un des outils les plus puissants pour expliquer des sujets abstraits. Il y a un énorme potentiel en ajoutant des diagrammes et des infographies. Après tout, une image vaut mille mots.
 
 1. Visitez notre site web et identifiez les pages où de nouvelles infographies pourraient être ajoutées.
-2. Assurez-vous que le style de l'illustration correspond à [nos ressources](/assets/).
-3. Rendez-vous sur notre dépôt GitHub et [émettez une demande](https://github.com/ethereum/ethereum-org-website/issues/new) concernant l'illustration.
+2. Assurez-vous que le style de l'illustration correspond à nos [ressources](/assets/).
+3. Rendez-vous sur notre dépôt GitHub et [ouvrez un problème](https://github.com/ethereum/ethereum-org-website/issues/new) pour proposer l'illustration.
 4. L'équipe de conception l'examinera.
 5. Nous créons une nouvelle demande pour qu'un développeur implémente la nouvelle image.
diff --git a/public/content/translations/fr/contributing/quizzes/index.md b/public/content/translations/fr/contributing/quizzes/index.md
index 00fdea1f525..e34837d3371 100644
--- a/public/content/translations/fr/contributing/quizzes/index.md
+++ b/public/content/translations/fr/contributing/quizzes/index.md
@@ -4,7 +4,7 @@ description: La politique que nous appliquons pour ajouter des quiz sur ethereum
 lang: fr
 ---
 
-# Quiz {#quizzes}
+# Questionnaires {#quizzes}
 
 Les quiz permettent aux utilisateurs de vérifier s'ils ont bien compris le contenu de la page qu'ils viennent de lire. Les questions doivent être basées sur le contenu de la page et ne doivent pas porter sur des informations qui n'y sont pas mentionnées.
 
@@ -15,11 +15,11 @@ Vous trouverez ici quelques exemples de quiz actuels :
 - [Couche 2](/layer-2)
 - [NFT](/nft/)
 - [Qu'est-ce qu'Ethereum ?](/what-is-ethereum/)
-- [Qu'est-ce que l'ETH ?](/what-is-ether/)
+- [Qu'est-ce que l'ETH ?](/what-is-ether/)
 
 ## Ajouter un quiz d'apprentissage
 
-Si une page n'a pas encore fait l'objet d'un quiz éducatif, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) pour cette page.
+S'il existe une page pour laquelle aucun questionnaire d'apprentissage n'a été créé, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) à ce sujet.
 
 Veuillez fournir les informations suivantes :
 
@@ -32,7 +32,7 @@ Veuillez fournir les informations suivantes :
 
 ## Ajouter une question de quiz
 
-Si vous souhaitez ajouter une question à la base de questions d'un quiz, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) et fournir les informations suivantes :
+Si vous souhaitez ajouter une question à la banque de questions pour un questionnaire, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) et fournir les informations suivantes :
 
 - La page sur laquelle vous souhaitez ajouter une question de quiz
 - Pour chaque question, fournir les informations suivantes :
@@ -43,7 +43,7 @@ Si vous souhaitez ajouter une question à la base de questions d'un quiz, veuill
 
 ## Mettre à jour une question de quiz
 
-Si vous souhaitez mettre à jour une question dans la base de questions d'un quiz, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) et fournir les informations suivantes :
+Si vous souhaitez mettre à jour une question dans la banque de questions d'un questionnaire, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) et fournir les informations suivantes :
 
 - La page sur laquelle vous souhaitez mettre à jour une question de quiz
 - Pour chaque question modifiée, veuillez fournir les informations suivantes :
@@ -55,7 +55,7 @@ Si vous souhaitez mettre à jour une question dans la base de questions d'un qui
 
 ## Supprimer une question de quiz
 
-Si le contenu d'une question n'existe plus sur la page et que celle-ci doit être supprimée, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) pour supprimer la question et fournir les informations suivantes :
+Si le contenu d'une question n'existe plus sur la page et qu'elle doit être supprimée, veuillez [ouvrir un ticket](https://github.com/ethereum/ethereum-org-website/issues/new?assignees=&labels=&template=suggest_quiz.yaml) pour supprimer la question et fournir les informations suivantes :
 
 - La page sur laquelle vous souhaitez supprimer une question de quiz
 - La question que vous souhaitez supprimer
diff --git a/public/content/translations/fr/contributing/translation-program/faq/index.md b/public/content/translations/fr/contributing/translation-program/faq/index.md
index 7c4e3c9facc..6476d62437e 100644
--- a/public/content/translations/fr/contributing/translation-program/faq/index.md
+++ b/public/content/translations/fr/contributing/translation-program/faq/index.md
@@ -1,10 +1,10 @@
 ---
 title: Foire aux questions du programme de traduction (FAQ)
 lang: fr
-description: Questions fréquentes sur le programme de traduction d'ethereum.org
+description: "Questions fréquentes sur le programme de traduction d'ethereum.org"
 ---
 
-# Guide de traduction du site ethereum.org {#translating-ethereum-guide}
+# Guide de traduction d'ethereum.org {#translating-ethereum-guide}
 
 Si vous n'avez jamais utilisé de logiciels de traduction et hésitez à vous lancer, voici quelques questions/réponses pour commencer. Utilisez ce guide pour trouver les réponses aux questions les plus courantes.
 
@@ -18,31 +18,31 @@ Le but du programme de traduction est de rendre le contenu Ethereum accessible 
 
 Par conséquent, le programme de traduction est ouvert et sur la base du volontariat, et la participation n'est pas rémunérée. Si nous devions indemniser les traducteurs pour le nombre de mots qu'ils traduisent, nous ne pourrions inviter que ceux qui ont une expérience de traduction suffisante (traducteurs professionnels) à rejoindre le programme de traduction. Cela rendrait le programme de traduction exclusif et nous empêcherait d'atteindre les objectifs énoncés, en particulier : permettre à chacun de participer et de s'impliquer dans l'écosystème.
 
-Nous faisons tout notre possible pour permettre à nos contributeurs de réussir dans l'écosystème Ethereum. De nombreuses incitations non monétaires sont en place, notamment [l'offre de POAP](/contributing/translation-program/acknowledgements/#poap) et la délivrance d'un certificat de traducteur[](/contributing/translation-program/acknowledgements/#certificate), ainsi que l'organisation de [classements des traducteurs](/contributing/translation-program/acknowledgements/) et [la mention de tous nos traducteurs sur le site](/contributing/translation-program/contributors/).
+Nous mettons tout en œuvre pour permettre à nos contributeurs de réussir dans l'écosystème Ethereum ; de nombreuses incitations non monétaires sont en place, telles que : [l'offre de POAP](/contributing/translation-program/acknowledgements/#poap) et d'un [certificat de traducteur](/contributing/translation-program/acknowledgements/#certificate), ainsi que l'organisation des [classements des traducteurs](/contributing/translation-program/acknowledgements/) et [la publication de la liste de tous nos traducteurs sur le site](/contributing/translation-program/contributors/).
 
-## Comment traduire des chaînes avec des balises `<HTML tags>` ? {#tags}
+## Comment traduire des chaînes avec des `<balises HTML>` ? {#tags}
 
-Toutes les chaînes ne sont pas écrites sous forme de texte pur. Certaines se composent de scripts mixtes comme des balises HTML (`<0>`, `</0>`), généralement utilisées pour les hyperliens ou les styles de caractère au sein d'une phrase.
+Toutes les chaînes ne sont pas écrites sous forme de texte pur. Certaines chaînes se composent de scripts mixtes comme des balises HTML (`<0>`, `</0>`). Ceci est généralement utilisé pour les hyperliens ou les styles alternatifs au milieu d'une phrase.
 
-- Traduisez le texte à l'intérieur des balises, mais pas les balises elles-mêmes. Tout ce qui se trouve entre les `<` et `>` ne doit pas être traduit ni supprimé.
+- Traduisez le texte à l'intérieur des balises, mais pas les balises elles-mêmes. Tout ce qui se trouve dans les chevrons `<` et `>` ne doit pas être traduit ou supprimé.
 - Pour éviter tout problème dans la chaîne, nous vous recommandons de cliquer sur le bouton « Copy Source » (Copier la source) situé en bas à gauche. La chaîne d'origine sera copiée et collée dans la zone texte. Cela vous permet de savoir clairement où se trouvent les balises et vous aide à éviter les erreurs.
 
-![Interface Crowdin avec le bouton copy source mis en évidence](./html-tag-strings.png)
+![Interface Crowdin avec le bouton « Copier la source » en surbrillance](./html-tag-strings.png)
 
 Vous pouvez déplacer les balises dans la chaîne pour la rendre plus naturelle dans votre langue. Assurez-vous de bien déplacer la balise entière.
 
-Pour des informations plus détaillées sur le traitement des balises et des extraits de code, veuillez vous référer au [guide de style pour la traduction d'ethereum.org](/contributing/translation-program/translators-guide/#dealing-with-tags).
+Pour obtenir des informations plus détaillées sur la gestion des balises et des extraits de code, veuillez vous référer au [guide de style de traduction d'ethereum.org](/contributing/translation-program/translators-guide/#dealing-with-tags).
 
 ## Où sont réellement les chaînes ? {#strings}
 
 Souvent, les chaînes sources seules ne sont pas suffisantes pour fournir une traduction précise.
 
 - Jetez un coup d'œil aux captures d'écran et au contexte pour plus d'informations. Dans la section « Source String » (Chaîne source), vous verrez la capture d'écran correspondante qui vous montrera comment la chaîne est utilisée en contexte.
-- Si vous avez encore des doutes, signalez-le dans la section « Comments » (Commentaires). [Comment laisser un commentaire ?](#comment)
+- Si vous avez encore des doutes, signalez-le dans la section « Comments » (Commentaires). [Vous ne savez pas comment laisser un commentaire ?](#comment)
 
-![Image montrant comment du contexte peut être fourni pour une phrase avec une capture d'écran](./source-string.png)
+![Montre comment le contexte d'une chaîne peut être fourni avec une capture d'écran](./source-string.png)
 
-![Un exemple de capture d'écran ajoutée pour le contexte](./source-string-2.png)
+![Exemple de capture d'écran ajoutée pour le contexte](./source-string-2.png)
 
 ## Comment laisser des commentaires ou poser des questions ? Je voudrais signaler un problème ou une faute de frappe... {#comment}
 
@@ -52,36 +52,36 @@ Si vous voulez signaler une chaîne particulière qui a besoin d'être examinée
 - Une fois le commentaire envoyé, notre équipe en sera informée. Nous résoudrons le problème et vous le ferons savoir en répondant à votre commentaire et en clôturant le problème.
 - Si vous signalez une traduction incorrecte, la traduction initiale ainsi que votre proposition seront revues par un locuteur natif lors de la prochaine révision.
 
-![Image montrant comment écrire des commentaires et signaler des problèmes/poser des questions](./comment-issue.png)
+![Montre comment ajouter des commentaires et des problèmes](./comment-issue.png)
 
 ## Qu'est-ce que la mémoire de traduction (TM) ? {#translation-memory}
 
-La mémoire de traduction (TM, de l'anglais Translation Memory) est une fonctionnalité de Crowdin qui stocke toutes les chaînes précédemment traduites sur [ethereum.org](https://ethereum.org/). Lorsqu'une chaîne de caractères est traduite, elle est automatiquement enregistrée dans notre TM du projet. Cela peut être un outil utile pour vous aider à gagner du temps !
+La mémoire de traduction (TM, de l'anglais Translation Memory) est une fonctionnalité de Crowdin qui stocke toutes les chaînes précédemment traduites sur ethereum.org. Lorsqu'une chaîne de caractères est traduite, elle est automatiquement enregistrée dans notre TM du projet. Cela peut être un outil utile pour vous aider à gagner du temps !
 
 - Regardez la section « TM and MT Suggestions » (Suggestions de la mémoire de traduction et de traduction automatique) et vous verrez comment les autres traducteurs ont traduit la phrase ou une phrase similaire. Si vous trouvez une suggestion qui correspond, n'hésitez pas à l'utiliser en cliquant dessus.
 - S'il n'y a rien dans la liste, vous pouvez rechercher dans la TM des traductions faites précédemment et les réutiliser pour assurer la cohérence.
 
-![Une capture d'écran de la mémoire de traduction](./translation-memory.png)
+![Capture d'écran de la mémoire de traduction](./translation-memory.png)
 
 ## Comment utiliser le glossaire Crowdin ? {#glossary}
 
-La terminologie Ethereum est un autre élément crucial de notre travail de traduction, car souvent les nouveaux termes technologiques n'auront pas encore d'équivalents dans de nombreuses langues. Certains termes ont également des significations différentes dans différents contextes. [En savoir plus sur la traduction de la terminologie Ethereum](#terminology)
+La terminologie Ethereum est un autre élément crucial de notre travail de traduction, car souvent les nouveaux termes technologiques n'auront pas encore d'équivalents dans de nombreuses langues. Certains termes ont également des significations différentes dans différents contextes. [En savoir plus sur la traduction de la terminologie d'Ethereum](#terminology)
 
 Le glossaire Crowdin est le meilleur endroit pour clarifier les termes et les définitions. Il y a deux façons de se référer au glossaire.
 
 - Premièrement, lorsque vous voyez un terme souligné dans la chaîne source, vous pouvez le survoler, ce qui affichera une brève définition.
 
-![Un exemple de définition du glossaire](./glossary-definition.png)
+![Exemple de définition de glossaire](./glossary-definition.png)
 
 - Deuxièmement, si vous voyez un terme qui ne vous est pas familier, mais qui n'est pas souligné, vous pouvez effectuer une recherche dans l'onglet du glossaire (le troisième bouton de la colonne de droite). Vous trouverez des explications sur des termes spécifiques et sur ceux fréquemment utilisés dans le projet.
 
-![Une capture d'écran montrant où trouver l'onglet glossaire dans Crowdin](./glossary-tab.png)
+![Capture d'écran montrant où trouver l'onglet du glossaire dans Crowdin](./glossary-tab.png)
 
 - Si vous ne trouvez toujours pas votre terme, c'est l'occasion d'ajouter un nouveau terme ! Nous vous encourageons à le rechercher sur un moteur de recherche et à ajouter la description au glossaire. Cela sera d'une grande aide aux autres traducteurs pour mieux comprendre le terme.
 
-![Une capture d'écran montrant comment ajouter un terme au glossaire de Crowdin](./add-glossary-term.png)
+![Capture d'écran montrant comment ajouter un terme au glossaire dans Crowdin](./add-glossary-term.png)
 
-### Politique de traduction terminologique {#terminology}
+### Politique de traduction de la terminologie {#terminology}
 
 _Pour les noms (marques, entreprises, personnes) et les nouveaux termes technologiques (chaîne phare, chaîne de fragments, etc.)_
 
@@ -93,7 +93,7 @@ Après mûre réflexion, nous avons pris la décision de laisser le choix de la
 
 Voici ce que nous suggérons lorsque vous trouvez un terme qui vous est inconnu :
 
-- Reportez-vous au [glossaire des termes](#glossary), vous pourriez y trouver comment d'autres traducteurs l'ont traduit précédemment. Si vous pensez que le terme précédemment traduit n'est pas approprié, n'hésitez pas à proposer votre traduction en ajoutant un nouveau terme au glossaire Crowdin.
+- Reportez-vous au [Glossaire des termes](#glossary), vous y trouverez peut-être la façon dont d'autres traducteurs l'ont traduit précédemment. Si vous pensez que le terme précédemment traduit n'est pas approprié, n'hésitez pas à proposer votre traduction en ajoutant un nouveau terme au glossaire Crowdin.
 - Si aucune traduction précédente n'existe dans le glossaire, nous vous encourageons à rechercher le terme sur un moteur de recherche ou dans un article de presse pour déterminer comment le terme est réellement utilisé dans votre communauté.
 - Si vous ne trouvez aucune référence, n'hésitez pas à faire confiance à votre intuition et à suggérer une nouvelle traduction dans votre langue !
 - Si vous n'êtes pas très confiant à cette idée, laissez le terme non traduit. Parfois, les termes anglais sont plus qu'adéquats pour fournir des définitions précises.
@@ -102,18 +102,18 @@ Nous vous recommandons de laisser les noms des marques, des entreprises et des p
 
 ## Comment fonctionne le processus de révision ? {#review-process}
 
-Pour assurer un certain niveau de qualité et de cohérence dans nos traductions, nous travaillons avec [Acolad](https://www.acolad.com/), l'un des plus grands fournisseurs de services linguistiques au monde. Acolad compte 20 000 linguistes professionnels, ce qui signifie qu'ils peuvent fournir des réviseurs professionnels pour chaque langue et chaque type de contenu dont nous avons besoin.
+Pour garantir un certain niveau de qualité et de cohérence dans nos traductions, nous travaillons avec [Acolad](https://www.acolad.com/), l'un des plus grands fournisseurs de services linguistiques au monde. Acolad compte 20 000 linguistes professionnels, ce qui signifie qu'ils peuvent fournir des réviseurs professionnels pour chaque langue et chaque type de contenu dont nous avons besoin.
 
-Le processus de révision est simple ; une fois qu'un certain [ensemble de contenu](/contributing/translation-program/) est traduit à 100 %, nous commandons une révision pour cet ensemble de contenu. Le processus de révision se déroule directement dans Crowdin. Une fois la révision terminée, nous mettons à jour le site web avec le contenu traduit.
+Le processus de révision est simple ; une fois qu'un ensemble de contenu est traduit à 100 %, nous commandons une révision pour ce lot de contenu. Le processus de révision se déroule directement dans Crowdin. Une fois la révision terminée, nous mettons à jour le site web avec le contenu traduit.
 
 ## Comment ajouter du contenu dans ma langue ? {#adding-foreign-language-content}
 
 Actuellement, tout le contenu dans d'autres langues que l'anglais a été traduit directement à partir du contenu source anglais, et tout contenu qui n'existe pas en anglais ne peut être ajouté dans les autres langues.
 
-Pour proposer du nouveau contenu pour ethereum.org, vous pouvez [créer un ticket](https://github.com/ethereum/ethereum-org-website/issues) sur GitHub. S'il est ajouté, le contenu sera écrit en anglais et traduit par la suite dans d'autres langues à l'aide de Crowdin.
+Pour suggérer du nouveau contenu pour ethereum.org, vous pouvez [créer un problème](https://github.com/ethereum/ethereum-org-website/issues) sur GitHub. S'il est ajouté, le contenu sera écrit en anglais et traduit par la suite dans d'autres langues à l'aide de Crowdin.
 
 Nous prévoyons de prendre en charge l'ajout de contenu dans d'autres langues que l'anglais dans un futur proche.
 
-## Nous contacter {#contact}
+## Contactez-nous {#contact}
 
-Je vous remercie d'avoir lu toutes ces informations. Nous espérons que cela vous aidera à participer à notre programme. N'hésitez pas à rejoindre notre [canal de traduction sur Discord](https://discord.gg/ethereum-org) afin de poser des questions et de travailler avec les autres traducteurs, ou à nous contacter à l'adresse translations@ethereum.org !
+Je vous remercie d'avoir lu toutes ces informations. Nous espérons que cela vous aidera à participer à notre programme. N'hésitez pas à rejoindre notre [canal de traduction Discord](https://discord.gg/ethereum-org) pour poser des questions et collaborer avec d'autres traducteurs, ou contactez-nous à l'adresse translations@ethereum.org !
diff --git a/public/content/translations/fr/contributing/translation-program/how-to-translate/index.md b/public/content/translations/fr/contributing/translation-program/how-to-translate/index.md
index b50a3cbca83..e945092b8b2 100644
--- a/public/content/translations/fr/contributing/translation-program/how-to-translate/index.md
+++ b/public/content/translations/fr/contributing/translation-program/how-to-translate/index.md
@@ -22,28 +22,27 @@ Vous devrez vous connecter à votre compte Crowdin ou vous inscrire si vous n'av
   Rejoindre le projet
 </ButtonLink>
 
-### Accédez à votre langue {#open-language}
+### Ouvrez votre langue {#open-language}
 
-Après vous être connecté à Crowdin, vous verrez une description du projet et une liste de toutes les langues disponibles. Chaque langue contient également des informations sur le nombre total de mots traduisibles et une vue d'ensemble de la quantité de contenu qui a été traduite et approuvée dans une langue spécifique.
+Après vous être connecté à Crowdin, vous verrez une description du projet et une liste de toutes les langues disponibles.
+Chaque langue contient également des informations sur le nombre total de mots traduisibles et une vue d'ensemble de la quantité de contenu qui a été traduite et approuvée dans une langue spécifique.
 
 Ouvrez la langue dans laquelle vous souhaitez traduire pour voir la liste des fichiers disponibles pour la traduction.
 
-![Liste des langues sur Crowdin](./list-of-languages.png)
+![Liste des langues dans Crowdin](./list-of-languages.png)
 
 ### Trouvez un document sur lequel travailler {#find-document}
 
 Le contenu du site web est divisé en un certain nombre de documents et d'ensembles de contenus. Vous pouvez vérifier la progression de chaque document sur la droite. Si la progression de la traduction est inférieure à 100 %, n'hésitez pas à y contribuer !
 
-Votre langage n'est pas répertorié ici ? [Créez un ticket](https://github.com/ethereum/ethereum-org-website/issues/new/choose) ou demandez de l'aide sur notre [Discord](https://discord.gg/ethereum-org)
+Votre langage n'est pas répertorié ici ? [Ouvrez un ticket](https://github.com/ethereum/ethereum-org-website/issues/new/choose) ou demandez sur notre [Discord](https://discord.gg/ethereum-org)
 
-![Fichiers traduits et non traduits sur Crowdin](./crowdin-files.png)
+![Fichiers traduits et non traduits dans Crowdin](./crowdin-files.png)
 
-Une remarque sur les ensembles de contenu : nous utilisons des « ensembles de contenu » dans Crowdin pour que le contenu le plus prioritaire soit publié en premier. Lorsque vous parcourez une langue, comme le [philippin](https://crowdin.com/project/ethereum-org/fil#) par exemple, vous verrez des dossiers pour chaque ensemble de contenu (« 1. Homepage », « 2. Essentials », « 3. Exploring », etc.).
+Une remarque sur les ensembles de contenu : nous utilisons des « ensembles de contenu » dans Crowdin pour que le contenu le plus prioritaire soit publié en premier. Lorsque vous consultez une langue, par exemple, le [philippin](https://crowdin.com/project/ethereum-org/fil#) vous verrez des dossiers pour l'ensemble de contenu ("1. Homepage », « 2. Essentials », « 3. Exploring », etc.).
 
 Nous vous encourageons à traduire dans cet ordre numérique (1 → 2 → 3 → ⋯) afin de garantir que les pages ayant le plus fort impact soient traduites en premier.
 
-[En savoir plus sur les compartiments de contenu ethereum.org](/contributing/translation-program/)
-
 ### Traduire {#translate}
 
 Après avoir sélectionné le dossier que vous souhaitez traduire, il s'ouvrira dans l'éditeur en ligne. Si vous n'avez jamais utilisé Crowdin auparavant, vous pouvez utiliser ce guide rapide pour passer en revue les bases.
@@ -60,7 +59,8 @@ Vous pouvez également utiliser les boutons situés en haut pour rechercher des
 
 **_2 – Zone éditeur_**
 
-Il s'agit de la zone de traduction principale. Le texte source est affiché en haut, avec du contexte et des captures d'écran supplémentaires, si disponibles. Pour proposer une nouvelle traduction, tapez votre traduction dans le champ « Enter translation here » (Entrez la traduction ici), puis cliquez sur « Save » (Enregistrer).
+Il s'agit de la zone de traduction principale. Le texte source est affiché en haut, avec du contexte et des captures d'écran supplémentaires, si disponibles.
+Pour proposer une nouvelle traduction, tapez votre traduction dans le champ « Enter translation here » (Entrez la traduction ici), puis cliquez sur « Save » (Enregistrer).
 
 Dans cette section, vous pouvez également trouver des traductions existantes de la phrase dans d'autres langues, ainsi que des correspondances issues de la mémoire de traduction et des suggestions de traduction automatique.
 
@@ -70,7 +70,7 @@ C'est ici que vous pouvez trouver des commentaires, des entrées de mémoire de
 
 En utilisant les boutons situés en haut, vous pouvez également accéder à la mémoire de traduction, où vous pouvez rechercher des traductions existantes, ou au glossaire, qui contient des descriptions et traductions de termes clés.
 
-Vous voulez en savoir plus ? N'hésitez pas à consulter la [documentation sur l'utilisation de l'éditeur en ligne Crowdin](https://support.crowdin.com/online-editor/)
+Vous voulez en savoir plus ? N'hésitez pas à consulter la [documentation sur l'utilisation de l'éditeur en ligne de Crowdin](https://support.crowdin.com/online-editor/)
 
 ### Processus de révision {#review-process}
 
@@ -83,9 +83,9 @@ Une fois que vous avez terminé la traduction (c'est-à-dire que tous les fichie
 </AlertContent>
 </Alert>
 
-### Nous contacter {#get-in-touch}
+### Contactez-nous {#get-in-touch}
 
-Avez-vous d'autres questions ? Ou souhaitez-vous collaborer avec notre équipe et d'autres traducteurs ? Envoyez un message dans le canal #translations sur notre [serveur Discord ethereum.org](https://discord.gg/ethereum-org)
+Avez-vous d'autres questions ? Ou souhaitez-vous collaborer avec notre équipe et d'autres traducteurs ? Veuillez publier un message dans le canal #translations de notre [serveur Discord ethereum.org](https://discord.gg/ethereum-org)
 
 Vous pouvez également nous contacter à l'adresse translations@ethereum.org
 
diff --git a/public/content/translations/fr/contributing/translation-program/index.md b/public/content/translations/fr/contributing/translation-program/index.md
index 58de56f2c66..a3ce5991486 100644
--- a/public/content/translations/fr/contributing/translation-program/index.md
+++ b/public/content/translations/fr/contributing/translation-program/index.md
@@ -16,14 +16,14 @@ Le programme de traduction d'ethereum.org est ouvert et n'importe qui peut y con
 
 1. Vous devrez vous connecter à votre compte Crowdin ou vous inscrire.
 2. Sélectionnez la langue à laquelle vous souhaitez contribuer.
-3. Avant de commencer, veuillez consulter le guide [Comment traduire](/contributing/translation-program/how-to-translate/) pour apprendre comment utiliser Crowdin, et le [Guide de style de traduction](/contributing/translation-program/translators-guide/) pour obtenir des conseils et connaître les bonnes pratiques.
+3. Avant de commencer, veuillez consulter le guide [Comment traduire](/contributing/translation-program/how-to-translate/) pour apprendre à utiliser Crowdin, ainsi que le [Guide de style de traduction](/contributing/translation-program/translators-guide/) pour obtenir des conseils et des bonnes pratiques.
 4. Les traductions automatiques ne seront pas approuvées.
 5. Toutes les traductions sont vérifiées avant d'être ajoutées au site, par conséquent il y aura un court délai avant que vos traductions ne soient en ligne.
 
-_Rejoignez [ethereum.org Discord](https://discord.gg/ethereum-org) pour collaborer aux traductions, poser des questions, partager des commentaires et des idées, ou rejoindre un groupe de traduction._
+_Rejoignez le [Discord d'ethereum.org](https://discord.gg/ethereum-org) pour collaborer aux traductions, poser des questions, partager vos commentaires et idées, ou rejoindre un groupe de traduction._
 
 <ButtonLink href="https://crowdin.com/project/ethereum-org/">
-  Commencez à traduire
+  Commencer à traduire
 </ButtonLink>
 
 ## À propos du programme de traduction {#about-us}
@@ -32,19 +32,20 @@ La communauté Ethereum se veut mondiale et inclusive, mais une grande partie de
 
 Le Programme de traduction d'ethereum.org vise à rendre Ethereum accessible à tous en traduisant le site ethereum.org et les autres contenus Ethereum en autant de langues que possible.
 
-En savoir plus sur [la mission et la vision](/contributing/translation-program/mission-and-vision) du Programme de traduction d'ethereum.org.
+En savoir plus sur la [mission et la vision](/contributing/translation-program/mission-and-vision) du programme de traduction d'ethereum.org.
 
-### Les progrès réalisés jusqu'à présent {#our-progress}
+### Nos progrès jusqu'à présent {#our-progress}
 
-- [**plus de 6900** traducteurs](/contributing/translation-program/contributors/)
-- **68** langues présentes sur le site
+- [**Plus de 6 900** traducteurs](/contributing/translation-program/contributors/)
+- **68** langues disponibles sur le site
 - [**2,89 millions** de mots traduits en 2024](/contributing/translation-program/acknowledgements/)
 
 <TranslationChartImage />
 
 ### Remerciements {#acknowledgements}
 
-Ethereum.org est traduit par des milliers de membres de la communauté qui sont les membres clés du Programme de traduction. Nous voulons saluer le travail de nos traducteurs et les soutenir dans leur carrière. Voici quelques-uns de nos remerciements destinés aux traducteurs :
+Ethereum.org est traduit par des milliers de membres de la communauté qui sont les membres clés du Programme de traduction.
+Nous voulons saluer le travail de nos traducteurs et les soutenir dans leur carrière. Voici quelques-uns de nos remerciements destinés aux traducteurs :
 
 #### Certificat {#certificate}
 
@@ -54,13 +55,13 @@ Si vous avez contribué au Programme de traduction et qu'au moins 5 000 des mots
 
 Les contributeurs au Programme de traduction sont éligibles à différents OAT (onchain achievement tokens) en fonction du nombre de mots traduits en 2024. Les OAT sont des NFT qui prouvent votre contribution au Programme de traduction d'ethereum.org. [En savoir plus sur les OAT](/contributing/translation-program/acknowledgements/#oats)
 
-#### Traducteurs mis à l'honneur {#translator-acknowledgements}
+#### Remerciements aux traducteurs {#translator-acknowledgements}
 
-Reconnaissances publiques de nos meilleurs traducteurs en utilisant [des tableaux de classement](/contributing/translation-program/acknowledgements/) et une [liste de tous les contributeurs au Programme de traduction](/contributing/translation-program/contributors/).
+Remerciements publics à nos meilleurs traducteurs au moyen de [classements](/contributing/translation-program/acknowledgements/) et d'une [liste de tous les contributeurs au programme de traduction](/contributing/translation-program/contributors/).
 
 #### Récompenses {#rewards}
 
-Par le passé, nous avons récompensé rétroactivement nos contributeurs les plus actifs en leur offrant des billets pour les conférences Ethereum comme [Devcon](https://devcon.org/en/) et [Devconnect](https://devconnect.org/), ainsi que des produits dérivés exclusifs d'ethereum.org.
+Par le passé, nous avons récompensé rétroactivement nos contributeurs les plus actifs en leur offrant des billets pour des conférences Ethereum comme [Devcon](https://devcon.org/en/) et [Devconnect](https://devconnect.org/), ainsi que des produits dérivés exclusifs d'ethereum.org.
 
 Nous réfléchissons constamment à de nouvelles façons innovantes de récompenser nos contributeurs, alors restez à l'écoute !
 
@@ -68,23 +69,23 @@ Nous réfléchissons constamment à de nouvelles façons innovantes de récompen
 
 Si vous contribuez au Programme de traduction ou songez à vous impliquer, vous devriez consulter les guides de traduction ci-dessous :
 
-- [Guide de style pour la traduction](/contributing/translation-program/translators-guide/) _– instructions et conseils pour les traducteurs d'ethereum.org _
-- [FAQ sur la traduction](/contributing/translation-program/faq/) _– foire aux questions sur le programme de traduction d'ethereum.org_
-- [Guide sur l'éditeur en ligne Crowdin](https://support.crowdin.com/online-editor/) _– un guide détaillé sur l'utilisation de l'éditeur en ligne Crowdin et certaines des fonctionnalités avancées de Crowdin_
-- [Ensembles de contenu](/contributing/translation-program/) _– quelles pages sont incluses dans chaque ensemble de contenu d'ethereum.org_
+- [Guide de style de traduction](/contributing/translation-program/translators-guide/) _– instructions et conseils pour les traducteurs d'ethereum.org_
+- [FAQ sur la traduction](/contributing/translation-program/faq/) _– foire aux questions et réponses sur le programme de traduction d'ethereum.org_
+- [Guide de l'éditeur en ligne de Crowdin](https://support.crowdin.com/online-editor/) _– un guide détaillé sur l'utilisation de l'éditeur en ligne de Crowdin et certaines de ses fonctionnalités avancées_
 
-Pour obtenir d'autres outils de traduction utiles, connaître les communautés de traducteurs et lire des articles de blog du Programme de traduction, veuillez visiter la [page Ressources](/contributing/translation-program/resources/).
+Pour d'autres outils de traduction utiles, les communautés de traducteurs et les articles de blog du programme de traduction, veuillez consulter la [page Ressources](/contributing/translation-program/resources/).
 
-## Nous contacter {#get-in-touch}
+## Contactez-nous {#get-in-touch}
 
-Vous avez d'autres questions ? Ou souhaitez-vous collaborer avec notre équipe et d'autres traducteurs ? Envoyez un message dans le canal #translations sur notre [serveur Discord ethereum.org](https://discord.gg/ethereum-org)
+Avez-vous d'autres questions ? Ou souhaitez-vous collaborer avec notre équipe et d'autres traducteurs ? Veuillez publier un message dans le canal #translations de notre [serveur Discord ethereum.org](https://discord.gg/ethereum-org)
 
 Vous pouvez également nous contacter à l'adresse translations@ethereum.org
 
 ## Lancer votre propre programme de traduction {#starting-a-translation-program}
 
-Nous tenons à traduire le contenu Ethereum en autant de langues que possible et à mettre le contenu éducatif à la disposition de tous. En vertu de l'importance que nous accordons aux traductions, nous souhaitons apporter notre aide à d'autres projets Ethereum dans l'organisation, la gestion et l'amélioration de leurs propres efforts de traduction.
+Nous tenons à traduire le contenu Ethereum en autant de langues que possible et à mettre le contenu éducatif à la disposition de tous.
+En vertu de l'importance que nous accordons aux traductions, nous souhaitons apporter notre aide à d'autres projets Ethereum dans l'organisation, la gestion et l'amélioration de leurs propres efforts de traduction.
 
-C'est pourquoi nous avons créé un [manuel pour le Programme de traduction](/contributing/translation-program/playbook/) qui contient quelques conseils et bonnes pratiques que nous avons identifiées et regroupés au cours du processus de traduction du site ethereum.org.
+C'est pourquoi nous avons créé un [manuel du programme de traduction](/contributing/translation-program/playbook/) qui contient des conseils et des bonnes pratiques que nous avons recueillis lors de la traduction d'ethereum.org.
 
 Vous souhaitez collaborer davantage ou utiliser certaines de nos ressources de traduction ? Vous avez des commentaires sur le manuel ? N'hésitez pas à nous contacter à l'adresse translations@ethereum.org.
diff --git a/public/content/translations/fr/contributing/translation-program/playbook/index.md b/public/content/translations/fr/contributing/translation-program/playbook/index.md
new file mode 100644
index 00000000000..802fe2cbee2
--- /dev/null
+++ b/public/content/translations/fr/contributing/translation-program/playbook/index.md
@@ -0,0 +1,317 @@
+---
+title: Translation program playbook
+lang: fr
+description: "Une collection de conseils et de considérations importantes pour la mise en place d'un programme de traduction"
+---
+
+# Manuel du programme de traduction {#translation-program-playbook}
+
+English is one of the most spoken languages in the world and is by far the world’s most studied language. Comme l'anglais est la langue la plus couramment utilisée sur Internet - en particulier sur les médias sociaux - et que les langages de programmation multilingues sont rares, la majorité du contenu de l'espace blockchain est écrit nativement en anglais.
+
+However, as over 6 billion people in the world (more than 75% of the population) do not speak English at all, this presents a massive barrier for entry to Ethereum for the vast majority of the world’s population.
+
+For this reason, an increasing number of projects in the space are looking to get their content translated into different languages and localized for global communities.
+
+Fournir du contenu multilingue est un moyen simple et efficace de développer votre communauté mondiale, de fournir une éducation aux non-anglophones, de s'assurer que votre contenu et vos communications atteignent un public plus large et d'intégrer davantage de personnes dans l'espace.
+
+Ce guide vise à répondre aux défis et aux idées fausses courants concernant la localisation du contenu. It provides a step-by-step guide to managing content, the translation and review process, quality assurance, translator outreach, and other vital aspects of the localization process.
+
+## Content Management {#content-management}
+
+Translation content management refers to the process of automating the translation workflow, which removes the need for repetitive manual work, improves efficiency and quality, allows for better control, and enables collaboration.
+
+There are many different approaches to content management in the localization process, depending on the content and your needs.
+
+The fundamental way of managing content is to create bilingual files, containing the source and target text. Ceci est rarement utilisé en traduction, car il n'offre aucun avantage significatif, à part la simplicité.
+
+Les agences de traduction abordent généralement la gestion de la traduction en utilisant un logiciel de gestion de la traduction ou des outils de localisation, qui fournissent des capacités de gestion de projet et permettent un contrôle beaucoup plus grand sur les fichiers, le contenu et les linguistes.
+
+Read more about content management:
+
+[Trados on what is translation management](https://www.trados.com/solutions/translation-management/)
+
+[Phrase sur la gestion de contenu multilingue](https://phrase.com/blog/posts/multilingual-content-management/)
+
+### Translation Management Software {#translation-management-software}
+
+Il existe de nombreux systèmes de gestion de la traduction et outils de localisation, et le choix du logiciel dépend principalement de vos besoins.
+
+Alors que certains projets décident de ne pas utiliser de systèmes de gestion de traduction et préfèrent gérer les traductions manuellement - soit directement dans des fichiers bilingues, soit sur des services d'hébergement, tels que GitHub - cela réduit considérablement le contrôle, la productivité, la qualité, l'évolutivité et les capacités de collaboration. Such an approach might be most beneficial for small-scale or one-off translation projects.
+
+Un aperçu rapide de certains des outils de gestion de la traduction les plus puissants et les plus largement utilisés :
+
+**Best for crowdsourcing and collaboration**
+
+[Crowdin](https://crowdin.com/)
+
+- Gratuit pour les projets open source (nombre illimité de chaînes et de projets)
+- TM and glossary available with all plans
+- 60+ supported file formats, 70+ API integrations
+
+[Lokalise](https://lokalise.com/)
+
+- Free for 2 team members, paid plans for more contributors (limited number of strings for most plans)
+- TM et glossaire disponibles avec certains plans payants
+- 30+ supported file formats, 40+ API integrations
+
+[Transifex](https://www.transifex.com/)
+
+- Uniquement les plans payants (nombre limité de chaînes pour la plupart des plans)
+- TM et glossaire disponibles avec tous les plans payants
+- Plus de 30 formats de fichiers pris en charge, plus de 20 intégrations d'API
+
+[Phrase](https://phrase.com/)
+
+- Only paid plans (unlimited number of strings for all plans, limited number of projects and team members)
+- TM et glossaire disponibles avec certains plans payants
+- 40+ supported file formats, 20+ API integrations
+
+[Smartcat](https://www.smartcat.com/)
+
+- Basic free plan with payable advanced features (unlimited number of strings and projects for all plans)
+- TM and glossary available with all plans
+- 60+ supported file formats, 20+ API integrations
+
+[POEditor](https://poeditor.com/)
+
+- Free for open-source projects (limited number of strings for all projects, unlimited for open-source projects)
+- TM and glossary available for paid plans
+- 20+ supported file formats, 10+ API integrations
+
+Et beaucoup d'autres...
+
+**Outils de traduction professionnels**
+
+[SDL Trados Studio](https://www.trados.com/products/trados-studio/)
+
+- Plans rémunérés pour les traducteurs et les équipes indépendants
+- Outil de traduction assistée par ordinateur (CAT) très puissant et logiciel de productivité traducteur
+
+[MemoQ](https://www.memoq.com/)
+
+- Version gratuite limitée disponible avec plusieurs plans payants pour des fonctionnalités avancées
+- Translation management software for companies, language service providers and translators
+
+[Memsource](https://www.memsource.com/)
+
+- Free for individual translators with several paid plans for teams
+- Système de traduction et de gestion de la traduction assisté par ordinateur basé sur le cloud
+
+Et beaucoup d'autres...
+
+Read more about translation management software:
+
+[Wikipedia definition of translation management systems](https://en.wikipedia.org/wiki/Translation_management_system)
+
+[Phrase sur 7 choses que tout logiciel de gestion de traduction devrait avoir](https://phrase.com/blog/posts/7-things-every-translation-management-software-should-have/)
+
+[MemoQ sur ce qu'est un système de gestion de la traduction](https://www.memoq.com/tools/what-is-a-translation-management-system)
+
+[Gengo’s list of 16 best translation management systems](https://gengo.com/translator-product-updates/16-best-translation-management-systems/)
+
+## Workflow {#workflow}
+
+In the translation space, translation workflow can mean a couple of different things, both somewhat interrelated, and important considerations for your project.
+
+We will explore both of them below.
+
+**Meaning 1**
+
+This is probably the most common way of thinking about translation workflows and something that usually comes to mind when hearing the word workflow.
+
+In its essence, it is the ‘flow of work’ from starting to think about translations to using the translated content in your product.
+
+An example workflow in this case would be:
+
+1. **Preparing the files for translation** – It sounds simple; however, you need to consider a couple of important things. At this step, you should have a clear plan on how the entire process should work.
+
+- _Which file types will you be using? Dans quel format souhaitez-vous recevoir vos fichiers traduits ? _
+  - Si votre contenu est disponible au format DOCX ou MD, l'approche sera beaucoup plus simple que si vous traduisez une version PDF de votre livre blanc ou d'autres documents.
+- _Which localization tools support this file type? Le fichier peut-il être traduit d'une manière qui conserve le formatage d'origine ? _
+  - Not all file types support direct localization (e.g., PDF files, image files), and not all localization tools support all file types.
+- _Who will be translating the content? Allez-vous commander des traductions professionnelles ou compter sur des bénévoles ? _
+  - This affects a number of other decisions you need to make. For example, professional translators are more comfortable working with advanced localization tools than volunteers.
+- _What are your expectations for the linguists? If you are using a language service provider, what do they expect from you?_
+  - This is the step to make sure your goals, expectations, and timelines are aligned.
+- _Is all the content for translation equally important? Faut-il d'abord traduire du contenu ? _
+  - There are some ways to prioritize certain content, which should be translated and implemented first. Par exemple, si vous avez beaucoup de contenu à traduire, vous pouvez utiliser le contrôle de version pour vous assurer que les traducteurs sont conscients de ce qu'ils doivent prioriser.
+
+2. **Sharing the files for translation** – This step also requires some long-term thinking and is not as straightforward as sending the source files to a language service provider.
+
+- _Who will be translating the content? How many people will be involved in this process?_
+  - If you plan to use a localization tool, this step is simplified since you can upload the source files to the tool directly. This is also true if the translation process takes place on the hosting service since the source files don’t need to be exported anywhere.
+- _Will the source files be handled manually, or can this process be automated?_
+  - Most localization tools allow for some type of integration or automation of the file management process. On the other hand, if you are working with individual translators and not using a localization tool, manually sending source files to hundreds or thousands of translators is not a scalable process.
+- _Which tools will be used for the localization?_
+  - The answer to this question will determine how you approach everything else. Selecting the proper tool can help you automate content management, managing the Translation Memory and Glossary, managing translators, keeping track of the translation/review progress, etc., so take some time and do some research on which tool you want to use. If you are not planning on using a localization tool, all of the above will need to be done manually.
+- _How long will the translation process take? How much will it cost?_
+  - At this point, you should be ready to share the source files with the language service provider or pool of translators. The language service provider can help you analyze the word count and provide a quote, including the rates and timeline for the translation process.
+- _Are you planning on making changes/updating the source content during this process?_
+  - If your content is dynamic and changes often, any changes or updates can disrupt the translation progress. Using a Translation Memory can help mitigate this significantly, though it is still important to think about how the process will work and how you can prevent setting back the progress the translators are making.
+
+3. **Managing the translation process** – Your work isn’t done once the source content is handed off to the language service provider or the translators. To ensure optimal quality of the translations, content creators should be as involved with the translation process as possible.
+
+- _Comment comptez-vous communiquer avec les traducteurs ? _
+  - Si vous prévoyez d'utiliser un outil de localisation, la communication peut avoir lieu directement dans l'outil. Setting up an alternative communication channel with the translators is also recommended since they might be less hesitant to reach out, and messaging tools allow for more free-flowing communication.
+- _Comment gérer les questions des traducteurs ? Who should be answering these questions?_
+  - Translators (both professional and non-professional) will often reach out with questions and requests for clarification or additional context, as well as feedback and ideas for improvements. Replying to these inquiries can often lead to better engagement and quality of translated content. It is also valuable to provide them with as many resources as possible (e.g., guides, tips, terminology guidelines, FAQs, etc.).
+- _Comment gérer le processus d'examen ? Do you want to outsource it, or do you have the capacity to perform reviews internally?_
+  - While not always necessary, reviews are an integral part of an optimal translation process. Usually, it is easiest to outsource the review process to professional reviewers. Cependant, si vous avez une grande équipe internationale, les examens ou l'assurance qualité peuvent également être gérés en interne.
+
+4. **Implementing the translated content** – The last part of the workflow, though still important to consider ahead of time.
+
+- _Toutes les traductions seront-elles terminées en même temps ? _
+  - If not, you should think about which translations should be prioritized, how to keep track of the translations in progress, and how the implementation is handled while the translations are done.
+- _Comment le contenu traduit vous sera-t-il livré ? What format will it be in?_
+  - C'est une considération importante, quelle que soit l'approche que vous utilisez. Localization tools allow you to maintain control over the target file format and export process and usually support automation, e.g., by enabling integration with the hosting service.
+- _How will you be implementing the translations in your project?_
+  - In some cases, this could be as simple as uploading the translated file or adding it to your docs. However, with more complex projects, like website or app translations, you should make sure the code supports internationalization and establish how the implementation process will be handled ahead of time.
+- _What happens if the formatting is different to the source?_
+  - Similar to the above, if you are translating simple text files, the formatting probably isn’t crucially important. However, with more complex files, like content for a website or application, the formatting and code need to be identical to the source in order to be implemented in your project. If not, the target files will need to be edited, either by the translators or your developers.
+
+**Meaning 2**
+
+An alternative translation workflow, which does not account for internal decisions and approaches. The main consideration here is the flow of the content itself.
+
+An example workflow in this case would be:
+
+1. _Translation → Implementation_
+
+- Le flux de travail le plus simple, où la traduction sera probablement une traduction humaine, car il n'y a pas de processus d'examen ou d'assurance qualité pour évaluer la qualité et éditer les traductions avant la mise en œuvre.
+- With this workflow, it is important that the translators can maintain a certain level of quality, which will require appropriate resources and communication between the project managers and translators.
+
+2. _Translation → Review → Implementation_
+
+- A more advanced workflow, which includes a review and editing process, to ensure the quality of the translations is acceptable and consistent.
+- There are a number of approaches to this workflow, where the translations could be performed by professional translators or volunteers, while the review process will likely be handled by professional reviewers, who are familiar with all the grammar and orthography rules that need to be observed in the target language.
+
+3. _Translation → Review → QA → Implementation_
+
+- The optimal workflow to ensure the highest level of quality. While QA is not always necessary, it could be useful to give you a better sense of the quality of the translated text after translation and review.
+- With this workflow, translations could be performed exclusively by volunteers or even machine translation. The review process should be performed by professional translators, while the QA can be performed by a language service provider or internally, if you have employees who are native speakers of the target languages.
+
+En savoir plus sur les flux de travail de traduction :
+
+[Content rules on the five phases of the translation workflow](https://contentrules.com/creating-translation-workflow/)
+
+[Smartling on what is translation workflow management](https://www.smartling.com/resources/101/what-is-translation-workflow-management/)
+
+[RixTrans on the translation workflow](https://www.rixtrans.com/translation-workflow)
+
+## Terminology Management {#terminology-management}
+
+Establishing a clear plan on how to handle terminology is one of the most important steps to ensure the quality and consistency of your translations and save your translators time.
+
+In the translation space, this is known as terminology management and is one of the key services language service providers offer their clients, in addition to access to their pool of linguists and content management.
+
+Terminology management refers to the process of identifying, gathering, and managing terminology that is important for your project and should always be translated correctly and consistently.
+
+There are a couple of steps to follow when starting to think about terminology management:
+
+- Identify key terms that should be included in the termbase.
+- Create a glossary of terms and their definitions.
+- Translate the terms and add them to the glossary.
+- Check and approve the translations.
+- Maintenez le glossaire et mettez-le à jour avec de nouveaux termes, à mesure qu'ils deviennent importants.
+
+Read more about terminology management:
+
+[Trados on what is terminology management](https://www.trados.com/solutions/terminology-management/translation-101-what-is-terminology-management.html)
+
+[Language Scientific on why terminology management matters](https://www.languagescientific.com/terminology-management-why-it-matters/#:~:text=Terminology%20management%20is%20the%20process,are%20related%20to%20each%20other.)
+
+[Clear Words Translation on what is terminology management and why it matters](http://clearwordstranslations.com/language/en/what-is-terminology-management/)
+
+### Translation Memory and Glossary {#tm-and-glossary}
+
+The Translation Memory and Glossary are important tools in the translation industry and something most language service providers rely on.
+
+Let’s look at what these terms mean and how they are different to each other:
+
+**Mémoire de traduction (TM)** - Une base de données qui stocke automatiquement des segments ou des chaînes, y compris des blocs de texte plus longs, des phrases complètes, des paragraphes et des termes individuels, ainsi que leurs traductions actuelles et précédentes dans toutes les langues.
+
+La plupart des outils de localisation, des systèmes de gestion de la traduction et des outils de traduction assistés par ordinateur ont des mémoires de traduction intégrées, qui peuvent généralement être exportées et utilisées dans d'autres outils similaires.
+
+The benefits of using a translation memory include faster translations, better translation quality, the ability to retain certain translations when updating or changing source content, and cheaper translation costs for repetitive content.
+
+Translation memories work based on a percentage match between different segments and are usually most useful when two segments contain over 50% of the same content. They are also used to automatically translate repetitive segments, which are 100% matches, thus removing the need to ever translate repetitive content more than once.
+
+Read more about translation memories:
+
+[Memsource on translation memories](https://www.memsource.com/translation-memory/)
+
+[Smartling sur ce qu'est une mémoire de traduction](https://www.smartling.com/resources/101/what-is-translation-memory/)
+
+**Glossary –** A list of important or sensitive terms, their definitions, functions, and established translations. The main difference between a glossary and a translation memory is that a glossary is not created automatically, and that it does not contain translations of full sentences.
+
+Most localization tools, translation management systems, and computer-assisted translation tools have built-in glossaries that you can maintain to ensure they contain terminology important for your project. Like the TM, the glossary can usually be exported and used in other localization tools.
+
+Before starting your translation project, it is highly recommended to take some time and create a glossary for your translators and reviewers. Using a glossary ensures that important terms are translated correctly, provides translators with much-needed context, and guarantees consistency in translations.
+
+While glossaries most often contain established translations in the target languages, they are also useful without this. Even without established translations, a glossary can have definitions of technical terms, highlight terms that should not get translated, and inform translators whether a specific term is used as a noun, verb, proper noun, or any other part of speech.
+
+Read more about glossaries:
+
+[Lionbridge on what is a translation glossary](http://info.lionbridge.com/rs/lionbridge/images/Lionbridge%20FAQ_Glossary_2013.pdf)
+
+[Transifex sur les glossaires](https://docs.transifex.com/glossary/glossary)
+
+Si vous ne prévoyez pas d'utiliser un outil de localisation pour votre projet, vous ne pourrez probablement pas utiliser une mémoire de traduction et un glossaire (vous pouvez créer un glossaire ou une base de termes dans un fichier Excel, cependant, les glossaires automatisés éliminent le besoin pour les traducteurs de rechercher manuellement les termes et leurs définitions).
+
+This means that all repetitive and similar content would have to be manually translated every time. De plus, les traducteurs devraient vous poser des questions pour savoir si un certain terme doit être traduit ou non, comment il est utilisé dans le texte et si un terme a déjà une traduction établie.
+
+_Voulez-vous utiliser la mémoire de traduction et le glossaire d'ethereum.org dans votre projet ? Contactez-nous à l'adresse translations@ethereum.org. _
+
+## Translator Outreach {#translator-outreach}
+
+**Working with a language service provider**
+
+If you are working with a language service provider and their professional translators, this section might not be too relevant for you.
+
+Dans ce cas, il est important de sélectionner un fournisseur de services linguistiques ayant la capacité de fournir tous les services dont vous avez besoin (par exemple, traduction, révision, assurance qualité) dans de nombreuses langues.
+
+Bien qu'il puisse être tentant de choisir un fournisseur de services linguistiques uniquement en fonction de ses tarifs proposés, il est important de noter que les plus grands fournisseurs de services linguistiques ont des tarifs plus élevés pour une raison.
+
+- They have tens of thousands of linguists in their database, which means that they will be able to assign translators with sufficient experience and knowledge of your particular sector to your project (i.e., technical translators).
+- They have significant experience working on different projects and meeting their clients’ diverse needs. This means they will be more likely to adapt to your particular workflow, offer valuable suggestions and potential improvements for your translation process, and meet your needs, requirements, and deadlines.
+- Most of the largest language service providers also have their own localization tools, translation memories, and glossaries that you can use. Si ce n'est pas le cas, ils ont au moins suffisamment de linguistes dans leur bassin pour s'assurer que leurs traducteurs seront familiers et capables de travailler avec n'importe quel outil de localisation que vous souhaitez utiliser.
+
+You can find an in-depth comparison of the largest language service providers in the world, some details about each of them and breakdowns by the services they provide, geographical data, etc. in the [2021 Nimdzi 100 report](https://www.nimdzi.com/nimdzi-100-top-lsp/).
+
+**Working with non-professional translators**
+
+Vous travaillez peut-être avec des traducteurs non professionnels et recherchez des bénévoles pour vous aider à traduire.
+
+There are several ways to reach people and invite them to join your project. This will largely depend on your product and how big of a community you already have.
+
+Some ways of onboarding volunteers are outlined below:
+
+**Outreach –** While this is somewhat covered in the points below, reaching out to potential volunteers and making sure they are aware of your translation initiative can be effective in itself.
+
+A lot of people want to get involved and contribute to their favorite projects, but often don’t see a clear way of doing that without being a developer or having special technical skills. Si vous pouvez faire connaître votre projet, de nombreux bilingues seront probablement désireux de s'impliquer.
+
+**Looking within your community –** Most projects in the space already have large and active communities. A lot of your community members would probably appreciate the chance to contribute to the project in a simple way.
+
+Bien que la contribution à des projets open source soit souvent basée sur une motivation intrinsèque, c'est aussi une expérience d'apprentissage fantastique. Anyone interested in learning more about your project would likely be happy to get involved with a translation program as a volunteer, since it would allow them to combine the fact that they have contributed to something they care about with an intensive hands-on learning experience.
+
+**Mention de l'initiative dans votre produit -** Si votre produit est populaire et utilisé par un grand nombre de personnes, mettre en évidence votre programme de traduction et appeler les utilisateurs à l'action lors de l'utilisation du produit peut être extrêmement efficace.
+
+This could be as simple as adding a banner or pop-up with a CTA to your product for applications and websites. C'est efficace parce que votre public cible est votre communauté - les personnes qui sont les plus susceptibles de s'impliquer en premier lieu.
+
+**Social media –** Social media can be an effective way of spreading awareness about your translation program and reaching out to your community members, as well as other people who aren’t members of your community yet.
+
+If you have a Discord server or Telegram channel, it is easy to use that for outreach, communication with your translators, and acknowledging your contributors.
+
+Des plateformes comme X (anciennement Twitter) peuvent également être utiles pour intégrer de nouveaux membres de la communauté et reconnaître publiquement vos contributeurs.
+
+La Fondation Linux a créé un rapport détaillé, le [Report on the 2020 FOSS contributor survey](https://www.linuxfoundation.org/wp-content/uploads/2020FOSSContributorSurveyReport_121020.pdf), analysant les contributeurs open source et leurs motivations.
+
+## Conclusion {#conclusion}
+
+This document contains some key considerations every translation program should be aware of. Ce n'est en aucun cas un guide exhaustif, bien qu'il puisse aider toute personne sans expérience dans l'industrie de la traduction à organiser un programme de traduction pour son projet.
+
+If you are looking for more detailed instructions and breakdowns of different tools, processes, and critical aspects of managing a translation program, some of the largest language service providers maintain blogs and often publish articles on different aspects of the localization process. These are the best resources if you want to dive deeper into any of the topics above and understand how the localization process works professionally.
+
+Some relevant links are included at the end of each section; however, you can find many other resources online.
+
+Pour des propositions de coopération ou d'informations supplémentaires, d'apprentissages et de meilleures pratiques que nous avons recueillis en maintenant le programme de traduction ethereum.org, n'hésitez pas à nous contacter à translations@ethereum.org.
diff --git a/public/content/translations/fr/contributing/translation-program/resources/index.md b/public/content/translations/fr/contributing/translation-program/resources/index.md
index 18851821e80..2bf2f804ef0 100644
--- a/public/content/translations/fr/contributing/translation-program/resources/index.md
+++ b/public/content/translations/fr/contributing/translation-program/resources/index.md
@@ -10,35 +10,40 @@ Vous pouvez trouver ci-dessous des guides et des outils utiles pour les traducte
 
 ## Guides {#guides}
 
-- [Guide de style pour la traduction](/contributing/translation-program/translators-guide/)_– instructions et conseils pour les traducteurs d'ethereum.org_
-- [FAQ sur la traduction](/contributing/translation-program/faq/) _– foire aux questions sur le programme de traduction d'ethereum.org_
-- [Guide sur l'éditeur en ligne Crowdin](https://support.crowdin.com/online-editor/) _– un guide détaillé sur l'utilisation de l'éditeur en ligne Crowdin et certaines des fonctionnalités avancées de Crowdin_
-- [Ensembles de contenu](/contributing/translation-program/) _– quelles pages sont incluses dans chaque ensemble de contenu d'ethereum.org_
+- [Guide de style de traduction](/contributing/translation-program/translators-guide/) _– instructions et conseils pour les traducteurs d'ethereum.org_
+- [FAQ sur la traduction](/contributing/translation-program/faq/) _– foire aux questions et réponses sur le programme de traduction d'ethereum.org_
+- [Guide de l'éditeur en ligne de Crowdin](https://support.crowdin.com/online-editor/) _– un guide détaillé sur l'utilisation de l'éditeur en ligne de Crowdin et certaines de ses fonctionnalités avancées_
 
 ## Outils {#tools}
 
-- [Linguee](https://www.linguee.com/) _– moteur de recherche de traductions et dictionnaire qui permet la recherche par mot ou phrase_
-- [Recherche de terme Proz](https://www.proz.com/search/) _– base de données de dictionnaires de traduction et de glossaires pour des termes spécialisés_
-- [Eurotermbank](https://www.eurotermbank.com/) _– collections de terminologie européenne en 42 langues_
+- [Linguee](https://www.linguee.com/)
+  _– moteur de recherche de traductions et dictionnaire qui permet la recherche par mot ou par phrase_
+- [Recherche de terme Proz](https://www.proz.com/search/)
+  _– base de données de dictionnaires de traduction et de glossaires pour les termes spécialisés_
+- [Eurotermbank](https://www.eurotermbank.com/)
+  _– collections de terminologie européenne en 42 langues_
 
 ## Communautés {#communities}
 
-- [Groupes de traduction spécifiques à une langue sur Discord](https://discord.gg/ethereum-org) _– une initiative pour connecter les traducteurs ethereum.org à travers des groupes de traduction_
-- [Groupe de traducteurs chinois](https://www.notion.so/Ethereum-org-05375fe0a94c4214acaf90f42ba40171) _– page de notion pour faciliter la coordination entre les traducteurs chinois_
+- [Groupes de traduction Discord spécifiques à une langue](https://discord.gg/ethereum-org)
+  _– une initiative pour connecter les traducteurs d'ethereum.org à des groupes de traduction_
+- [Groupe des traducteurs chinois](https://www.notion.so/Ethereum-org-05375fe0a94c4214acaf90f42ba40171)
+  _– Page Notion pour faciliter la coordination entre les traducteurs chinois_
 
 ## Dernières mises à jour {#latest-updates}
 
-Pour vous tenir au courant des dernières avancées du programme de traduction, vous pouvez suivre le blog de l'[Ethereum Foundation](https://blog.ethereum.org/) :
+Pour vous tenir au courant des derniers progrès du programme de traduction, vous pouvez suivre le [blog de la Fondation Ethereum](https://blog.ethereum.org/) :
 
-- [Mise à jour d'octobre 2021](https://blog.ethereum.org/2021/10/04/translation-program-update)
-- [Mise à jour de décembre 2020](https://blog.ethereum.org/2020/12/21/translation-program-milestones-updates-20)
-- [Mise à jour de juillet 2020](https://blog.ethereum.org/2020/07/29/ethdotorg-translation-milestone)
-- [Lancement du programme de traduction, août 2019](https://blog.ethereum.org/2019/08/20/translating-ethereum-for-our-global-community)
+- [Mise à jour des jalons d'octobre 2021](https://blog.ethereum.org/2021/10/04/translation-program-update/)
+- [Mise à jour des jalons de décembre 2020](https://blog.ethereum.org/2020/12/21/translation-program-milestones-updates-20/)
+- [Mise à jour des jalons de juillet 2020](https://blog.ethereum.org/2020/07/29/ethdotorg-translation-milestone/)
+- [Lancement du programme de traduction d'août 2019](https://blog.ethereum.org/2019/08/20/translating-ethereum-for-our-global-community/)
 
-## Permanence pour les traducteurs {#office-hours}
+## Permanences pour les traducteurs {#office-hours}
 
-Nous assurons des permanences pour les traducteurs le deuxième mercredi du mois. Celles-ci sont tenues dans le canal vocal #office-hours sur l'[ethereum.org Discord](https://discord.gg/ethereum-org), où vous pouvez également trouver les heures exactes et les détails supplémentaires.
+Nous assurons des permanences pour les traducteurs le deuxième mercredi du mois. Elles ont lieu dans le canal vocal #office-hours sur le [Discord d'ethereum.org](https://discord.gg/ethereum-org), où vous pouvez également trouver les heures exactes et des détails supplémentaires.
 
-Les heures de permanence permettent à nos traducteurs de poser des questions sur le processus de traduction, de faire part de leurs commentaires sur le programme, de partager leurs idées ou simplement de discuter avec l'équipe d'ethereum.org. Enfin, nous voulons utiliser ces appels pour communiquer les développements récents en lien avec le programme de traduction et partager avec nos contributeurs des conseils et des instructions.
+Les heures de permanence permettent à nos traducteurs de poser des questions sur le processus de traduction, de faire part de leurs commentaires sur le programme, de partager leurs idées ou simplement de discuter avec l'équipe d'ethereum.org.
+Enfin, nous voulons utiliser ces appels pour communiquer les développements récents en lien avec le programme de traduction et partager avec nos contributeurs des conseils et des instructions.
 
 Si vous êtes un traducteur ethereum.org ou si vous souhaitez le devenir, n'hésitez pas à nous rejoindre pendant l'une de ces sessions.
diff --git a/public/content/translations/fr/contributing/translation-program/translatathon/details/index.md b/public/content/translations/fr/contributing/translation-program/translatathon/details/index.md
new file mode 100644
index 00000000000..cb90549ae08
--- /dev/null
+++ b/public/content/translations/fr/contributing/translation-program/translatathon/details/index.md
@@ -0,0 +1,90 @@
+---
+title: "Détails et règles"
+lang: fr
+template: translatathon
+---
+
+![](./participate.png)
+
+Le Translatathon est ouvert et tout le monde peut participer en remplissant le formulaire de candidature et en rejoignant le projet sur Crowdin.
+
+Les traducteurs collectent des points en suggérant des traductions pour les chaînes non traduites dans leur langue dans l'éditeur Crowdin pendant la période de traduction.
+
+Le score final de chaque participant est déterminé par sa position dans le classement, en fonction du nombre de mots qu'il a traduits pendant la période de traduction et des éventuels points bonus qu'il a collectés.
+
+## Mise en route {#getting-started}
+
+Le processus de traduction se déroule dans le projet ethereum.org sur Crowdin, et les traducteurs suggèrent leurs traductions pour les chaînes non traduites, qui constituent la quasi-totalité du contenu du site web ethereum.org.
+
+Les traductions sont suggérées directement dans l'éditeur en ligne, il n'est donc pas nécessaire de télécharger ou de charger des fichiers ou des livrables. Chaque mot traduit est suivi et compté.
+
+**1) Rejoindre le projet**
+
+- Pour commencer à contribuer, rejoignez le [projet ethereum.org sur Crowdin](https://crowdin.com/project/ethereum-org)
+- Vous devrez vous connecter ou créer un compte. Une adresse e-mail et un mot de passe sont tout ce qui est requis.
+
+**2) Sélectionnez votre langue**
+
+- Trouvez votre langue dans la liste des langues cibles et ouvrez-la en cliquant sur son nom ou son drapeau.
+- Si vous souhaitez traduire dans une langue qui n'est pas disponible, contactez [l'équipe d'Ethereum.org](https://crowdin.com/profile/ethdotorg) sur Crowdin ou envoyez-nous un e-mail à translations@ethereum.org et nous ajouterons d'autres langues cibles sur demande.
+
+**3) Ouvrir un fichier non traduit**
+
+- Trouvez le premier fichier non traduit pour commencer la traduction. Les dossiers contenant les fichiers sources sont organisés par priorité, vous devez donc commencer à traduire le premier dossier qui contient des fichiers non traduits.
+- Chaque fichier dispose d'un indicateur de progression qui indique la quantité de contenu traduisible du fichier qui a été traduite et approuvée… si la progression de la traduction d'un fichier est inférieure à 100 %, veuillez le traduire.
+
+**4) Traduire les chaînes non traduites**
+
+- Lorsque vous ouvrez un fichier à traduire, assurez-vous de ne traduire que les chaînes non traduites !
+- Chaque chaîne a un indicateur de statut qui indique si elle est _Traduite_, _Non traduite_ ou _Approuvée_. Si une chaîne source a déjà une traduction suggérée dans votre langue, il n'est pas nécessaire de la traduire.
+- Vous pouvez également filtrer les chaînes dans l'éditeur pour afficher les chaînes _Non traduites en premier_ ou _Non traduites uniquement_.
+
+Pour un guide détaillé sur la navigation et l'utilisation de l'éditeur Crowdin, nous recommandons à tous les participants du Translatathon de lire notre guide [Comment traduire](/contributing/translation-program/how-to-translate/).
+
+Vous pouvez également trouver des conseils et des bonnes pratiques en consultant notre [guide de style de traduction](/contributing/translation-program/translators-guide/).
+
+**Fonctionnement des points**
+
+Chaque participant au Translatathon gagnera des points pour son score final en traduisant du contenu dans le projet ethereum.org sur Crowdin et d'autres projets éligibles (la liste complète des projets éligibles est disponible ci-dessous).
+
+Le décompte des points est simple : **1 mot traduit = 1 point**.
+
+Afin de recevoir votre attribution finale de points, vos traductions suggérées devront passer le processus d'évaluation, au cours duquel des réviseurs professionnels vérifieront les traductions de chaque participant pour s'assurer qu'elles respectent le seuil de qualité minimum et qu'aucune traduction automatique ou par IA n'a été utilisée.
+
+## Contenu de l'écosystème {#ecosystem-content}
+
+Le programme de traduction d'ethereum.org étant actif en permanence, la progression de la traduction dans certaines langues cibles sur le site web est nettement plus élevée que dans d'autres.
+
+Afin de garantir que tous les participants au Translatathon aient une chance égale de traduire autant de contenu que possible et de concourir pour les premiers prix, le contenu source qui fait partie du Translatathon ne se limite pas seulement au contenu du site web ethereum.org.
+
+Les participants qui traduisent l'un des projets éligibles gagneront un nombre égal de points, 1 mot traduit dans n'importe quel projet = 1 point.
+
+Voici la liste de tous les projets éligibles qui font partie du Translatathon 2025 :
+
+- [Ethereum.org](https://crowdin.com/project/ethereum-org)
+
+- [Tutoriels pour développeurs d'Ethereum.org](https://crowdin.com/project/33388446abbe9d7aa21e42e49bba7f97)
+
+- [CLI de dépôt EthStaker](https://crowdin.com/project/ethstaker-deposit-cli)
+
+- [Documentation d'Eth Docker](https://crowdin.com/project/eth-docker-docs)
+
+- [Documentation de Remix IDE](https://crowdin.com/project/remix-translation)
+
+- [Remix LearnEth](https://crowdin.com/project/remix-learneth)
+
+- [web3.py](https://crowdin.com/project/web3py)
+
+## Processus d'évaluation {#evaluation-process}
+
+Toutes les traductions seront soumises à une assurance qualité et à des commentaires, où des linguistes professionnels évalueront les soumissions en fonction de leur qualité et de leur exactitude.
+
+Nous appliquerons également des **mesures anti-traduction automatique** à l'aide d'outils qui détectent automatiquement les traductions automatiques ou par IA.
+
+Bien que la qualité de la traduction ne joue pas un rôle essentiel dans le décompte des points, les **participants surpris à utiliser des traductions automatiques ou par IA** ou à suggérer des traductions de mauvaise qualité et inexactes ne seront pas éligibles aux prix !
+
+La période d'évaluation se déroulera tout au long du mois de septembre et les résultats seront annoncés lors de l'appel communautaire d'ethereum.org le 25 septembre.
+
+Toutes les traductions seront également entièrement révisées avant d'être ajoutées au site web.
+
+<ApplyNow />
diff --git a/public/content/translations/fr/contributing/translation-program/translatathon/index.md b/public/content/translations/fr/contributing/translation-program/translatathon/index.md
new file mode 100644
index 00000000000..c1333c9cca7
--- /dev/null
+++ b/public/content/translations/fr/contributing/translation-program/translatathon/index.md
@@ -0,0 +1,100 @@
+---
+title: Translatathon 2025 d'ethereum.org
+lang: fr
+template: translatathon
+---
+
+<CardContainer>
+  <EmojiCard
+    emoji=':globe_with_meridians:'
+    title="Traduisez ethereum.org"
+    description="Traduisez le contenu d'ethereum.org dans votre langue pour aider plus de monde à découvrir Ethereum."
+  />
+  <EmojiCard
+    emoji=':trophy:'
+    title="Gagnez des prix"
+    description="Gagnez une part de la cagnotte en fonction de votre position dans le classement."
+  />
+  <EmojiCard
+    emoji=':bulb:'
+    title="Découvrir Ethereum"
+    description="Apprenez-en plus sur Ethereum tout en traduisant et en concourant pour des prix."
+  />
+</CardContainer>
+
+## Introduction {#introduction}
+
+Nous pensons que le contenu d'Ethereum et les ressources d'intégration devraient être accessibles à tous, quelle que soit la langue parlée.
+Pour nous rapprocher de cet objectif, le programme de traduction d'ethereum.org est une initiative visant à traduire le site Web dans le plus de langues possible.
+
+Dans le cadre du programme de traduction, nous organisons la 3e édition du Translatathon, notre concours de traduction qui vise à encourager les contributions à la traduction dans les langues moins actives, à augmenter le nombre de langues et la quantité de contenu disponible sur le site, à intégrer de nouveaux contributeurs et à récompenser nos contributeurs existants.
+
+Si vous êtes un locuteur natif d'une autre langue que l'anglais et que vous souhaitez contribuer à rendre le contenu d'Ethereum plus accessible tout en concourant pour des prix, lisez la suite pour en savoir plus !
+
+[En savoir plus sur le programme de traduction d'ethereum.org](/contributing/translation-program/)
+
+## Calendrier {#timeline}
+
+Voici les dates importantes pour le Translatathon 2025 :
+
+<DatesAndTimeline />
+
+<TranslatathonInANutshell />
+
+## Participer {#participate}
+
+![Image d'une communauté et d'un globe](./participate.png)
+
+<TwoColumnContent>
+  <CardContent>
+    <h3 className="mt-6 mb-3">Qui peut participer ?</h3>
+    Toute personne âgée de plus de 18 ans, locuteur natif d'au moins une langue autre que l'anglais et maîtrisant l'anglais.
+  </CardContent>
+  <CardContent>
+    <h3 className="mt-6 mb-3">Faut-il être traducteur ?</h3>
+    Non. Vous devez simplement être bilingue et suggérer des traductions humaines (l'utilisation de la traduction automatique est interdite !) au mieux de vos capacités, aucune expérience professionnelle n'est requise.
+  </CardContent>
+</TwoColumnContent>
+
+<TwoColumnContent>
+  <CardContent>
+  <h3 className="mt-6 mb-3">Combien de temps dois-je y consacrer ?</h3>
+    Autant que vous le souhaitez. Le seuil minimum pour être éligible aux prix est de 1 000 mots traduits, ce qui devrait prendre environ 2 heures, tandis que la compétition pour les premiers prix exigera un engagement en temps plus important.
+  </CardContent>
+  <CardContent>
+    <h3 className="mt-6 mb-3">Dois-je bien connaître Ethereum ?</h3>
+    Non. Bien que la connaissance d'Ethereum puisse améliorer votre productivité et la qualité de votre travail, le Translatathon est aussi une expérience d'apprentissage. Tout le monde est invité à participer pour en apprendre davantage sur Ethereum.
+  </CardContent>
+</TwoColumnContent>
+
+Pour plus de détails, [consultez l'intégralité des Conditions générales](/contributing/translation-program/translatathon/terms-and-conditions)
+
+### Instructions pas à pas {#step-by-step-instructions}
+
+<StepByStepInstructions />
+
+## Prix {#prizes}
+
+| Classement        | Montant du prix |
+| ----------------- | --------------- |
+| 1re place         | $4000           |
+| 2e place          | $2500           |
+| 3e place          | $1500           |
+| 4e place          | $1100           |
+| 5e place          | $1000           |
+| 6e place          | $600            |
+| 7e place          | $550            |
+| 8e place          | $500            |
+| 9e place          | $450            |
+| 10e place         | $400            |
+| 11e à 20e place   | $240            |
+| 21e à 50e place   | $120            |
+| 51e à 100e place  | $60             |
+| 101e à 150e place | $40             |
+| Autres            | $20             |
+
+Tous les prix seront payés en ETH.
+
+<TranslatathonCalendar />
+
+<ApplyNow />
diff --git a/public/content/translations/fr/contributing/translation-program/translators-guide/index.md b/public/content/translations/fr/contributing/translation-program/translators-guide/index.md
index bcb331c2aca..48431914bea 100644
--- a/public/content/translations/fr/contributing/translation-program/translators-guide/index.md
+++ b/public/content/translations/fr/contributing/translation-program/translators-guide/index.md
@@ -1,5 +1,5 @@
 ---
-title: Guide à l'intention des traducteurs
+title: "Guide à l'intention des traducteurs"
 lang: fr
 description: Instructions et conseils pour les traducteurs d'ethereum.org
 ---
@@ -10,13 +10,13 @@ Le guide de style pour la traduction d'ethereum.org contient les principales rec
 
 Ce document sert de guide général et n'est spécifique à aucune langue.
 
-Si vous avez des questions, des suggestions ou des commentaires, n'hésitez pas à nous contacter à l'adresse translations@ethereum.org, à envoyer un message à @ethdotorg sur Crowdin ou à [rejoindre notre serveur Discord](https://discord.gg/ethereum-org), où vous pourrez nous envoyer un message dans le canal #translations ou contacter l'un des membres de l'équipe.
+Si vous avez des questions, des suggestions ou des commentaires, n'hésitez pas à nous contacter à l'adresse translations@ethereum.org, à envoyer un message à @ethdotorg sur Crowdin ou à [rejoindre notre Discord](https://discord.gg/ethereum-org), où vous pourrez nous envoyer un message sur le canal #translations ou contacter l'un des membres de l'équipe.
 
-## Utiliser Crowdin {#using-crowdin}
+## Utilisation de Crowdin {#using-crowdin}
 
-Vous pouvez trouver les instructions de base pour rejoindre le projet sur Crowdin et sur l'utilisation de l'éditeur en ligne de la plateforme sur la [page du programme de traduction](/contributing/translation-program/#how-to-translate).
+Vous trouverez des instructions de base sur la façon de rejoindre le projet dans Crowdin et d'utiliser l'éditeur en ligne de Crowdin sur la [page du programme de traduction](/contributing/translation-program/#how-to-translate).
 
-Si vous souhaitez en savoir plus sur Crowdin et sur certaines de ses fonctionnalités avancées, la [base de connaissances de Crowdin](https://support.crowdin.com/online-editor/) contient de nombreux guides approfondis et des aperçus de toutes les fonctionnalités de Crowdin.
+Si vous souhaitez en savoir plus sur Crowdin et l'utilisation de certaines de ses fonctionnalités avancées, la [base de connaissances de Crowdin](https://support.crowdin.com/online-editor/) contient de nombreux guides approfondis et des aperçus de toutes les fonctionnalités de Crowdin.
 
 ## Saisir l'essence du message {#capturing-the-essence}
 
@@ -28,7 +28,7 @@ Chaque langue a ses règles grammaticales, ses conventions et sa syntaxe. Lors d
 
 Au lieu de traduire le texte original mot pour mot, il est recommandé de lire la phrase entière et de l'adapter aux conventions de la langue de destination.
 
-## Formel et informel {#formal-vs-informal}
+## Formel ou informel {#formal-vs-informal}
 
 Nous utilisons la forme formelle (le vouvoiement), car elle est toujours polie et appropriée pour tous les visiteurs.
 
@@ -42,7 +42,7 @@ Notre objectif est de rendre le contenu du site accessible au plus grand nombre
 
 La plupart du temps, il suffit d'utiliser des mots courts et simples qui sont faciles à comprendre. S'il y a plusieurs traductions possibles pour un certain mot, le meilleur choix sera souvent le mot le plus court reflétant clairement le sens.
 
-## Système de rédaction {#writing-system}
+## Système d'écriture {#writing-system}
 
 Ethereum.org est disponible en plusieurs langues qui utilisent des systèmes d'écriture (ou des scripts) différents du système latin.
 
@@ -50,17 +50,17 @@ Tout le contenu doit alors être traduit en utilisant le système d'écriture de
 
 Lors de la traduction du contenu, vous devez vous assurer que les traductions sont cohérentes et n'incluent pas de caractères latins.
 
-Une idée reçue courante voudrait qu'« Ethereum » soit toujours écrit en latin. C'est généralement incorrect. Veuillez utiliser l'orthographe d'« Ethereum » native dans votre langue (ex : 以太坊 en chinois, إيثيريوم en arabe, etc.).
+Une idée reçue courante voudrait qu'« Ethereum » soit toujours écrit en latin. C'est généralement incorrect. Veuillez utiliser l'orthographe d'« Ethereum » native dans votre langue (ex : 以太坊 en chinois, إيثيريوم en arabe, etc.).
 
 **Ceci ne s'applique pas aux langues au sein desquelles il existe une règle proscrivant la traduction des noms propres.**
 
-## Traduire les métadonnées des pages {#translating-metadata}
+## Traduction des métadonnées de la page {#translating-metadata}
 
 Certaines pages contiennent des métadonnées comme « title », « lang », « description », « sidebar », etc.
 
 Nous « cachons » le contenu que les traducteurs ne doivent jamais traduire lors du chargement de nouvelles pages sur Crowdin, ce qui signifie que toutes les métadonnées visibles aux traducteurs dans Crowdin doivent être traduites.
 
-Soyez particulièrement attentif lorsque vous traduisez des chaînes où le texte source est « en ». Ce texte indique la langue dans laquelle la page est disponible et doit donc être traduit par le [code de langue ISO correspondant à votre langue](https://www.andiamo.co.uk/resources/iso-language-codes/). Ces chaînes de caractères doivent toujours être traduites en utilisant des caractères latins, et non le script natif de la langue cible.
+Soyez particulièrement attentif lorsque vous traduisez des chaînes où le texte source est « en ». Ceci représente la langue dans laquelle la page est disponible et doit être traduit par le [code de langue ISO de votre langue](https://www.andiamo.co.uk/resources/iso-language-codes/). Ces chaînes de caractères doivent toujours être traduites en utilisant des caractères latins, et non le script natif de la langue cible.
 
 Si vous n'êtes pas certain du code de langue à utiliser, vous pouvez vérifier la mémoire de traduction dans Crowdin ou trouver le code de votre langue dans l'URL de la page dans l'éditeur en ligne Crowdin.
 
@@ -78,15 +78,18 @@ Certaines chaînes de caractères contiennent des titres d'articles externes. La
 
 Pour vous aider à les repérer, vous trouverez ci-dessous quelques exemples de ces chaînes (les liens vers les articles se trouvent principalement en bas de ces pages, dans la section « Further reading » [Lectures complémentaires]) :
 
-![Titres des articles dans sidebar.png](./article-titles-in-sidebar.png) ![Titres des articles dans editor.png](./article-titles-in-editor.png)
+![Titres des articles dans la barre latérale](./article-titles-in-sidebar.png)
+![Titres des articles dans l'éditeur](./article-titles-in-editor.png)
 
-## Notification d'erreur Crowdin {#crowdin-warnings}
+## Avertissements de Crowdin {#crowdin-warnings}
 
-Crowdin a une fonctionnalité intégrée qui avertit les traducteurs lorsqu'ils sont sur le point de faire une erreur. Crowdin vous en avertira automatiquement avant d'enregistrer votre traduction si vous oubliez d'inclure une balise de la source, de traduire des éléments qui ne devraient pas être traduits, d'ajouter plusieurs espaces consécutifs, d'oublier la ponctuation de fin, etc. Si un tel avertissement s'affiche, veuillez revenir en arrière et vérifier la traduction proposée.
+Crowdin a une fonctionnalité intégrée qui avertit les traducteurs lorsqu'ils sont sur le point de faire une erreur. Crowdin vous en avertira automatiquement avant d'enregistrer votre traduction si vous oubliez d'inclure une balise de la source, de traduire des éléments qui ne devraient pas être traduits, d'ajouter plusieurs espaces consécutifs, d'oublier la ponctuation de fin, etc.
+Si un tel avertissement s'affiche, veuillez revenir en arrière et vérifier la traduction proposée.
 
 **N'ignorez jamais ces avertissements, car ils signifient généralement que quelque chose ne va pas ou qu'il manque un élément essentiel du texte source dans la traduction.**
 
-Voici un exemple d'avertissement Crowdin lorsque vous oubliez d'ajouter une balise à votre traduction : ![Exemple d'un avertissement dans Crowdin](./crowdin-warning-example.png)
+Exemple d'un avertissement Crowdin lorsque vous oubliez d'ajouter une balise à votre traduction :
+![Exemple d'un avertissement Crowdin](./crowdin-warning-example.png)
 
 ## Gestion des balises et des extraits de code {#dealing-with-tags}
 
@@ -96,15 +99,18 @@ Une grande partie du contenu de la source contient des balises et des variables,
 
 Pour faciliter la gestion des tags et les copier directement à partir de la source, nous vous recommandons de modifier vos paramètres dans l'éditeur Crowdin.
 
-1. Ouvrez les paramètres de l'éditeur ![Comment ouvrir les paramètres de l'éditeur](./editor-settings.png)
+1. Ouvrir les paramètres
+   ![Comment ouvrir les paramètres dans l'éditeur](./editor-settings.png)
 
 2. Allez à la section 'Affichage des tags HTML'
 
-3. Sélectionnez 'Masquer' ![Veuillez sélectionner 'Masquer'](./hide-tags.png)
+3. Sélectionner « Masquer »
+   ![Veuillez sélectionner « Masquer »](./hide-tags.png)
 
 4. Cliquez sur 'Enregistrer'
 
-En sélectionnant cette option, le texte du tag complet ne sera plus affiché et sera remplacé par un nombre. Lors de la traduction, cliquer sur ce tag copiera automatiquement le tag exact dans le champ de traduction.
+En sélectionnant cette option, le texte du tag complet ne sera plus affiché et sera remplacé par un nombre.
+Lors de la traduction, cliquer sur ce tag copiera automatiquement le tag exact dans le champ de traduction.
 
 **Liens**
 
@@ -114,15 +120,15 @@ Ceux-ci doivent rester identiques à la source sans changement ni traduction. Si
 
 La meilleure façon de gérer les liens est de les copier directement à partir de la source, soit en cliquant dessus, soit en utilisant le bouton « Copy Source » (Copier la source) (Alt+C).
 
-![Exemple de lien.png](./example-of-link.png)
+![Exemple de lien](./example-of-link.png)
 
-Les liens apparaissent également dans le texte source sous la forme de balises (c'est-à-dire `<0> </0>`). Si vous survolez la balise, l'éditeur affichera son véritable contenu. Parfois, ces balises désigneront des liens.
+Les liens apparaissent également dans le texte source sous la forme de balises (c'est-à-dire, `<0>` `</0>`). Si vous survolez la balise, l'éditeur affichera son véritable contenu. Parfois, ces balises désigneront des liens.
 
 Il est très important de copier les liens depuis le texte source et de ne pas modifier l'ordre des balises.
 
 Si l'ordre des balises est changé, le lien qu'elles représentent sera cassé.
 
-![Exemple de liens à l'intérieur de balises.png](./example-of-links-inside-tags.png)
+![Exemple de liens à l'intérieur de balises](./example-of-links-inside-tags.png)
 
 **Balises et variables**
 
@@ -130,19 +136,19 @@ Le texte source contient de nombreux types de balises différentes, qui doivent
 
 Les balises comprennent toujours une balise ouvrante et une balise fermante. Et en général, le texte compris entre les deux balises doit être traduit.
 
-Exemple : `<strong x-id="1">`Décentralisé`</strong>`
+Exemple : `<strong x-id="1">`Décentralisé`</strong>`
 
-`<strong x-id="1">` - _Balise ouvrante qui fait apparaître le texte en gras_
+`<strong x-id="1">` - _Balise ouvrante qui met le texte en gras_
 
-Décentralisé - _Texte à traduire_
+Décentralisé - _Texte traduisible_
 
 `</strong>` - _Balise fermante_
 
-![Exemple de balises strong.png](./example-of-strong-tags.png)
+![Exemple de balises « strong »](./example-of-strong-tags.png)
 
 Les extraits de code doivent être abordés légèrement différemment des autres balises, car ils contiennent du code qui ne doit pas être traduit.
 
-Exemple : `<code>`nonce`</code>`
+Exemple : `<code>`nonce`</code>`
 
 `<code>` - _Balise ouvrante, qui contient un extrait de code_
 
@@ -150,17 +156,17 @@ nonce - _Texte non traduisible_
 
 `</code>` - _Balise fermante_
 
-![Exemple d'extraits de code.png](./example-of-code-snippets.png)
+![Exemple d'extraits de code](./example-of-code-snippets.png)
 
 Le texte source contient aussi des balises raccourcies. Elles contiennent uniquement des chiffres et leur fonction n'est donc pas directement identifiable. Vous pouvez survoler ces balises pour voir exactement ce à quoi elles servent.
 
-Dans l'exemple ci-dessous, vous pouvez voir que survoler la balise `<0>` nous permet de savoir qu'elle désigne en fait une balise `<code>` et qu'elle contient un extrait de code. Le contenu de ces balises ne doit donc pas être traduit.
+Dans l'exemple ci-dessous, vous pouvez voir que le survol de la balise `<0>` montre qu'elle représente `<code>` et contient un extrait de code. Par conséquent, le contenu à l'intérieur de ces balises ne doit pas être traduit.
 
-![Exemple de balises ambiguës.png](./example-of-ambiguous-tags.png)
+![Exemple de balises ambiguës](./example-of-ambiguous-tags.png)
 
-## Formes courtes et formes complètes/abréviations {#short-vs-full-forms}
+## Formes courtes ou complètes/abréviations {#short-vs-full-forms}
 
-De nombreuses abréviations sont utilisées sur le site, comme dApps, NFT, DAO, DeFi, etc. Ces abréviations sont couramment utilisées en anglais et les visiteurs du site web les connaissent généralement.
+De nombreuses abréviations sont utilisées sur le site, par exemple dapps, NFT, DAO, DeFi, etc. Ces abréviations sont couramment utilisées en anglais et les visiteurs du site web les connaissent généralement.
 
 Étant donné qu'elles n'ont souvent pas de traduction établie dans les autres langues, la meilleure façon d'adapter ces termes (ainsi que les termes qui gravitent autour) est de fournir une traduction descriptive de leur forme complète, puis d'ajouter l'abréviation entre parenthèses.
 
@@ -168,7 +174,7 @@ Ne traduisez pas ces abréviations, car la plupart des gens ne les connaissent p
 
 Exemple de la manière de traduire « dApps » :
 
-- Applications décentralisées (dApps) → _Forme complète traduite (abréviation anglaise entre parenthèses)_
+- Applications décentralisées (dapps) → _Forme complète traduite (abréviation anglaise entre parenthèses)_
 
 ## Termes sans traduction établie {#terms-without-established-translations}
 
@@ -180,17 +186,17 @@ Lorsque vous traduisez ces termes, soyez créatifs, utilisez des traductions des
 
 **Le fait de traduire ces termes, plutôt que de les laisser en anglais, permettra à cette nouvelle terminologie de se généraliser à l'avenir, à mesure que de plus en plus de personnes utiliseront Ethereum et les technologies associées. Si nous voulons faire connaître ce domaine à plus de personnes à travers le monde, nous devons fournir une terminologie compréhensible dans un maximum de langues, quitte à la créer nous-mêmes.**
 
-## Boutons & boutons d'appel à l'action {#buttons-and-ctas}
+## Boutons et CTA {#buttons-and-ctas}
 
 Le site contient de nombreux boutons, qui doivent être traduits différemment des autres contenus.
 
 Vous pouvez repérer un bouton et son contenu en visualisant les captures d'écran contextuelles, fournies avec la plupart des textes sources, ou bien en regardant le contexte de l'éditeur, qui inclura le terme « button » (bouton).
 
-Les traductions des boutons doivent être aussi courtes que possible pour éviter les problèmes de mise en forme. En outre, la traduction des boutons doit être impérative, c'est-à-dire exprimer un ordre ou une demande.
+Les traductions des boutons doivent être aussi courtes que possible pour éviter les problèmes de mise en forme. En outre, la traduction des boutons doit être impérative, c'est-à-dire présenter un ordre ou une demande.
 
-![Comment repérer un bouton.png](./how-to-find-a-button.png)
+![Comment trouver un bouton](./how-to-find-a-button.png)
 
-## Traduire de façon inclusive {#translating-for-inclusivity}
+## Traduction inclusive {#translating-for-inclusivity}
 
 Les visiteurs d'ethereum.org viennent de partout dans le monde et d'horizons différents. Le langage du site web devrait donc être neutre, accueillant pour tout le monde et inclusif.
 
@@ -200,7 +206,7 @@ Une autre forme d'inclusivité consiste à faire en sorte que la traduction s'ad
 
 Enfin, le langage doit être adapté à tous les publics et tous les âges.
 
-## Traductions spécifiques dans une langue {#language-specific-translations}
+## Traductions spécifiques à la langue {#language-specific-translations}
 
 Lors de la traduction, plutôt que de calquer simplement la source, il est important de suivre les règles de grammaire, les conventions et le formatage en vigueur dans votre langue. Le texte source suit les règles et conventions de la grammaire anglaise, qui ne sont pas applicables dans beaucoup d'autres langues.
 
@@ -208,7 +214,7 @@ Vous devez donc avoir les règles de votre langue en tête afin de traduire corr
 
 Voici quelques exemples de ce à quoi vous devrez faire attention :
 
-### Ponctuation, mise en forme {#punctuation-and-formatting}
+### Ponctuation et formatage {#punctuation-and-formatting}
 
 **Majuscules**
 
@@ -216,12 +222,12 @@ Voici quelques exemples de ce à quoi vous devrez faire attention :
 - En anglais, il est courant de mettre en majuscule sur la première lettre de tous les mots contenus dans les titres, les noms, les mois, les jours, le nom des langues, les jours fériés, etc. Dans de nombreuses autres langues, c'est grammaticalement incorrect, car les règles sont différentes.
 - Certaines langues ont aussi des règles sur la mise en majuscule des pronoms personnels, des noms communs et de certains adjectifs, qui ne portent pas de majuscule en anglais.
 
-**Espaces**
+**Espacement**
 
 - Les règles orthographiques définissent l'utilisation des espaces pour chaque langue. Ces règles sont souvent très spécifiques, et parce que les espaces sont utilisés partout, ils sont parmi les éléments les plus mal traduits.
 - Voici quelques différences d'espacement fréquentes entre l'anglais et d'autres langues :
-  - Espace avant les unités de mesure et les devises (ex. USD, EUR, kB, MB)
-  - Espace avant le signe de degré (ex. °C, ℉)
+  - Espace avant les unités de mesure et les devises (par ex., USD, EUR, kB, MB)
+  - Espace avant les signes de degré (par ex., °C, ℉)
   - Espace avant certains signes de ponctuation, notamment l'ellipse (…)
   - Espace avant et après les barres obliques (/)
 
@@ -229,7 +235,7 @@ Voici quelques exemples de ce à quoi vous devrez faire attention :
 
 - Chaque langue possède un ensemble de règles diverses et variées pour la rédaction des listes. Elles peuvent différer considérablement de l'anglais.
 - Dans certaines langues, le premier mot de chaque nouvelle ligne doit avoir sa première lettre en majuscule, tandis que dans d'autres langues, les nouvelles lignes doivent commencer par une lettre minuscule. Plusieurs langues ont aussi différentes règles sur la présence de majuscule en début de ligne, en fonction de la longueur de celle-ci.
-- Il en va de même pour la ponctuation en fin de ligne. Cela peut être un point (**.**), une virgule (**,**) ou un point-virgule (**;**), en fonction de la langue.
+- Il en va de même pour la ponctuation en fin de ligne. La ponctuation finale dans les listes peut être un point (.), une virgule (,) ou un point-virgule (;), selon la langue.
 
 **Guillemets**
 
@@ -256,7 +262,7 @@ Voici quelques exemples de ce à quoi vous devrez faire attention :
     - Anglais – **1,000.50**
     - Espagnol – **1.000,50**
     - Français – **1 000,50**
-- Une autre chose à prendre en considération lors de la traduction de nombres est le signe pourcentage. Il peut être écrit de différentes manières : **100%**, **100 %** ou encore **%100**.
+- Une autre chose à prendre en considération lors de la traduction de nombres est le signe pourcentage. Il peut être écrit de différentes manières : **100%**, **100 %** ou **%100**.
 - Enfin, les nombres négatifs peuvent aussi s'afficher différemment en fonction de la langue : -100, 100-, (100) ou [100].
 
 **Dates**
diff --git a/public/content/translations/fr/dao/index.md b/public/content/translations/fr/dao/index.md
index 962e8abd025..784018ed161 100644
--- a/public/content/translations/fr/dao/index.md
+++ b/public/content/translations/fr/dao/index.md
@@ -1,16 +1,16 @@
 ---
 title: Qu'est-ce qu'une DAO ?
-metaTitle: Qu'est-ce qu'une DAO ? | Organisation autonome et décentralisée
-description: Un aperçu des DAO sur Ethereum
+metaTitle: "Qu'est-ce qu'une DAO ? | Organisation autonome et décentralisée"
+description: "Un aperçu des DAO sur Ethereum"
 lang: fr
 template: use-cases
 emoji: ":handshake:"
 sidebarDepth: 2
 image: /images/use-cases/dao-2.png
-alt: Une représentation d'une DAO qui vote une proposition.
-summaryPoint1: Des communautés appartenant à leurs membres sans pouvoir centralisé.
-summaryPoint2: Un moyen sûr de collaborer avec des étrangers sur Internet.
-summaryPoint3: Un endroit sûr pour engager des fonds pour une cause précise.
+alt: "Une représentation d'une DAO qui vote une proposition."
+summaryPoint1: "Des communautés appartenant à leurs membres sans pouvoir centralisé."
+summaryPoint2: "Un moyen sûr de collaborer avec des étrangers sur Internet."
+summaryPoint3: "Un endroit sûr pour engager des fonds pour une cause précise."
 ---
 
 ## Que sont les DAO ? {#what-are-daos}
@@ -19,7 +19,7 @@ Une DAO est une organisation collectivement détenue et qui travaille à une mis
 
 Les DAO nous permettent de travailler avec des personnes partageant le même état d'esprit et dans le monde entier, sans pour autant faire confiance à un dirigeant bienveillant pour gérer les fonds ou les opérations. Il n'y a pas de Directeur Général qui puisse dépenser des fonds sur un caprice ou un Chef de la direction financière capable de manipuler les registres. Au lieu de cela, les règles basées sur la blockchain ont été intégrées dans le code et définissent comment fonctionne l'organisation et comment les fonds sont dépensés.
 
-Elles possèdent une trésorerie intégrée à laquelle personne ne peut accéder sans l'accord du groupe. Les décisions sont régies par des propositions et des votes pour s'assurer que tout le monde au sein de l'organisation puisse s'exprimer et que tout se passe de manière transparente [onchain](/glossary/#onchain).
+Elles possèdent une trésorerie intégrée à laquelle personne ne peut accéder sans l'accord du groupe. Les décisions sont régies par des propositions et des votes pour s'assurer que tout le monde au sein de l'organisation a une voix, et que tout se passe de manière transparente [en chaîne](/glossary/#onchain).
 
 ## Pourquoi avons-nous besoin des DAO ? {#why-dao}
 
@@ -29,19 +29,19 @@ Cela ouvre énormément de nouvelles possibilités de collaboration et de coordi
 
 ### Une comparaison {#dao-comparison}
 
-| DAO                                                                                                                               | Organisation traditionnelle                                                                                            |
-| --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| Habituellement fixe, et pleinement démocratisée.                                                                                  | Généralement hiérarchique.                                                                                             |
-| Vote requis par les membres pour que tout changement soit mis en œuvre.                                                           | Selon la structure, des changements peuvent être demandés par une seule personne et le vote peut être biaisé.          |
-| Votes comptabilisés et résultats mis en œuvre automatiquement sans intermédiaire de confiance.                                    | Si les votes sont proposés, ils sont calculés en interne et les résultats des votes doivent être traités manuellement. |
+| DAO                                                                                                                                                                  | Organisation traditionnelle                                                                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| Habituellement fixe, et pleinement démocratisée.                                                                                                     | Généralement hiérarchique.                                                                                             |
+| Vote requis par les membres pour que tout changement soit mis en œuvre.                                                                              | Selon la structure, des changements peuvent être demandés par une seule personne et le vote peut être biaisé.          |
+| Votes comptabilisés et résultats mis en œuvre automatiquement sans intermédiaire de confiance.                                                       | Si les votes sont proposés, ils sont calculés en interne et les résultats des votes doivent être traités manuellement. |
 | Les services offerts sont gérés automatiquement de manière décentralisée (par exemple la distribution de fonds philanthropiques). | Nécessite une manipulation humaine ou une automatisation centralisée sujette à la manipulation.                        |
-| Toutes les activités sont transparentes et entièrement publiques.                                                                 | L'activité est généralement privée et limitée au public.                                                               |
+| Toutes les activités sont transparentes et entièrement publiques.                                                                                    | L'activité est généralement privée et limitée au public.                                                               |
 
 ### Exemples de DAO {#dao-examples}
 
 Pour aider votre compréhension, voici quelques exemples de la façon dont vous pourriez utiliser une DAO :
 
-- **Un organisme caritatif** – vous pouvez accepter les dons de n'importe qui dans le monde entier et voter pour les causes à financer.
+- **Un organisme de bienfaisance** – vous pouvez accepter les dons de n'importe qui dans le monde entier et voter pour les causes à financer.
 - **Propriété collective** – vous pouvez acheter des actifs physiques ou numériques et les membres peuvent voter sur la façon de les utiliser.
 - **Entreprises et subventions** – vous pouvez créer un fonds de capital-risque qui regroupe le capital d'investissement et vote sur les entreprises à soutenir. L'argent perçu pourra plus tard être redistribué entre les membres de la DAO.
 
@@ -49,11 +49,11 @@ Pour aider votre compréhension, voici quelques exemples de la façon dont vous
 
 ## Comment fonctionnent les DAO ? {#how-daos-work}
 
-La colonne vertébrale d'une DAO est [son contrat intelligent](/glossary/#smart-contract), qui définit les règles de l'organisation et détient la trésorerie du groupe. Une fois que le contrat est en vigueur sur Ethereum, personne ne peut modifier les règles autrement que par un vote. Si quelqu'un essaie de faire quelque chose qui n'est pas couvert par les règles et la logique dans le code, il échouera. Et, comme la trésorerie est également définie par le contrat intelligent, personne ne peut dépenser l'argent sans l'approbation du groupe. Cela signifie que les DAO n'ont pas besoin d'une autorité centrale. Au lieu de cela, le groupe prend des décisions collectives et les paiements sont autorisés automatiquement lorsque les votes sont passés.
+La colonne vertébrale d'une DAO est son [contrat intelligent](/glossary/#smart-contract), qui définit les règles de l'organisation et détient la trésorerie du groupe. Une fois que le contrat est en vigueur sur Ethereum, personne ne peut modifier les règles autrement que par un vote. Si quelqu'un essaie de faire quelque chose qui n'est pas couvert par les règles et la logique dans le code, il échouera. Et, comme la trésorerie est également définie par le contrat intelligent, personne ne peut dépenser l'argent sans l'approbation du groupe. Cela signifie que les DAO n'ont pas besoin d'une autorité centrale. Au lieu de cela, le groupe prend des décisions collectives et les paiements sont autorisés automatiquement lorsque les votes sont passés.
 
 Ceci est possible parce que les contrats intelligents sont étanches à toute intrusion dès qu'ils sont mis en service sur Ethereum. Vous ne pouvez pas simplement modifier le code (les règles DAO) sans que les gens le remarquent puisque tout est public.
 
-## Ethereum et DAO {#ethereum-and-daos}
+## Ethereum et les DAO {#ethereum-and-daos}
 
 Ethereum est une base parfaite pour les DAOs pour plusieurs raisons :
 
@@ -62,7 +62,7 @@ Ethereum est une base parfaite pour les DAOs pour plusieurs raisons :
 - Les contrats intelligents peuvent envoyer/recevoir des fonds. Sans cela, vous aurez besoin d'un intermédiaire de confiance pour gérer les fonds de groupe.
 - La communauté Ethereum s'est révélée plus coopérative que compétitive, permettant ainsi l'émergence de pratiques exemplaires dotés d'une grande vitesse de développement.
 
-## Gouvernance de DAO {#dao-governance}
+## Gouvernance des DAO {#dao-governance}
 
 Il existe de nombreuses considérations à prendre en compte au moment de gouverner une DAO, comme le fonctionnement du vote et des propositions.
 
@@ -70,9 +70,7 @@ Il existe de nombreuses considérations à prendre en compte au moment de gouver
 
 La délégation est la version DAO de la démocratie représentative. Les détenteurs de jetons délèguent des votes aux utilisateurs qui se désignent et s'engagent à gérer le protocole et à rester informés.
 
-#### Un exemple célèbre {#governance-example}
-
-[ENS](https://claim.ens.domains/delegate-ranking) – Les détenteurs d'ENS peuvent déléguer leurs votes à des membres de la communauté engagés pour les représenter.
+#### Un exemple célèbre {#governance-example}[ENS](https://claim.ens.domains/delegate-ranking) – Les détenteurs d'ENS peuvent déléguer leurs votes à des membres engagés de la communauté pour les représenter.
 
 ### Gouvernance automatique des transactions {#governance-example}
 
@@ -80,35 +78,35 @@ Dans de nombreuse DAO, les transactions seront automatiquement exécutées si le
 
 #### Un exemple célèbre {#governance-example}
 
-[Nouns](https://nouns.wtf) – Dans Nouns DAO, une transaction est automatiquement exécutée si un quorum de votes est atteint et qu'une majorité vote par l'affirmative, tant qu'elle ne fait pas l'objet d'un véto de la part des fondateurs.
+[Nouns](https://nouns.wtf) – Dans la DAO Nouns, une transaction est automatiquement exécutée si un quorum de votes est atteint et qu'une majorité vote par l'affirmative, tant qu'elle ne fait pas l'objet d'un veto de la part des fondateurs.
 
-### Gouvernance Multisig {#governance-example}
+### Gouvernance multisig {#governance-example}
 
-Tandis que les DAO peuvent avoir des milliers de membres votants, les fonds peuvent se trouver dans un [portefeuille](/glossary/#wallet) partagé par 5 à 20 membres actifs de la communauté qui sont dignes de confiance et généralement doxxés (identités publiques connues de la communauté). Après un vote, les signataires [multisig](/glossary/#multisig) exécutent la volonté de la communauté.
+Bien que les DAO puissent avoir des milliers de membres votants, les fonds peuvent se trouver dans un [portefeuille](/glossary/#wallet) partagé par 5 à 20 membres actifs de la communauté qui sont dignes de confiance et généralement doxxés (dont les identités publiques sont connues de la communauté). Après un vote, les signataires [multisig](/glossary/#multisig) exécutent la volonté de la communauté.
 
-## Les lois des DAO {#dao-laws}
+## Lois sur les DAO {#dao-laws}
 
 En 1977, le Wyoming a créé la LLC, qui protège les entrepreneurs et limite leur responsabilité. Plus récemment, ils ont été les pionniers de la loi pour les DAO qui établit un statut juridique pour les DAO. Actuellement, le Wyoming, le Vermont et les Îles Vierges ont des lois portant sur les DAO sous une forme ou une autre.
 
 ### Un exemple célèbre {#law-example}
 
-[CityDAO](https://citizen.citydao.io/) - CityDAO s'est servi de la loi DAO du Wyoming pour acheter 40 acres de terrain près du parc national de Yellowstone.
+[CityDAO](https://citizen.citydao.io/) – CityDAO a utilisé la loi sur les DAO du Wyoming pour acheter 40 acres de terrain près du parc national de Yellowstone.
 
-## Adhésion à la DAO {#dao-membership}
+## Adhésion à une DAO {#dao-membership}
 
 Il existe différents modèles pour adhérer à une DAO. L'adhésion peut déterminer comment fonctionne le vote et d'autres éléments clés de la DAO.
 
-### Adhésion basée sur des jetons {#token-based-membership}
+### Adhésion basée sur les jetons {#token-based-membership}
 
-Habituellement cela se fait totalement [sans permission](/glossary/#permissionless), seulement en fonction du jeton utilisé. La plupart de ces jetons de gouvernance peuvent être échangés sans permission sur un [échange décentralisé](/glossary/#dex). D’autres doivent être gagnés en fournissant des liquidités ou une autre « preuve de travail ». Quoi qu’il en soit, il suffit de détenir le jeton pour avoir accès au vote.
+Généralement entièrement [sans permission](/glossary/#permissionless), en fonction du jeton utilisé. La plupart de ces jetons de gouvernance peuvent être échangés sans permission sur un [échange décentralisé](/glossary/#dex). D’autres doivent être gagnés en fournissant des liquidités ou une autre « preuve de travail ». Quoi qu’il en soit, il suffit de détenir le jeton pour avoir accès au vote.
 
 _Généralement, cela est utilisé pour régir des protocoles décentralisés et/ou des jetons eux-mêmes._
 
 #### Un exemple célèbre {#token-example}
 
-[MakerDAO](https://makerdao.com) – Le jeton MKR de MakerDAO est largement disponible sur les échanges décentralisés et tout le monde peut acheter un droit de vote sur le futur du protocole Maker.
+[MakerDAO](https://makerdao.com) – Le jeton MKR de MakerDAO est largement disponible sur les échanges décentralisés et n'importe qui peut en acheter pour avoir un droit de vote sur l'avenir du protocole Maker.
 
-### Adhésion basée sur les actions {#share-based-membership}
+### Adhésion par actions {#share-based-membership}
 
 Les DAO basées sur le partage sont davantage soumises à l'autorisation, mais demeurent assez ouvertes. Tous les membres potentiels peuvent soumettre une proposition pour rejoindre la DAO, offrant habituellement une contribution d'une certaine valeur sous la forme de jetons ou de travail. Les actions représentent le droit de vote direct et la propriété. Les membres peuvent sortir à tout moment avec leur part proportionnelle de la trésorerie.
 
@@ -116,51 +114,53 @@ _Habituellement utilisé pour des organisations plus proches et axées sur l'asp
 
 #### Un exemple célèbre {#share-example}
 
-[MolochDAO](http://molochdao.com/) – MolochDAO se concentre sur le financement de projets Ethereum. Ils requièrent une proposition d’adhésion afin que le groupe puisse évaluer si vous avez l’expertise et le capital nécessaires pour émettre des jugements éclairés sur les bénéficiaires potentiels. Vous ne pouvez pas vous contenter d'acheter l'accès à la DAO sur le marché ouvert.
+[MolochDAO](http://molochdao.com/) – MolochDAO se concentre sur le financement des projets Ethereum. Ils requièrent une proposition d’adhésion afin que le groupe puisse évaluer si vous avez l’expertise et le capital nécessaires pour émettre des jugements éclairés sur les bénéficiaires potentiels. Vous ne pouvez pas vous contenter d'acheter l'accès à la DAO sur le marché ouvert.
 
 ### Adhésion basée sur la réputation {#reputation-based-membership}
 
 Ici, la réputation représente une preuve de participation et accorde le droit de vote dans la DAO. Contrairement à une adhésion basée sur des jetons ou sur les actions, les DAO basées sur la réputation ne transfèrent pas la propriété aux contributeurs. En effet, la réputation ne peut pas être achetée, transférée ou déléguée  ; les membres de la DAO doivent mériter leur réputation par la participation. Le vote sur la chaîne est sans permission, les membres potentiels peuvent librement soumettre des propositions pour rejoindre la DAO et demander à obtenir une réputation et des jetons en guise de récompense en échange de leurs contributions.
 
-_Habituellement utilisée pour le développement décentralisé et la gouvernance de protocoles et de [DApps](/glossary/#dapp), cette méthode est également adaptée à divers autres types d'organisations, comme les organismes caritatifs, les collectifs de travailleurs, les clubs d'investissement, etc._
+_Généralement utilisée pour le développement décentralisé et la gouvernance des protocoles et des [dapps](/glossary/#dapp), cette méthode convient également à divers types d'organisations, comme les organismes de bienfaisance, les collectifs de travailleurs, les clubs d'investissement, etc._
 
 #### Un exemple célèbre {#reputation-example}
 
-[DXdao](https://DXdao.eth.limo) - DXdao est une construction collective mondiale souveraine et régit des protocoles et applications décentralisés depuis 2019. DXdao tire parti d'une gouvernance basé sur la réputation et du [consensus holographique](/glossary/#holographic-consensus) pour coordonner et gérer les fonds, ce qui signifie que personne ne pourrait faire en sorte d'influencer son futur ou sa gouvernance.
+[DXdao](https://DXdao.eth.limo) – DXdao était un collectif souverain mondial qui créait et gouvernait des protocoles et des applications décentralisés depuis 2019. Elle a tiré parti de la gouvernance basée sur la réputation et du [consensus holographique](/glossary/#holographic-consensus) pour coordonner et gérer les fonds, ce qui signifie que personne ne pouvait acheter son influence sur son avenir ou sa gouvernance.
 
-## Rejoindre/démarrer une DAO {#join-start-a-dao}
+## Rejoindre / créer une DAO {#join-start-a-dao}
 
-### Rejoindre une organisation autonome décentralisée (DAO) {#join-a-dao}
+### Rejoindre une DAO {#join-a-dao}
 
 - [DAO de la communauté Ethereum](/community/get-involved/#decentralized-autonomous-organizations-daos)
-- [Liste des DAO de DAOHauss](https://app.daohaus.club/explore)
-- [Liste des DAO Tally.xyz](https://www.tally.xyz)
+- [Liste de DAO de DAOHaus](https://app.daohaus.club/explore)
+- [Liste de DAO de Tally.xyz](https://www.tally.xyz/explore)
+- [Liste de DAO de DeGov.AI](https://apps.degov.ai/)
 
-### Démarrer une DAO {#start-a-dao}
+### Créer une DAO {#start-a-dao}
 
-- [Invoquer une DAO avec DAOHaus](https://app.daohaus.club/summon)
-- [Lancer une Governor DAO avec Tally](https://www.tally.xyz/add-a-dao)
+- [Créer une DAO avec DAOHaus](https://app.daohaus.club/summon)
+- [Créer une Governor DAO avec Tally](https://www.tally.xyz/get-started)
 - [Créer une DAO propulsée par Aragon](https://aragon.org/product)
 - [Lancer une colonie](https://colony.io/)
 - [Créer une DAO avec le consensus holographique de DAOstack](https://alchemy.daostack.io/daos/create)
+- [Lancer une DAO avec le DeGov Launcher](https://docs.degov.ai/integration/deploy)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-### Articles DAO {#dao-articles}
+### Articles sur les DAO {#dao-articles}
 
 - [Qu'est-ce qu'une DAO ?](https://aragon.org/dao) – [Aragon](https://aragon.org/)
-- [La maison des DAOs](https://wiki.metagame.wtf/docs/great-houses/house-of-daos) – [Metagame](https://wiki.metagame.wtf/)
-- [Qu'est-ce qu'une DAO et à quoi sert-elle ?](https://daohaus.substack.com/p/-what-is-a-dao-and-what-is-it-for) – [DAOhaus](https://daohaus.club/)
-- [Comment démarrer une communauté numérique DAO](https://daohaus.substack.com/p/four-and-a-half-steps-to-start-a) – [DAOhaus](https://daohaus.club/)
+- [House of DAOs](https://wiki.metagame.wtf/docs/great-houses/house-of-daos) – [Metagame](https://wiki.metagame.wtf/)
+- [Qu'est-ce qu'une DAO et à quoi ça sert ?](https://daohaus.substack.com/p/-what-is-a-dao-and-what-is-it-for) – [DAOhaus](https://daohaus.club/)
+- [Comment démarrer une communauté numérique alimentée par une DAO](https://daohaus.substack.com/p/four-and-a-half-steps-to-start-a) – [DAOhaus](https://daohaus.club/)
 - [Qu'est-ce qu'une DAO ?](https://coinmarketcap.com/alexandria/article/what-is-a-dao) – [Coinmarketcap](https://coinmarketcap.com)
-- [Qu'est-ce que le Consensus holographique ?](https://medium.com/daostack/holographic-consensus-part-1-116a73ba1e1c) - [DAOstack](https://daostack.io/)
-- [Les DAO ne sont pas des entreprises : là où la décentralisation dans les organisations autonomes compte, par Vitalik](https://vitalik.eth.limo/general/2022/09/20/daos.html)
-- [DAO, DAC, DA et plus : un guide terminologique incomplet](https://blog.ethereum.org/2014/05/06/daos-dacs-das-and-more-an-incomplete-terminology-guide) - [Blog Ethereum](https://blog.ethereum.org)
+- [Qu'est-ce que le consensus holographique ?](https://medium.com/daostack/holographic-consensus-part-1-116a73ba1e1c) - [DAOstack](https://daostack.io/)
+- [Les DAO ne sont pas des entreprises : où la décentralisation dans les organisations autonomes est importante, par Vitalik](https://vitalik.eth.limo/general/2022/09/20/daos.html)
+- [DAO, DAC, DA et plus encore : un guide terminologique incomplet](https://blog.ethereum.org/2014/05/06/daos-dacs-das-and-more-an-incomplete-terminology-guide) - [Blog Ethereum](https://blog.ethereum.org)
 
 ### Vidéos {#videos}
 
-- [Qu'est-ce qu'une DAO en cryptomonnaie ?](https://youtu.be/KHm0uUPqmVE)
-- [Une DAO peut-elle bâtir une ville ?](https://www.ted.com/talks/scott_fitsimones_could_a_dao_build_the_next_great_city) – [TED](https://www.ted.com/)
+- [Qu'est-ce qu'une DAO en crypto ?](https://youtu.be/KHm0uUPqmVE)
+- [Une DAO peut-elle construire une ville ?](https://www.ted.com/talks/scott_fitsimones_could_a_dao_build_the_next_great_city) – [TED](https://www.ted.com/)
 
 <Divider />
 
diff --git a/public/content/translations/fr/decentralized-identity/index.md b/public/content/translations/fr/decentralized-identity/index.md
index b98754ae1cd..a05bb4b760f 100644
--- a/public/content/translations/fr/decentralized-identity/index.md
+++ b/public/content/translations/fr/decentralized-identity/index.md
@@ -1,25 +1,25 @@
 ---
-title: Identité décentralisée
-description: Qu’est-ce que l’identité décentralisée et pourquoi est-ce important ?
+title: "Identité décentralisée"
+description: "Qu’est-ce que l’identité décentralisée et pourquoi est-ce important ?"
 lang: fr
 template: use-cases
 emoji: ":id:"
 sidebarDepth: 2
 image: /images/eth-gif-cat.png
-summaryPoint1: Les systèmes traditionnels d'identité centralisent l'émission, le maintien et le contrôle de vos identifiants.
-summaryPoint2: L'identité décentralisée supprime la dépendance à l'égard de tiers centralisés.
-summaryPoint3: Grâce à la cryptomonnaie, les utilisateurs ont maintenant les outils pour émettre, conserver et contrôler à nouveau leurs propres identifiants et attestations.
+summaryPoint1: "Les systèmes traditionnels d'identité centralisent l'émission, le maintien et le contrôle de vos identifiants."
+summaryPoint2: "L'identité décentralisée supprime la dépendance à l'égard de tiers centralisés."
+summaryPoint3: "Grâce à la cryptomonnaie, les utilisateurs ont maintenant les outils pour émettre, conserver et contrôler à nouveau leurs propres identifiants et attestations."
 ---
 
 Aujourd'hui, l'identité sous-tend pratiquement tous les aspects de votre existence. Utiliser les services en ligne, ouvrir un compte bancaire, voter aux élections, acheter un bien, obtenir un emploi, tout cela nécessite de prouver votre identité.
 
-Cependant, les systèmes traditionnels de gestion d'identité reposent depuis longtemps sur des intermédiaires centralisés qui émettent, conservent et contrôlent vos identifiants et vos [attestations](/glossary/#attestation). Cela signifie que vous ne pouvez pas contrôler les renseignements relatifs à votre identité ou décider qui a accès à des renseignements personnels identifiables (PII) et quel est le niveau d'accès de ces parties.
+Cependant, les systèmes traditionnels de gestion d'identité reposent depuis longtemps sur des intermédiaires centralisés qui émettent, conservent et contrôlent vos identifiants et [attestations](/glossary/#attestation). Cela signifie que vous ne pouvez pas contrôler les renseignements relatifs à votre identité ou décider qui a accès à des renseignements personnels identifiables (PII) et quel est le niveau d'accès de ces parties.
 
-Pour résoudre ces problèmes, nous avons des systèmes d'identité décentralisés construits sur des blockchains publiques comme Ethereum. L'identité décentralisée permet aux individus de gérer les informations relatives à leur identité. Avec des solutions d’identité décentralisées, _vous_ pouvez créer des identifiants et réclamer et détenir vos attestations sans compter sur les autorités centrales, comme les fournisseurs de services ou les gouvernements.
+Pour résoudre ces problèmes, nous avons des systèmes d'identité décentralisés construits sur des blockchains publiques comme Ethereum. L'identité décentralisée permet aux individus de gérer les informations relatives à leur identité. Avec les solutions d'identité décentralisée, _vous_ pouvez créer des identifiants, réclamer et conserver vos attestations sans dépendre d'autorités centrales, telles que les fournisseurs de services ou les gouvernements.
 
 ## Qu'est-ce qu'une identité? {#what-is-identity}
 
-L'identité signifie le sentiment de soi d'un individu, défini par des caractéristiques uniques. L'identité désigne le fait d'être un _individu_, c'est-à-dire une entité humaine distincte. L'identité pourrait également se référer à d'autres entités non humaines, comme une organisation ou une autorité.
+L'identité signifie le sentiment de soi d'un individu, défini par des caractéristiques uniques. L'identité fait référence au fait d'être un _individu_, c'est-à-dire une entité humaine distincte. L'identité pourrait également se référer à d'autres entités non humaines, comme une organisation ou une autorité.
 
 <YouTube id="Ew-_F-OtDFI" />
 
@@ -35,51 +35,77 @@ Un identificateur est une information qui sert de pointeur vers une identité pa
 
 Ces exemples traditionnels d’identifiants sont publiés, détenus et contrôlés par des entités centrales. Vous avez besoin de la permission de votre gouvernement pour changer votre nom ou de celle d'une plateforme de médias sociaux pour changer de pseudo.
 
-## Avantages d'une identité décentralisée {#benefits-of-decentralized-identity}
+## Avantages de l'identité décentralisée {#benefits-of-decentralized-identity}
 
 1. L'identité décentralisée accroît votre contrôle sur vos informations personnelles d'identification. Les identifiants et attestations décentralisés peuvent être vérifiés sans dépendre des autorités centralisées et des services tiers.
 
-2. Les solutions d'identité décentralisées facilitent la vérification et la gestion de l'identité des utilisateurs de manière fiable, transparente et protègent la vie privée.
+2. Les solutions d'identité décentralisée facilitent une méthode sans tiers de confiance, transparente et respectueuse de la vie privée pour vérifier et gérer l'identité des utilisateurs.
 
 3. L'identité décentralisée exploite la technologie blockchain, qui crée la confiance entre les différentes parties et fournit des garanties cryptographiques pour prouver la validité des attestations.
 
-4. L'identité décentralisée rend les données d'identité transférables. Les utilisateurs stockent des attestations et des identificateurs dans un portefeuille numérique et peuvent les partager avec n'importe quelle partie de leur choix. Les identifiants et attestations décentralisés ne sont pas verrouillés dans la base de données de l'organisme émetteur.
+4. L'identité décentralisée rend les données d'identité transférables. Les utilisateurs stockent les attestations et les identifiants dans un portefeuille mobile et peuvent les partager avec n'importe quelle partie de leur choix. Les identifiants et attestations décentralisés ne sont pas verrouillés dans la base de données de l'organisme émetteur.
 
-5. L'identité décentralisée devrait bien fonctionner avec les technologies émergentes de [connaissance zéro](/glossary/#zk-proof) qui permettront aux individus de prouver qu'ils possèdent ou ont fait quelque chose sans révéler ce que c'est. Cela pourrait devenir un moyen puissant de combiner confiance et confidentialité pour des applications telles que le vote.
+5. L'identité décentralisée devrait bien fonctionner avec les technologies émergentes de [preuve à divulgation nulle de connaissance](/glossary/#zk-proof) qui permettront aux individus de prouver qu'ils possèdent ou ont fait quelque chose sans révéler ce que c'est. Cela pourrait devenir un moyen puissant de combiner confiance et confidentialité pour des applications telles que le vote.
 
-6. L'identité décentralisée permet aux mécanismes [anti-Sybil](/glossary/#anti-sybil) de détecter lorsqu'un individu se fait passer pour plusieurs autres afin de jouer ou de spammer un système.
+6. L'identité décentralisée active des mécanismes [anti-Sybil](/glossary/#anti-sybil) pour identifier quand un individu se fait passer pour plusieurs personnes pour exploiter ou polluposter un système.
 
 ## Cas d'utilisation de l'identité décentralisée {#decentralized-identity-use-cases}
 
 L'identité décentralisée propose de nombreux cas d'utilisation potentiels :
 
-### 1. Connexions universelles {#universal-dapp-logins}
+### 1. Identifiants universels {#universal-dapp-logins}
 
-L'identité décentralisée peut aider à remplacer les connexions par mot de passe par une authentification décentralisée. Les fournisseurs de services peuvent délivrer des attestations aux utilisateurs, qui peuvent être stockées dans un portefeuille Ethereum. Un exemple d'attestation serait un [NFT](/glossary/#nft) accordant au titulaire l'accès à une communauté en ligne.
+L'identité décentralisée peut aider à remplacer les connexions par mot de passe par une authentification décentralisée. Les fournisseurs de services peuvent délivrer des attestations aux utilisateurs, qui peuvent être stockées dans un portefeuille Ethereum. Un exemple d'attestation serait un [NFT](/glossary/#nft) accordant à son détenteur l'accès à une communauté en ligne.
 
-Une fonction de [connexion avec Ethereum](https://siwe.xyz/) permettrait alors aux serveurs de confirmer le compte Ethereum de l'utilisateur et de récupérer l'attestation requise à partir de l'adresse de son compte. Cela signifie que les utilisateurs peuvent accéder aux plateformes et aux sites web sans avoir à mémoriser de longs mots de passe et améliore l'expérience en ligne des utilisateurs.
+Une fonction [Se connecter avec Ethereum](https://siwe.xyz/) permettrait alors aux serveurs de confirmer le compte Ethereum de l'utilisateur et de récupérer l'attestation requise depuis l'adresse de son compte. Cela signifie que les utilisateurs peuvent accéder aux plateformes et aux sites web sans avoir à mémoriser de longs mots de passe et améliore l'expérience en ligne des utilisateurs.
 
 ### 2. Authentification KYC {#kyc-authentication}
 
 L'utilisation de nombreux services en ligne exige des personnes qu'elles fournissent des attestations et des justificatifs, tels qu'un permis de conduire ou un passeport national. Mais cette approche est problématique, car les informations privées des utilisateurs peuvent être compromises et les fournisseurs de services ne peuvent pas vérifier l'authenticité de l'attestation.
 
-L'identité décentralisée permet aux entreprises de se passer des processus classiques de [connaissance du client (Know-Your-Customer KYC)](https://en.wikipedia.org/wiki/Know_your_customer) et d'authentifier l'identité des utilisateurs au moyen d'identifiants vérifiables. Cela réduit le coût de la gestion de l'identité et empêche l'utilisation de faux documents.
+L'identité décentralisée permet aux entreprises de se dispenser des processus conventionnels de type [Connaissance du client (KYC)](https://en.wikipedia.org/wiki/Know_your_customer) et d'authentifier l'identité des utilisateurs via des informations d'identification vérifiables. Cela réduit le coût de la gestion de l'identité et empêche l'utilisation de faux documents.
 
-### 3. Votes et communautés en ligne {#voting-and-online-communities}
+### 3. Vote et communautés en ligne {#voting-and-online-communities}
 
 Le vote en ligne et les médias sociaux sont deux nouvelles applications de l'identité décentralisée. Les systèmes de vote en ligne sont susceptibles d'être manipulés, notamment si des acteurs malveillants créent de fausses identités pour voter. Demander aux personnes de présenter des attestations sur la chaîne peut améliorer l'intégrité des processus de vote en ligne.
 
 L'identité décentralisée peut contribuer à créer des communautés en ligne exemptes de faux comptes. Par exemple, chaque utilisateur pourrait devoir authentifier son identité à l'aide d'un système d'identité sur la chaîne, comme le service de nom Ethereum, ce qui réduirait les possibilités de bots.
 
-### 4. Protection anti-sybil {#sybil-protection}
+### 4. Protection anti-Sybil {#sybil-protection}
 
-Les applications d'attribution de subvention qui utilisent le [vote quadratique](/glossary/#quadratic-voting) sont vulnérables aux [attaques Sybil](/glossary/#sybil-attack) car la valeur d'une subvention augmente quand davantage de personnes votent pour elle, incitant les utilisateurs à répartir leurs contributions sur plusieurs identités. Les identités décentralisées permettent d'éviter cela en faisant peser sur chaque participant la charge de prouver qu'il est réellement humain, mais souvent sans avoir à révéler des informations privées spécifiques.
+Les applications de subvention qui utilisent le [vote quadratique](/glossary/#quadratic-voting) sont vulnérables aux [attaques Sybil](/glossary/#sybil-attack) parce que la valeur d'une subvention augmente lorsque plus d'individus votent pour elle, ce qui incite les utilisateurs à répartir leurs contributions sur plusieurs identités. Les identités décentralisées permettent d'éviter cela en faisant peser sur chaque participant la charge de prouver qu'il est réellement humain, mais souvent sans avoir à révéler des informations privées spécifiques.
+
+### 5. Identité nationale et gouvernementale {#national-and-government-id}
+
+Les gouvernements peuvent utiliser les principes de l'identité décentralisée pour émettre des documents d'identité fondamentaux – tels que des cartes d'identité nationales, des passeports ou des permis de conduire – sous forme d'informations d'identification vérifiables sur Ethereum, offrant de solides garanties cryptographiques d'authenticité pour réduire la fraude et la falsification lors de la vérification d'identité en ligne. Les citoyens peuvent stocker ces attestations dans leur [portefeuille](/wallets/) personnel et les utiliser pour prouver leur identité, leur âge ou leur droit de vote.
+
+Ce modèle permet une divulgation sélective, en particulier lorsqu'il est combiné avec la technologie de confidentialité de la [preuve à divulgation nulle de connaissance (ZKP)](/zero-knowledge-proofs/). Par exemple, un citoyen pourrait prouver par cryptographie qu'il a plus de 18 ans pour accéder à un service réservé aux personnes d'un certain âge sans révéler sa date de naissance exacte, offrant ainsi une plus grande confidentialité qu'une pièce d'identité traditionnelle.
+
+#### 💡Étude de cas : Identité numérique nationale (NDI) du Bhoutan sur Ethereum {#case-study-bhutan-ndi}
+
+- Fournit un accès à des informations d'identification vérifiables pour près de 800 000 citoyens bhoutanais
+- Migration depuis le réseau Polygon [vers le réseau principal Ethereum](https://www.bhutanndi.com/article/bhutan-adopts-ethereum-for-national-identity-a-new-chapter-in-digital-sovereignty_2d0c7ec2-5605-4c42-b258-bd9361ae8878) en octobre 2025
+- Plus de [234 000 identités numériques](https://www.blockchain-council.org/blockchain/bhutan-uses-blockchain-in-digital-id-project/) émises en mars 2025
+
+Le Royaume du Bhoutan a [migré son système d'identité numérique nationale (NDI)](https://www.bhutanndi.com/article/bhutan-adopts-ethereum-for-national-identity-a-new-chapter-in-digital-sovereignty_2d0c7ec2-5605-4c42-b258-bd9361ae8878) vers Ethereum en octobre 2025. Basé sur les principes de l'identité décentralisée et de l'identité auto-souveraine, le système NDI du Bhoutan utilise des identifiants décentralisés et des informations d'identification vérifiables pour émettre des informations d'identification signées numériquement directement dans le portefeuille personnel d'un citoyen. En ancrant les preuves cryptographiques de ces informations d'identification sur Ethereum, le système garantit qu'elles sont authentiques, infalsifiables et peuvent être vérifiées par n'importe quelle partie sans interroger une autorité centrale.
+
+L'architecture du système met l'accent sur la confidentialité grâce à l'utilisation de la technologie de [preuve à divulgation nulle de connaissance (ZKP)](/zero-knowledge-proofs/). Cette implémentation de la « divulgation sélective » permet aux citoyens de prouver des faits spécifiques (par exemple, « J'ai plus de 18 ans » ou « Je suis citoyen ») pour accéder à des services sans révéler les données personnelles sous-jacentes, telles que leur numéro d'identification complet ou leur date de naissance exacte. Cela démontre une utilisation puissante et concrète d'Ethereum pour un système d'identification national sécurisé, centré sur l'utilisateur et respectueux de la vie privée.
+
+#### 💡Étude de cas : QuarkID de la ville de Buenos Aires sur la [Couche 2](/layer-2/) d'Ethereum ZKSync Era {#case-study-buenos-aires-quarkid}
+
+- A émis des informations d'identification décentralisées à plus de [3,6 millions d'utilisateurs](https://buenosaires.gob.ar/innovacionytransformaciondigital/miba-con-tecnologia-quarkid-la-ciudad-de-buenos-aires-incorporo) lors du lancement
+- QuarkID est un protocole open source reconnu comme un [bien public numérique](https://www.digitalpublicgoods.net/r/quarkid) dans le cadre des objectifs de développement durable de l'ONU
+- Met l'accent sur un modèle de « [gouvernement en tant qu'utilisateur](https://buenosaires.gob.ar/innovacionytransformaciondigital/miba-con-tecnologia-quarkid-la-ciudad-de-buenos-aires-incorporo) », où la ville ne possède pas le protocole, donnant aux citoyens la pleine propriété de leurs données et la confidentialité
+
+En 2024, le gouvernement de la ville de Buenos Aires (GCBA) a intégré QuarkID, le « cadre de confiance numérique » open source créé par le Secrétariat de l'innovation et de la transformation numérique du GCBA, dans miBA, l'application officielle de la ville permettant aux résidents d'accéder aux services gouvernementaux et aux documents officiels. Au lancement, tous les 3,6 millions et plus d'utilisateurs de miBA ont reçu des identités numériques décentralisées qui leur permettent de gérer et de partager des documents et certificats numériques vérifiables en chaîne, y compris des titres de citoyenneté, des certificats de naissance, de mariage et de décès, des dossiers fiscaux, des carnets de vaccination, et plus encore.
+
+Basé sur le réseau de [Couche 2](/layer-2/) d'Ethereum ZKSync Era, le système QuarkID utilise la technologie ZKP pour permettre aux citoyens de vérifier leurs informations d'identification personnelles en pair-à-pair via leurs appareils mobiles, sans exposer de données personnelles inutiles. Le programme met en évidence un modèle de « gouvernement en tant qu'utilisateur » dans lequel le GCBA agit comme un utilisateur du protocole QuarkID, open source et interopérable, plutôt que comme un propriétaire centralisé. Cette architecture compatible ZKP offre une fonctionnalité de confidentialité essentielle : aucun tiers, pas même le GCBA, ne peut suivre comment, quand ou pourquoi un citoyen utilise ses informations d'identification. Ce programme réussi offre aux citoyens une identité entièrement auto-souveraine et un contrôle total sur leurs données sensibles, le tout sécurisé par le réseau mondialement distribué d'Ethereum.
 
 ## Que sont les attestations ? {#what-are-attestations}
 
 Une attestation est une déclaration faite par une entité sur une autre entité. Si vous vivez aux États-Unis, le permis de conduire qui vous a été délivré par le Department of Motor Vehicles (ministère des véhicules à moteur) (une entité) atteste que vous (une autre entité) êtes légalement autorisé à conduire une voiture.
 
-Les attestations sont différentes des identifiants. Une attestation _contient_des identifiants pour référencer une identité particulière et émet une revendication à propos d'un attribut lié à cette identité. Ainsi, votre permis de conduire a des identifiants (nom, date de naissance, adresse) mais est aussi l'attestation de votre droit légal de conduire.
+Les attestations sont différentes des identifiants. Une attestation _contient_ des identifiants pour référencer une identité particulière, et fait une déclaration sur un attribut lié à cette identité. Ainsi, votre permis de conduire a des identifiants (nom, date de naissance, adresse) mais est aussi l'attestation de votre droit légal de conduire.
 
 ### Que sont les identifiants décentralisés ? {#what-are-decentralized-identifiers}
 
@@ -87,27 +113,27 @@ Les identificateurs traditionnels comme votre nom légal ou votre adresse de cou
 
 Des identifiants décentralisés sont émis, conservés et contrôlés par des individus. Un [compte Ethereum](/glossary/#account) est un exemple d'identifiant décentralisé. Vous pouvez créer autant de comptes que vous le souhaitez sans permission de personne et sans avoir à les stocker dans un registre central.
 
-Les identifiants décentralisés sont stockés sur des registres distribués ([blockchains](/glossary/#blockchain)) ou sur des réseaux [pair-à-pair](/glossary/#peer-to-peer-network). Cela rend les DID [mondialement uniques, solubles avec une haute disponibilité, et vérifiables cryptographiquement](https://w3c-ccg.github.io/did-primer/). Un identifiant décentralisé peut être associé à différentes entités, y compris les personnes, les organisations ou les institutions gouvernementales.
+Les identifiants décentralisés sont stockés sur des registres distribués ([blockchains](/glossary/#blockchain)) ou des [réseaux pair-à-pair](/glossary/#peer-to-peer-network). Cela rend les DID [uniques à l'échelle mondiale, résolvables avec une haute disponibilité et vérifiables par cryptographie](https://w3c-ccg.github.io/did-primer/). Un identifiant décentralisé peut être associé à différentes entités, y compris les personnes, les organisations ou les institutions gouvernementales.
 
-## Qu'est-ce qui rend possible les identifiants décentralisés ? {#what-makes-decentralized-identifiers-possible}
+## Qu'est-ce qui rend possible les identifiants décentralisés ? Qu'est-ce qui rend les identifiants décentralisés possibles ? {#what-makes-decentralized-identifiers-possible}
 
 ### 1. Cryptographie à clé publique {#public-key-cryptography}
 
 La cryptographie à clé publique est une mesure de sécurité de l'information qui génère une [clé publique](/glossary/#public-key) et une [clé privée](/glossary/#private-key) pour une entité. La [cryptographie](/glossary/#cryptography) à clé publique est utilisée dans les réseaux blockchain pour authentifier l'identité des utilisateurs et prouver la propriété des actifs numériques.
 
-Certains identifiants décentralisés, tels qu'un compte Ethereum, possèdent des clés publiques et privées. La clé publique identifie le contrôleur du compte, tandis que les clés privées peuvent signer et déchiffrer les messages pour ce compte. La cryptographie à clé publique fournit les preuves nécessaires pour authentifier les entités et empêcher l'usurpation d'identité et l'utilisation de fausses identités, en utilisant [des signatures cryptographiques](https://andersbrownworth.com/blockchain/public-private-keys/) pour vérifier toutes les demandes.
+Certains identifiants décentralisés, tels qu'un compte Ethereum, possèdent des clés publiques et privées. La clé publique identifie le contrôleur du compte, tandis que les clés privées peuvent signer et déchiffrer les messages pour ce compte. La cryptographie à clé publique fournit les preuves nécessaires pour authentifier les entités, empêcher l'usurpation d'identité et l'utilisation de fausses identités, en utilisant des [signatures cryptographiques](https://andersbrownworth.com/blockchain/public-private-keys/) pour vérifier toutes les déclarations.
 
-### 2. Stockage de données décentralisé {#decentralized-datastores}
+### 2. Magasins de données décentralisés {#decentralized-datastores}
 
 Une blockchain sert de registre de données vérifiable : un registre d'informations ouvert, dénué de confiance et décentralisé. L'existence de blockchains publiques élimine la nécessité de stocker des identifiants dans des registres centralisés.
 
 Si quelqu'un a besoin de confirmer la validité d'un identifiant décentralisé, il peut consulter la clé publique associée sur la blockchain. Cela diffère des identifiants traditionnels qui nécessitent l'authentification par des tiers.
 
-## Comment les identifiants et les attestations décentralisés permettent-ils une identité décentralisée ? {#how-decentralized-identifiers-and-attestations-enable-decentralized-identity}
+## Comment les identifiants et les attestations décentralisés permettent-ils une identité décentralisée ? Comment les identifiants et attestations décentralisés rendent-ils possible l'identité décentralisée ? {#how-decentralized-identifiers-and-attestations-enable-decentralized-identity}
 
 L'identité décentralisée est l'idée que les informations liées à l'identité doivent être autocontrôlées, privées et portables, les identifiants et les attestations décentralisés étant les principaux éléments constitutifs.
 
-Dans le contexte de l'identité décentralisée, les attestations (également connues sous le nom de [identifiants vérifiables](https://www.w3.org/TR/vc-data-model/)) sont des déclarations infalsifiables et vérifiables par cryptographie faites par l'émetteur. Chaque attestation ou identifiant vérifiable émis par une entité (par exemple, une organisation) est associé à son identité décentralisée (IDD).
+Dans le contexte de l'identité décentralisée, les attestations (également connues sous le nom d'[informations d'identification vérifiables](https://www.w3.org/TR/vc-data-model/)) sont des déclarations infalsifiables et vérifiables par cryptographie, faites par l'émetteur. Chaque attestation ou identifiant vérifiable émis par une entité (par exemple, une organisation) est associé à son identité décentralisée (IDD).
 
 Les IDD étant stockées sur la blockchain, n'importe qui peut vérifier la validité d'une attestation en recoupant l'IDD de l'émetteur sur Ethereum. Essentiellement, la blockchain Ethereum agit comme un répertoire mondial qui permet de vérifier les IDD associées à certaines entités.
 
@@ -119,11 +145,11 @@ Les identifiants décentralisés sont également essentiels pour protéger la co
 
 La façon dont les informations d'attestation sont stockées et récupérées dans un écosystème d'identité basé sur Ethereum est différente de la gestion d'identité traditionnelle. Voici un aperçu des différentes approches de l'émission, du stockage et de la vérification des attestations dans les systèmes d'identité décentralisés :
 
-### Attestations hors chaîne {#off-chain-attestations}
+### Attestations hors chaîne {#offchain-attestations}
 
 L'une des préoccupations liées au stockage des attestations sur la chaîne est qu'elles peuvent contenir des informations que les personnes souhaitent garder privées. La nature publique de la blockchain Ethereum rend peu attrayant le stockage de telles attestations.
 
-La solution consiste à délivrer des attestations, détenues par les utilisateurs en dehors de la chaîne dans des portefeuilles numériques, mais signées avec le DID de l'émetteur stocké sur la chaîne. Ces attestations sont encodées en [JSON Web Tokens](https://en.wikipedia.org/wiki/JSON_Web_Token) et contiennent la signature numérique de l'émetteur, ce qui permet une vérification facile des revendications hors chaîne.
+La solution consiste à délivrer des attestations, détenues par les utilisateurs en dehors de la chaîne dans des portefeuilles numériques, mais signées avec le DID de l'émetteur stocké sur la chaîne. Ces attestations sont encodées sous forme de [jetons web JSON](https://en.wikipedia.org/wiki/JSON_Web_Token) et contiennent la signature numérique de l'émetteur, ce qui permet de vérifier facilement les déclarations hors chaîne.
 
 Voici un scénario hypothétique pour expliquer les attestations hors de la chaîne :
 
@@ -133,13 +159,13 @@ Voici un scénario hypothétique pour expliquer les attestations hors de la cha
 
 ### Attestations hors chaîne avec accès persistant {#offchain-attestations-with-persistent-access}
 
-Dans ce cas, les attestations sont transformées en fichiers JSON et stockées hors chaîne ( idéalement sur une plateforme [de stockage cloud décentralisée](/developers/docs/storage/), telle que IPFS ou Swarm). Cependant, un [hachage](/glossary/#hash) du fichier JSON est stocké sur la chaîne et lié à un DID via un registre sur la chaîne. Le DID associé peut être soit celui de l'émetteur de l'attestation, soit celui du destinataire.
+Dans le cadre de cet arrangement, les attestations sont transformées en fichiers JSON et stockées hors chaîne (idéalement sur une plateforme de [stockage en nuage décentralisé](/developers/docs/storage/), comme IPFS ou Swarm). Cependant, un [hachage](/glossary/#hash) du fichier JSON est stocké en chaîne et lié à un DID via un registre en chaîne. Le DID associé peut être soit celui de l'émetteur de l'attestation, soit celui du destinataire.
 
 Cette approche permet aux attestations d'obtenir une persistance basée sur la blockchain, tout en conservant les informations relatives aux demandes de remboursement chiffrées et vérifiables. Elle permet également une divulgation sélective puisque le détenteur de la clé privée peut déchiffrer les informations.
 
-### Attestations sur la chaîne {#onchain-attestations}
+### Attestations en chaîne {#onchain-attestations}
 
-Les attestations sur la chaîne sont détenues dans des [contrats intelligents](/glossary/#smart-contract) sur la blockchain Ethereum. Le contrat intelligent (agissant comme un registre) associera une attestation à un identifiant décentralisé correspondant sur la chaîne (une clé publique).
+Les attestations en chaîne sont conservées dans des [contrats intelligents](/glossary/#smart-contract) sur la blockchain Ethereum. Le contrat intelligent (agissant comme un registre) associera une attestation à un identifiant décentralisé correspondant sur la chaîne (une clé publique).
 
 Voici un exemple pour montrer comment les attestations sur la chaîne pourraient fonctionner dans la pratique :
 
@@ -149,43 +175,44 @@ Voici un exemple pour montrer comment les attestations sur la chaîne pourraient
 
 3. Le contrat intelligent qui vend des actions peut vérifier dans le contrat de registre l'identité des acheteurs sélectionnés, ce qui permet au contrat intelligent de déterminer qui est autorisé à acheter des actions ou non.
 
-### Jetons d'âme et identité {#soulbound}
+### Jetons Soulbound et identité {#soulbound}
 
-Les [jetons d'âmes](https://vitalik.eth.limo/general/2022/01/26/soulbound.html) ([NFT non transférables](/glossary/#nft)) pourraient être utilisés pour collecter des informations propres à un portefeuille spécifique. Cela crée effectivement une identité unique sur la chaîne, liée à une adresse Ethereum particulière, qui peut inclure des jetons représentant des réalisations (par exemple, terminer un cours en ligne spécifique ou atteindre un score seuil dans un jeu) ou la participation à une communauté.
+Les [jetons Soulbound](https://vitalik.eth.limo/general/2022/01/26/soulbound.html) ([NFT non transférables](/glossary/#nft)) pourraient être utilisés pour collecter des informations uniques à un portefeuille spécifique. Cela crée de fait une identité en chaîne unique liée à une adresse Ethereum particulière qui pourrait inclure des jetons représentant des réussites (par exemple, terminer un cours en ligne spécifique ou dépasser un score seuil dans un jeu) ou la participation à la communauté.
 
-## Utiliser une identité décentralisée {#use-decentralized-identity}
+## Utiliser l'identité décentralisée {#use-decentralized-identity}
 
 Il existe de nombreux projets ambitieux utilisant Ethereum comme base pour des solutions d'identité décentralisée :
 
-- **[Ethereum Name Service (ENS)](https://ens.domains/)** - _Un système de nommage décentralisé pour les identifiants sur la chaîne, lisibles par machine, tels que les adresses de portefeuilles Ethereum, les hachages de contenu et les métadonnées._
-- **[SprunceID](https://www.spruceid.com/)** - _Un projet d'identité décentralisé qui permet aux utilisateurs de contrôler leur identité numérique avec des comptes Ethereum et des profils ENS au lieu de s'appuyer sur des services tiers._
-- **[Ethereum Attestation Service (EAS)](https://attest.sh/)** - _Un registre/protocole décentralisé pour faire des attestations en chaîne ou hors chaîne sur quoi que ce soit._
-- **[Preuve d'humanité](https://www.proofofhumanity.id)** - _Preuve d'humanité (ou PoH) est un système de vérification d'identité sociale construit sur Ethereum._
-- **[BrightID](https://www.brightid.org/)** - _Un réseau d'identité sociale décentralisé et open-source qui cherche à réformer la vérification d'identité par la création et l'analyse d'un graphe social._
-- **[walt.id](https://walt.id)** — _Infrastructure décentralisée et open source d'identité et de portefeuille qui permet aux développeurs et aux organisations de tirer parti de l'identité souveraine et des NFT/SBT._
-- **[Veramo](https://veramo.io/)** - _Un environnement JavaScript qui permet à chacun d'utiliser facilement des données vérifiables cryptographiquement dans ses applications._
+- **[Ethereum Name Service (ENS)](https://ens.domains/)** – _Un système de nommage décentralisé pour les identifiants en chaîne lisibles par machine, comme les adresses de portefeuille Ethereum, les hachages de contenu et les métadonnées._
+- **[Se connecter avec Ethereum (SIWE)](https://siwe.xyz/)** – _Norme ouverte pour l'authentification avec les comptes Ethereum._
+- **[SpruceID](https://www.spruceid.com/)** – _Un projet d'identité décentralisée qui permet aux utilisateurs de contrôler leur identité numérique avec des comptes Ethereum et des profils ENS au lieu de dépendre de services tiers._
+- **[Ethereum Attestation Service (EAS)](https://attest.org/)** – _Un registre/protocole décentralisé pour faire des attestations en chaîne ou hors chaîne sur n'importe quel sujet._
+- **[Proof of Humanity](https://www.proofofhumanity.id)** – _Proof of Humanity (ou PoH) est un système de vérification d'identité sociale construit sur Ethereum._
+- **[BrightID](https://www.brightid.org/)** – _Un réseau d'identité sociale décentralisé et open source qui cherche à réformer la vérification d'identité par la création et l'analyse d'un graphe social._
+- **[walt.id](https://walt.id)** — _Infrastructure d'identité et de portefeuille décentralisée et open source qui permet aux développeurs et aux organisations d'exploiter l'identité auto-souveraine et les NFT/SBT._
+- **[Veramo](https://veramo.io/)** – _Un framework JavaScript qui permet à quiconque d'utiliser facilement des données vérifiables par cryptographie dans ses applications._
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 ### Articles {#articles}
 
-- [Cas d'utilisation de la Blockchain : Blockchain en identité numérique](https://consensys.net/blockchain-use-cases/digital-identity/) — _ConsensusSys_
-- [Qu'est-ce qu'Ethereum ERC725 ? Gestion des identités autonomes sur la Blockchain](https://cryptoslate.com/what-is-erc725-self-sovereign-identity-management-on-the-blockchain/) — _Sam Town_
-- [Comment la Blockchain pourrait-elle résoudre le problème de l'identité numérique](https://time.com/6142810/proof-of-humanity/) — _Andrew R. Chow_
-- [Qu'est-ce que l'identité décentralisée et pourquoi devriez-vous vous en préocupper ?](https://web3.hashnode.com/what-is-decentralized-identity) — _Emmanuel Awosika_
-- [Introduction à l'Identité Décentralisée](https://walt.id/white-paper/digital-identity)— _Dominik Beron_
+- [Blockchain Use Cases: Blockchain in Digital Identity](https://consensys.net/blockchain-use-cases/digital-identity/) — _ConsenSys_
+- [What is Ethereum ERC725? Self-Sovereign Identity Management on the Blockchain](https://cryptoslate.com/what-is-erc725-self-sovereign-identity-management-on-the-blockchain/) — _Sam Town_
+- [How Blockchain Could Solve the Problem of Digital Identity](https://time.com/6142810/proof-of-humanity/) — _Andrew R. Chow_
+- [What Is Decentralized Identity And Why Should You Care?](https://web3.hashnode.com/what-is-decentralized-identity) — _Emmanuel Awosika_
+- [Introduction to Decentralized Identity](https://walt.id/white-paper/digital-identity) — _Dominik Beron_
 
 ### Vidéos {#videos}
 
-- [Identité décentralisée (Bonus Session Livestream)](https://www.youtube.com/watch?v=ySHNB1za_SE&t=539s) — _Une formidable vidéo explicative sur l'identité décentralisée par Andreas Antonopolous_
-- [Connexion avec Ethereum et Decentralized Identity avec Ceramic, IDX, React, et 3ID Connect](https://www.youtube.com/watch?v=t9gWZYJxk7c) — _tutoriel YouTube sur la création d'un système de gestion d'identité pour créer, lire et mettre à jour un profil d'utilisateur en utilisant son portefeuille Ethereum par Nader Dabit_
-- [BrightID - Identité décentralisée sur Ethereum](https://www.youtube.com/watch?v=D3DbMFYGRoM) — _Épisode de podcast non bancaire parlant de BrightID, une solution d'identité décentralisée pour Ethereum_
-- [The Off Chain Internet : Identités décentralisées & Références vérifiables](https://www.youtube.com/watch?v=EZ_Bb6j87mg) — Présentation EthDenver 2022 par Evin McMullen
-- [Explication des Justificatifs Vérifiables](https://www.youtube.com/watch?v=ce1IdSr-Kig) - Vidéo explicative sur YouTube avec démonstration par Tamino Baumann
+- [Decentralized Identity (Bonus Livestream Session)](https://www.youtube.com/watch?v=ySHNB1za_SE&t=539s) — _Une excellente vidéo explicative sur l'identité décentralisée par Andreas Antonopolous_
+- [Sign In with Ethereum and Decentralized Identity with Ceramic, IDX, React, and 3ID Connect](https://www.youtube.com/watch?v=t9gWZYJxk7c) — _Tutoriel YouTube sur la création d'un système de gestion d'identité pour créer, lire et mettre à jour le profil d'un utilisateur à l'aide de son portefeuille Ethereum par Nader Dabit_
+- [BrightID - Decentralized Identity on Ethereum](https://www.youtube.com/watch?v=D3DbMFYGRoM) — _Épisode du podcast Bankless discutant de BrightID, une solution d'identité décentralisée pour Ethereum_
+- [The Offchain Internet: Decentralized Identity & Verifiable Credentials](https://www.youtube.com/watch?v=EZ_Bb6j87mg) — Présentation à EthDenver 2022 par Evin McMullen
+- [Verifiable Credentials Explained](https://www.youtube.com/watch?v=ce1IdSr-Kig) - Vidéo explicative YouTube avec une démonstration par Tamino Baumann
 
 ### Communautés {#communities}
 
-- [ERC-725 Alliance sur GitHub](https://github.com/erc725alliance) — _Supporters de la norme ERC725 pour la gestion d'identité sur la blockchain Ethereum_
-- [Serveur Discord EthID](https://discord.com/invite/ZUyG3mSXFD) — _Communauté pour les adeptes et les développeurs travaillant sur la connexion avec Ethereum_
-- [Veramo Labs](https://discord.gg/sYBUXpACh4) — _Une communauté de développeurs contribuant à la construction d'un framework de données vérifiables pour les applications_
-- [walt.id](https://discord.com/invite/AW8AgqJthZ) — _Une communauté de développeurs et constructeurs travaillant sur des cas d'utilisation d'identité décentralisée dans diverses industries._
+- [ERC-725 Alliance on GitHub](https://github.com/erc725alliance) — _Partisans de la norme ERC725 pour la gestion de l'identité sur la blockchain Ethereum_
+- [Serveur Discord EthID](https://discord.com/invite/ZUyG3mSXFD) — _Communauté pour les passionnés et les développeurs travaillant sur Se connecter avec Ethereum, et le protocole de suivi Ethereum_
+- [Veramo Labs](https://discord.gg/sYBUXpACh4) — _Une communauté de développeurs qui contribuent à la création d'un framework pour les données vérifiables pour les applications_
+- [walt.id](https://discord.com/invite/AW8AgqJthZ) — _Une communauté de développeurs et de créateurs travaillant sur des cas d'utilisation de l'identité décentralisée dans divers secteurs_
diff --git a/public/content/translations/fr/defi/index.md b/public/content/translations/fr/defi/index.md
index 829b566a078..48728650f68 100644
--- a/public/content/translations/fr/defi/index.md
+++ b/public/content/translations/fr/defi/index.md
@@ -1,16 +1,16 @@
 ---
-title: Finance Décentralisée (DeFi)
-metaTitle: Qu'est-ce que DeFi ? | Avantages et utilisation de la finance décentralisée
-description: Un aperçu de la DeFi sur Ethereum
+title: "Finance Décentralisée (DeFi)"
+metaTitle: "Qu'est-ce que DeFi ? | Avantages et utilisation de la finance décentralisée"
+description: "Un aperçu de la DeFi sur Ethereum"
 lang: fr
 template: use-cases
 emoji: ":money_with_wings:"
 image: /images/use-cases/defi.png
 alt: Un logo Eth fait en briques lego.
 sidebarDepth: 2
-summaryPoint1: Une alternative mondiale ouverte au système financier actuel.
-summaryPoint2: Des produits qui vous permettent d'emprunter, d'épargner, d'investir, d'échanger et plus encore.
-summaryPoint3: Basé sur une technologie open-source avec laquelle n'importe qui peut programmer.
+summaryPoint1: "Une alternative mondiale ouverte au système financier actuel."
+summaryPoint2: "Des produits qui vous permettent d'emprunter, d'épargner, d'investir, d'échanger et plus encore."
+summaryPoint3: "Basé sur une technologie open-source avec laquelle n'importe qui peut programmer."
 ---
 
 La DeFi est un système financier ouvert et mondial conçu pour l'ère de l'internet - une alternative à un système opaque, contrôlé rigoureusement et maintenu par des infrastructures et des processus vieux de plusieurs décennies. Il vous donne le contrôle et la visibilité de votre argent. Il vous offre une exposition aux marchés mondiaux et des alternatives à vos options bancaires ou monétaires locales. Les produits DeFi ouvrent des services financiers à toute personne disposant d'une connexion Internet et ils sont en grande partie la propriété de leurs utilisateurs. Jusqu'à présent, des dizaines de milliards de dollars de cryptomonnaies ont coulé à travers des applications DeFi et ils se développent chaque jour.
@@ -32,44 +32,44 @@ L'une des meilleures façons de voir le potentiel de la DeFi est de comprendre l
 - Les services financiers peuvent vous empêcher d'être payé.
 - Des frais cachés de services financiers sont vos données personnelles.
 - Les gouvernements et les institutions centralisées peuvent fermer les marchés à volonté.
-- Les heures de trading sont souvent limitées aux heures de bureau sur un fuseau horaire spécifique.
+- Les heures de trading sont souvent limitées aux heures de bureau d'un fuseau horaire spécifique.
 - Les transferts d'argent peuvent prendre des jours en raison de processus humains internes.
 - Il y a une prime pour les services financiers parce que les institutions intermédiaires ont besoin de leur part.
 
 ### Une comparaison {#defi-comparison}
 
-| DeFi                                                                                                                                   | La finance traditionnelle                                                                                                                                   |
-| -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Vous détenez votre argent.                                                                                                             | Votre argent est détenu par des entreprises.                                                                                                                |
-| Vous contrôlez où va votre argent et comment il est dépensé.                                                                           | Vous devez faire confiance à des entreprises pour ne pas mal gérer votre argent, comme prêter à des emprunteurs risqués.                                    |
-| Les transferts de fonds se font en quelques minutes.                                                                                   | Les paiements peuvent prendre des jours en raison de processus manuels.                                                                                     |
-| L'activité de la transaction est anonyme                                                                                               | L'activité financière est étroitement associée à votre identité.                                                                                            |
-| La DeFi est ouverte à tout le monde.                                                                                                   | Vous devez faire une demande pour utiliser les services financiers.                                                                                         |
-| Les marchés sont toujours ouverts.                                                                                                     | Les marchés ferment parce que les employés ont besoin de pauses.                                                                                            |
+| DeFi                                                                                                                                                   | La finance traditionnelle                                                                                                                                                                   |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Vous détenez votre argent.                                                                                                             | Votre argent est détenu par des entreprises.                                                                                                                                |
+| Vous contrôlez où va votre argent et comment il est dépensé.                                                                           | Vous devez faire confiance à des entreprises pour ne pas mal gérer votre argent, comme prêter à des emprunteurs risqués.                                                    |
+| Les transferts de fonds se font en quelques minutes.                                                                                   | Les paiements peuvent prendre des jours en raison de processus manuels.                                                                                                     |
+| L'activité de la transaction est pseudonyme                                                                                                               | L'activité financière est étroitement associée à votre identité.                                                                                                            |
+| La DeFi est ouverte à tout le monde.                                                                                                   | Vous devez faire une demande pour utiliser les services financiers.                                                                                                         |
+| Les marchés sont toujours ouverts.                                                                                                     | Les marchés ferment parce que les employés ont besoin de pauses.                                                                                                            |
 | Il est construit sur la transparence – tout le monde peut regarder les données d'un produit et inspecter le fonctionnement du système. | Les institutions financières sont des livres fermés : vous ne pouvez pas demander à voir leurs antécédents de prêts, un dossier de leurs actifs gérés, etc. |
 
 <ButtonLink href="/apps/categories/defi">
-  Explorer la DeFi
+  Explorer les applications DeFi
 </ButtonLink>
 
 ## Et si on commençait avec Bitcoin... {#bitcoin}
 
 Bitcoin à bien des égards a été la première application de la DeFi. Bitcoin vous permet de posséder et de contrôler la valeur et de l'envoyer partout dans le monde. Il le fait en fournissant un moyen à un grand nombre de personnes, qui ne se font pas confiance les unes aux autres, de se mettre d'accord sur un grand livre de comptes sans avoir besoin d'un intermédiaire de confiance. Le Bitcoin est ouvert à tout le monde et personne n'a l'autorité nécessaire pour modifier ses règles. Les règles du Bitcoin, comme sa rareté et son ouverture, sont inscrites dans la technologie. Ce n'est pas comme la finance traditionnelle où les gouvernements peuvent imprimer de l'argent qui déprécie vos épargnes et où les entreprises peuvent fermer les marchés.
 
-L'Ethereum s'appuie sur cela. Comme le Bitcoin, les règles ne peuvent pas changer et tout le monde y a accès. Mais cela rend aussi cet argent numérique programmable, en utilisant des [contrats intelligents](/glossary/#smart-contract), vous pouvez donc aller au-delà du stockage et de la valeur d'envoi.
+L'Ethereum s'appuie sur cela. Comme le Bitcoin, les règles ne peuvent pas changer et tout le monde y a accès. Mais cela rend également cette monnaie numérique programmable à l'aide de [contrats intelligents](/glossary/#smart-contract), ce qui permet d'aller au-delà du simple stockage et envoi de valeur.
 
 <YouTube id="qFBYB4W2tqU" />
 
 ## Monnaie programmable {#programmable-money}
 
-Cela semble étrange... « pourquoi je voudrais programmer mon argent » ? Cependant, il s'agit plutôt d'une fonctionnalité par défaut des jetons sur Ethereum. N'importe qui peut programmer une logique de paiement. Ainsi, vous pouvez obtenir le contrôle et la sécurité de Bitcoin mélangés avec les services fournis par les institutions financières. Cela vous permet de faire des choses avec des cryptomonnaies que vous ne pouvez pas faire avec des Bitcoins comme des prêts et des emprunts, des paiements, des investissements dans des fonds d'indice et plus encore.
+Cela semble étrange... « pourquoi voudrais-je programmer mon argent » ? Cependant, il s'agit plutôt d'une fonctionnalité par défaut des jetons sur Ethereum. N'importe qui peut programmer une logique de paiement. Ainsi, vous pouvez obtenir le contrôle et la sécurité de Bitcoin mélangés avec les services fournis par les institutions financières. Cela vous permet de faire des choses avec des cryptomonnaies que vous ne pouvez pas faire avec des Bitcoins comme des prêts et des emprunts, des paiements, des investissements dans des fonds d'indice et plus encore.
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
-<AlertContent className="justify-between flex-row items-center">
+<AlertContent className="flex-row justify-between items-center">
   <div>Explorez nos suggestions pour les applications de la DeFi pour essayer si vous êtes nouveau sur Ethereum.</div>
   <ButtonLink href="/apps/categories/defi">
-    Explorer la DeFi
+    Explorer les applications DeFi
   </ButtonLink>
 </AlertContent>
 </Alert>
@@ -78,37 +78,37 @@ Cela semble étrange... « pourquoi je voudrais programmer mon argent » ? Cepen
 
 Il existe une alternative décentralisée à la plupart des services financiers. Mais Ethereum crée également des opportunités de création de produits financiers totalement nouveaux. Cette liste ne cesse de croître.
 
-- [Envoyer de l'argent partout dans le monde](#send-money)
-- [Diffuser de l'argent dans le monde entier](#stream-money)
-- [Accéder aux devises stables](#stablecoins)
+- [Envoyer de l'argent dans le monde entier](#send-money)
+- [Transférer de l'argent en continu dans le monde entier](#stream-money)
+- [Accéder à des monnaies stables](#stablecoins)
 - [Emprunter des fonds avec garantie](#lending)
 - [Emprunter sans garantie](#flash-loans)
-- [Démarrer des économies de cryptomonnaies](#saving)
+- [Commencer à épargner en cryptomonnaies](#saving)
 - [Échanger des jetons](#swaps)
-- [Développer votre portefeuille](#investing)
+- [Faire fructifier votre portefeuille](#investing)
 - [Financer vos idées](#crowdfunding)
-- [Acheter une assurance](#insurance)
+- [Souscrire une assurance](#insurance)
 - [Gérer votre portefeuille](#aggregators)
 
 <Divider />
 
-### Envoyer de l'argent partout dans le monde rapidement {#send-money}
+### Envoyer de l'argent rapidement dans le monde entier {#send-money}
 
-En tant que blockchain, Ethereum est conçu pour envoyer des transactions de manière sécurisée et globale. Tout comme Bitcoin, Ethereum vous permet d'envoyer de l'argent dans le monde entier aussi facilement qu'un un email. Entrez simplement le nom [ENS de votre destinataire](/glossary/#ens) (comme bob. th) ou l'adresse de leur compte à partir de votre portefeuille et votre paiement leur ira directement, en quelques minutes (habituellement). Pour envoyer ou recevoir des paiements, vous aurez besoin d'un [portefeuille](/wallets/).
+En tant que blockchain, Ethereum est conçu pour envoyer des transactions de manière sécurisée et globale. Tout comme Bitcoin, Ethereum vous permet d'envoyer de l'argent dans le monde entier aussi facilement qu'un un email. Saisissez simplement le [nom ENS](/glossary/#ens) de votre destinataire (comme bob.eth) ou l'adresse de son compte depuis votre portefeuille et votre paiement lui parviendra directement en quelques minutes (généralement). Pour envoyer ou recevoir des paiements, vous aurez besoin d'un [portefeuille](/wallets/).
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les applications de paiement
+  Voir les dapps de paiement
 </ButtonLink>
 
 #### Diffuser de l'argent partout dans le monde... {#stream-money}
 
 Vous pouvez également diffuser de l'argent sur Ethereum. Cela vous permet de payer à quelqu'un son salaire en une seconde, lui donnant accès, ainsi, à son argent chaque fois qu'il en a besoin. Ou louer quelque chose presque instantanément comme un casier de stockage ou scooter électrique par exemple.
 
-Et si vous ne voulez pas envoyer ou diffuser des [ETH](/glossary/#ether) en raison de sa volatilité, il existe des devises alternatives sur Ethereum : les [stablecoins](/glossary/#stablecoin).
+Et si vous ne voulez pas envoyer ou streamer de l'[ETH](/glossary/#ether) en raison des fluctuations de sa valeur, il existe des monnaies alternatives sur Ethereum : les [stablecoins](/glossary/#stablecoin).
 
 <Divider />
 
-### Accéder aux monnaies stables {#stablecoins}
+### Accéder à des monnaies stables {#stablecoins}
 
 La volatilité des cryptomonnaies est un problème pour de nombreux produits financiers et les dépenses en générales. La communauté de la DeFi a résolu cela avec des stablecoins. Leur valeur reste indexée sur un autre actif, généralement une devise populaire comme le dollar par exemple.
 
@@ -120,7 +120,7 @@ Les pièces comme Dai ou USDC ont une valeur qui reste stable à quelques centim
 
 <Divider />
 
-### Emprunter {#lending}
+### Emprunt {#lending}
 
 L'emprunt de l'argent auprès de prestataires décentralisés se compose de deux variétés principales.
 
@@ -128,28 +128,28 @@ L'emprunt de l'argent auprès de prestataires décentralisés se compose de deux
 - Basé sur une pool où les prêteurs fournissent des fonds (liquidités) à une réserve dans laquelle les emprunteurs peuvent emprunter.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les dapp d'emprunt
+  Voir les dapps d'emprunt
 </ButtonLink>
 
 Il y a de nombreux avantages à utiliser un prêteur décentralisé...
 
-#### Emprunter avec confidentialité {#borrowing-privacy}
+#### Emprunter en toute confidentialité {#borrowing-privacy}
 
 Aujourd'hui, le prêt et l'emprunt d'argent tournent autour des personnes impliquées. Les banques doivent savoir si vous êtes susceptible de rembourser un prêt avant de le prêter.
 
-Les prêts décentralisés fonctionnent sans que l’une ou l’autre des parties n’ait à s’identifier. Au lieu de cela, l'emprunteur doit placer une garantie que le prêteur recevra automatiquement si leur prêt n'est pas remboursé. Certains prêteurs acceptent même les [NFT](/glossary/#nft) comme garanties. Les NFT sont un acte de propriété unique, comme une peinture par exemple. [Plus de détails sur les NFT](/nft/)
+Les prêts décentralisés fonctionnent sans que l’une ou l’autre des parties n’ait à s’identifier. Au lieu de cela, l'emprunteur doit placer une garantie que le prêteur recevra automatiquement si leur prêt n'est pas remboursé. Certains prêteurs acceptent même les [NFT](/glossary/#nft) comme garantie. Les NFT sont un acte de propriété unique, comme une peinture par exemple. [En savoir plus sur les NFT](/nft/)
 
 Cela vous permet d'emprunter de l'argent sans chèques d'acompte et sans remise d'informations privées.
 
 #### Accès aux fonds mondiaux {#access-global-funds}
 
-Lorsque vous utilisez un prêteur décentralisé, vous avez accès aux fonds déposés du monde entier, pas seulement les fonds détenus par la banque ou l'institution que vous avez choisie. Cela rend les prêts plus accessibles et améliore les taux d'intérêt.
+Lorsque vous utilisez un prêteur décentralisé, vous avez accès aux fonds déposés du monde entier, pas seulement les fonds détenus par la banque ou l'institution que vous avez choisie. Cela rend les prêts plus accessibles et améliore les taux d’intérêt.
 
-#### Efficacité fiscale {#tax-efficiencies}
+#### Optimisations fiscales {#tax-efficiencies}
 
-L’emprunt peut vous donner accès aux fonds dont vous avez besoin sans devoir vendre votre ETH (un événement imposable). Au lieu de cela, vous pouvez utiliser ETH comme garantie pour un prêt stablecoin. Cela vous donne le flux de trésorerie dont vous avez besoin et vous permet de garder votre ETH. Les Stablecoins sont des jetons qui sont beaucoup plus intéressant quand vous avez besoin d'argent car ils ne fluctuent pas en valeur comme ETH. [Plus d'infos sur les stablecoins](#stablecoins)
+L’emprunt peut vous donner accès aux fonds dont vous avez besoin sans devoir vendre votre ETH (un événement imposable). Au lieu de cela, vous pouvez utiliser ETH comme garantie pour un prêt stablecoin. Cela vous donne le flux de trésorerie dont vous avez besoin et vous permet de garder votre ETH. Les Stablecoins sont des jetons qui sont beaucoup plus intéressant quand vous avez besoin d'argent car ils ne fluctuent pas en valeur comme ETH. [En savoir plus sur les stablecoins](#stablecoins)
 
-#### Prêts Flash {#flash-loans}
+#### Prêts instantanés {#flash-loans}
 
 Les prêts Flash sont une forme plus expérimentale de prêt décentralisé qui vous permet d'emprunter sans garantie ou sans fournir de renseignements personnels.
 
@@ -173,12 +173,12 @@ Si l'échange B chutait soudainement et que l'utilisateur n'était pas en mesure
 Pour pouvoir faire ce qui précède dans le monde de la finance traditionnelle, vous auriez besoin d'une somme d'argent énorme. Ces stratégies pour gagner de l'argent ne sont accessibles qu'à ceux qui possèdent déjà une certaine richesse. Les prêts Flash sont un exemple d'avenir où avoir de l'argent n'est pas nécessairement une condition préalable pour gagner de l'argent.
 
 <ButtonLink isSecondary href="https://aave.com/docs/aave-v3/guides/flash-loans">
-  Plus d'infos sur les prêts Flash
+  En savoir plus sur les prêts instantanés
 </ButtonLink>
 
 <Divider />
 
-### Commencez à épargner avec des cryptomonnaies {#saving}
+### Commencer à épargner en cryptomonnaies {#saving}
 
 #### Prêt {#lending}
 
@@ -186,14 +186,14 @@ Vous pouvez gagner de l'intérêt sur votre cryptomonnaie en le prêtant et en v
 
 - Vous prêtez vos 100 Dai, un [stablecoin](/stablecoins/), à un produit comme Aave.
 - Vous recevez 100 Aave Dai (aDai), ce qui représente votre Dai prêté.
-- Votre aDai augmentera en fonction des taux d'intérêt et vous pourrez ainsi voir votre solde croître dans votre portefeuille. Dépendant de [l'APR](/glossary/#apr), le solde de votre portefeuille va afficher quelque chose comme 100,1234 après quelques jours ou même quelques heures !
+- Votre aDai augmentera en fonction des taux d'intérêt et vous pourrez ainsi voir votre solde croître dans votre portefeuille. En fonction de l'[APR](/glossary/#apr), le solde de votre portefeuille affichera quelque chose comme 100,1234 après quelques jours ou même quelques heures !
 - Vous pouvez retirer un montant de Dai égal à votre solde aDai à tout moment.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les dApps de prêt
+  Voir les dapps de prêt
 </ButtonLink>
 
-#### Loteries sans risque {#no-loss-lotteries}
+#### Loteries sans perte {#no-loss-lotteries}
 
 Les Loteries sans risque comme PoolTogether sont un moyen amusant et innovant d'épargner de l'argent.
 
@@ -218,36 +218,36 @@ Il existe des milliers de jetons sur Ethereum. Les échanges décentralisés (DE
 Par exemple, si vous voulez vous lancer dans une loterie sans risque (décrite au dessus), vous aurez besoin de jeton comme les Dai ou USDC. Les DEXs vous permettent d'échanger vos ETH avec des tokens, et de les reconvertir en ETH lorsque vous avez terminé.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir échanger des jetons
+  Voir les plateformes d'échange de jetons
 </ButtonLink>
 
 <Divider />
 
-### Échanges avancés {#trading}
+### Trading avancé {#trading}
 
 Pour les traders qui aiment le contrôle, il existe des options avancées. Les ordres à cours limités, échanges perpétuels, le trading sur marge sont tous possibles. Avec le trading décentralisé, vous avez accès à des liquidités dans le monde entier, le marché est toujours ouvert et vous gardez à tout moment le contrôle sur vos actifs.
 
 Avec le trading centralisé, vous devez déposer vos actifs avant les échanges et faire confiance à un tier pour en prendre soin. Lorsqu'ils sont déposés, vos actifs courent un risque par ce que les centres d'échange sont des cibles très attractives pour les hackers.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir Applications décentralisées (dapps)
+  Voir les dapps de trading
 </ButtonLink>
 
 <Divider />
 
-### Développer votre Portefeuille {#investing}
+### Faire fructifier votre portefeuille {#investing}
 
 Il existe des outils de gestion de fonds sur Ethereum qui vous permettront de développer votre portefeuille en vous appuyant sur la stratégie de votre choix. C'est automatique, ouvert à tous, et personne ne pourra vous demander de commission.
 
-Voilà un bon exemple [DeFi Pulse Index fund (DPI)](https://defipulse.com/blog/defi-pulse-index/). C'est un fonds qui se rééquilibre automatiquement pour garantir qu'il inclue toujours les jetons DeFi ayant la meilleure capitalisation boursière. Pas besoin de gérer les détails et vous pouvez retirer les fonds quand bon vous semble.
+Un bon exemple est le [fonds indiciel DeFi Pulse (DPI)](https://defipulse.com/blog/defi-pulse-index/). C'est un fonds qui se rééquilibre automatiquement pour garantir qu'il inclue toujours les jetons DeFi ayant la meilleure capitalisation boursière. Pas besoin de gérer les détails et vous pouvez retirer les fonds quand bon vous semble.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les applications d'investissement dapps
+  Voir les dapps d'investissement
 </ButtonLink>
 
 <Divider />
 
-### Financer vos projets {#crowdfunding}
+### Financer vos idées {#crowdfunding}
 
 Ethereum est une plateforme idéale pour le crowdfunding:
 
@@ -256,12 +256,12 @@ Ethereum est une plateforme idéale pour le crowdfunding:
 - Les collecteurs de fonds peuvent mettre en place des remboursements automatiques. Par exemple si un montant minimum n'est pas atteint à la deadline du projet.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les dapps de crowdfunding
+  Voir les dapps de financement participatif
 </ButtonLink>
 
-#### Financements quadratiques {#quadratic-funding}
+#### Financement quadratique {#quadratic-funding}
 
-Ethereum est un logiciel open source, une grand partie du travail à été financée par la communauté. Cela a conduit à la croissance d'un nouveau modèle de collecte de fond : le financement quadratique. Ce modèle a le potentiel d'améliorer la façon dont nous finançons tous les types de biens publics à l'avenir.
+Ethereum est un logiciel open source, une grand partie du travail à été financée par la communauté. Cela a conduit à la croissance d'un nouveau modèle de collecte de fond : le financement quadratique. Ce modèle a le potentiel d'améliorer la façon dont nous finançons tous les types de bien publics à l'avenir.
 
 Le financement quadratique veille à ce que les projets qui reçoivent le plus de financement soient ceux dont la demande est la plus unique. En d'autres termes, des projets qui visent à améliorer la vie du plus grand nombre de personnes. Voici comment ça marche :
 
@@ -282,10 +282,10 @@ Cela veut dire qu'un projet A avec ses 100 donneurs de 1 dollar pourrait finir a
 
 L'assurance décentralisée vise à rendre l'assurance moins chère, plus rapide à rembourser et plus transparente. Avec davantage d'automatisation, la protection est plus abordable et les paiements sont beaucoup plus rapides. Les données utilisées pour décider de votre réclamation sont complètement transparentes.
 
-Les produits Ethereum, comme n'importe quel logiciel, peuvent souffrir de bugs et d'exploits. Actuellement, de nombreux produits d'assurance dans l'espace sont axés sur la protection de leurs utilisateurs contre la perte de fonds. Cependant, il y a des projets qui commencent à construire une couverture pour tous les événements de la vie. Un bon exemple de ceci est la couverture Etherisc's Crop qui vise à [protéger les petits agriculteurs kényans contre les sécheresses et les inondations](https://blog.etherisc.com/etherisc-teams-up-with-chainlink-to-deliver-crop-insurance-in-kenya-137e433c29dc). Les assurances décentralisées peuvent offrir une couverture moins chère aux agriculteurs qui n'ont souvent pas les moyens d'accéder aux assurances traditionnelles.
+Les produits Ethereum, comme n'importe quel logiciel, peuvent souffrir de bugs et d'exploits. Actuellement, de nombreux produits d'assurance dans l'espace sont axés sur la protection de leurs utilisateurs contre la perte de fonds. Cependant, il y a des projets qui commencent à construire une couverture pour tous les événements de la vie. Un bon exemple est l'assurance récolte d'Etherisc qui vise à [protéger les petits agriculteurs du Kenya contre les sécheresses et les inondations](https://blog.etherisc.com/etherisc-teams-up-with-chainlink-to-deliver-crop-insurance-in-kenya-137e433c29dc). Les assurances décentralisées peuvent offrir une couverture moins chère aux agriculteurs qui n'ont souvent pas les moyens d'accéder aux assurances traditionnelles.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les assurances Dapps
+  Voir les dapps d'assurance
 </ButtonLink>
 
 <Divider />
@@ -295,7 +295,7 @@ Les produits Ethereum, comme n'importe quel logiciel, peuvent souffrir de bugs e
 Avec tant de choses en cours, vous aurez besoin d'un moyen de suivre tous vos investissements, vos prêts et vos transactions. Il y a une foule de produits qui vous permettent de coordonner toutes vos activités de DeFi à partir d'un seul endroit. C'est la beauté de l'architecture ouverte de DeFi. Les équipes peuvent construire des interfaces où vous ne pouvez pas simplement voir vos balances entre produits mais également utiliser leurs fonctionnalités. Vous pourriez trouver cela utile en explorant plus à propos de la DeFi.
 
 <ButtonLink href="/apps/categories/defi">
-  Voir les dApps de portefeuille
+  Voir les dapps de portefeuille
 </ButtonLink>
 
 <Divider />
@@ -312,7 +312,7 @@ Les contrats sont également publics pour toute personne voulant l'inspecter et
 
 Cela signifie qu'il est actuellement nécessaire de faire confiance aux membres les plus avancés de la communauté Ethereum qui peuvent lire du code. La communauté open-source aide à contrôler les développeurs, mais ce besoin diminuera avec le temps à mesure que les contrats intelligents deviennent plus faciles à lire et que d'autres moyens de prouver la fiabilité du code sont développés.
 
-## Ethereum et DeFi {#ethereum-and-defi}
+## Ethereum et la DeFi {#ethereum-and-defi}
 
 Ethereum est la fondation parfaite pour la DeFi pour plusieurs raisons:
 
@@ -324,41 +324,42 @@ Ethereum est la fondation parfaite pour la DeFi pour plusieurs raisons:
 Vous pouvez voir la DeFi comme des couches :
 
 1. La Blockchain, Ethereum qui trace l'historique des transactions et les états de comptes.
-2. Les actifs [ETH](/what-is-ether/) et autres jetons (devises).
-3. Les protocoles, [contrats intelligents](/glossary/#smart-contract) qui offrent des fonctionnalités comme les prêts d'actifs décentralisés.
-4. [Les applications](/apps/) les produits que vous utilisez pour accéder et gérer les protocoles.
+2. Les actifs – l'[ETH](/what-is-ether/) et les autres jetons (monnaies).
+3. Les protocoles – les [contrats intelligents](/glossary/#smart-contract) qui fournissent la fonctionnalité, par exemple, un service qui permet le prêt décentralisé d'actifs.
+4. [Les applications](/apps/) – les produits que nous utilisons pour gérer et accéder aux protocoles.
 
-Note : Beaucoup de DeFi utilisent la [norme ERC-20](/glossary/#erc-20). Les applications de DeFi utilisent un "wrapper" pour l'ETH appelé Wrapped Ether (WETH). [En apprendre plus à propos de l'ether symbolique](/wrapped-eth).
+Remarque : une grande partie de la DeFi utilise la [norme ERC-20](/glossary/#erc-20). Les applications de DeFi utilisent un "wrapper" pour l'ETH appelé Wrapped Ether (WETH). [En savoir plus sur l'ether encapsulé](/wrapped-eth).
 
-## Fabriquer une DeFi {#build-defi}
+## Construire sur la DeFi {#build-defi}
 
 DeFi est un mouvement open source. Les protocoles et applications DeFi sont ouverts et libres pour que vous puissiez les inspecter, fouiller et innover dessus. Grâce à cette superposition (ils partagent tous la même Blockchain et les mêmes ressources de base), les protocoles peuvent être mélangés et assemblés pour créer des combos d'opportunités uniques.
 
 <ButtonLink href="/developers/docs/dapps/">
-  En savoir plus sur la fabrication de dapps
+  En savoir plus sur la création de dapps
 </ButtonLink>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 ### Données DeFi {#defi-data}
 
 - [DeFi Prime](https://defiprime.com/)
 - [DeFi Llama](https://defillama.com/)
 
-### Articles DeFi {#defi-articles}
+### Articles sur la DeFi {#defi-articles}
 
-- [Un guide de la DeFi pour débutants](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) - _Sid Coelho-Prabhu, 6 janvier 2020_
+- [Un guide du débutant sur la DeFi](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _Sid Coelho-Prabhu, 6 janvier 2020_
+- [Directives d'évaluation des risques de la DeFi de l'EEA](https://entethalliance.org/specs/defi-risks/) – Un aperçu soutenu par l'industrie sur la manière d'identifier et d'évaluer les risques clés dans les protocoles DeFi.
 
 ### Vidéos {#videos}
 
-- [Finematics - decentralized finance education](https://finematics.com/) _vidéos de DeFi_
-- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _Les bases de la DeFi : Tout ce que vous avez besoin de savoir pour commencer dans cet espace parfois déroutant_
-- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) _Qu'est-ce que DeFi?_
+- [Finematics - éducation sur la finance décentralisée](https://finematics.com/) – _Vidéos sur la DeFi_
+- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _Les bases de la DeFi : tout ce que vous devez savoir pour commencer dans cet espace parfois déroutant._
+- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) _Qu'est-ce que la DeFi ?_
 
 ### Communautés {#communities}
 
-- [Serveur Discord DeFi Llama](https://discord.defillama.com/)
-- [Serveur Discord DeFi Pulse](https://discord.gg/Gx4TCTk)
+- [Serveur Discord de DeFi Llama](https://discord.defillama.com/)
+- [Serveur Discord de DeFi Pulse](https://discord.gg/Gx4TCTk)
 
 <Divider />
 
diff --git a/public/content/translations/fr/desci/index.md b/public/content/translations/fr/desci/index.md
index c35b0c2e024..a25cefac5c1 100644
--- a/public/content/translations/fr/desci/index.md
+++ b/public/content/translations/fr/desci/index.md
@@ -1,57 +1,57 @@
 ---
-title: La science décentralisée (DeSci)
-description: Présentation de la science décentralisée sur Ethereum
+title: "La science décentralisée (DeSci)"
+description: "Présentation de la science décentralisée sur Ethereum"
 lang: fr
 template: use-cases
 emoji: ":microscope:"
 sidebarDepth: 2
 image: /images/future_transparent.png
 alt: ""
-summaryPoint1: Une alternative globale et ouverte au système scientifique actuel.
-summaryPoint2: Technologie qui permet aux scientifiques de recueillir des fonds, de mener des expériences, de partager des données, de diffuser des informations et plus encore.
-summaryPoint3: S'appuie sur le mouvement science en libre accès.
+summaryPoint1: "Une alternative globale et ouverte au système scientifique actuel. "
+summaryPoint2: "Technologie qui permet aux scientifiques de recueillir des fonds, de mener des expériences, de partager des données, de diffuser des informations et plus encore."
+summaryPoint3: "S'appuie sur le mouvement science en libre accès."
 ---
 
 ## Qu'est-ce que la science décentralisée (DeSci) ? {#what-is-desci}
 
-La science décentralisée (DeSci) est un mouvement qui vise à construire une infrastructure publique en vue du financement, de la création, de l'examen, de l'attribution de crédits, du stockage et de la diffusion des connaissances scientifiques de manière juste et équitable en utilisant la pile [Web3](/glossary/#web3).
+La science décentralisée (DeSci) est un mouvement qui vise à construire une infrastructure publique pour le financement, la création, l'examen, la crédibilisation, le stockage et la diffusion des connaissances scientifiques de manière juste et équitable en utilisant la pile [Web3](/glossary/#web3).
 
 La DeSci vise à créer un écosystème dans lequel les scientifiques sont incités à partager ouvertement leurs recherches et à être salués pour leurs travaux, tout en permettant à quiconque d'accéder et de contribuer facilement aux recherches. La DeSci part du principe que les connaissances scientifiques doivent être accessibles à tous et que le processus de recherche scientifique doit être transparent. La DeSci crée un modèle de recherche scientifique plus décentralisé et distribué, qui la rend plus résistante à la censure et au contrôle par les autorités centrales. La DeSci vise à créer un environnement où les idées nouvelles et non conventionnelles peuvent prospérer en décentralisant l’accès au financement, aux outils scientifiques et aux canaux de communication.
 
-La science décentralisée permet d'accéder à des sources de financement plus variées (des [DAO](/glossary/#dao), [dons quadratiques](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531) aux financements participatifs et plus encore), des données et méthodes d'accès plus accessibles, et incite à la reproductibilité.
+La science décentralisée permet des sources de financement plus diverses (des [DAO](/glossary/#dao) et des [dons quadratiques](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531) au financement participatif, et plus encore), des données et des méthodes plus accessibles, et incite à la reproductibilité.
 
 ### Juan Benet - Le Mouvement DeSci
 
 <YouTube id="5ORvbCIW39o" />
 
-## En quoi la DeSci fait avancer la science {#desci-improves-science}
+## Comment la DeSci améliore la science {#desci-improves-science}
 
 Liste non exhaustive des principaux problèmes rencontrés par la science et comment la science décentralisée peut aider à les résoudre
 
-| **La science décentralisée**                                                                                                                              | **La science traditionnelle**                                                                                                                  |
-| --------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| La répartition des fonds est **déterminée par le public** à l’aide de mécanismes tels que les dons quadratiques ou les DAO.                               | De petits **groupes centralisés** et fermés contrôlent la distribution des fonds.                                                              |
-| Vous collaborez avec des pairs du **monde entier** dans des équipes dynamiques.                                                                           | Les organismes de financement et les établissements d’origine **limitent** vos collaborations.                                                 |
-| Les décisions de financement sont prises en ligne et en toute **transparence**. De nouveaux mécanismes de financement sont explorés.                      | Les décisions de financement sont longues à prendre et la **transparence en la matière limitée**. Il existe peu de mécanismes de financement.  |
-| Partager des services de laboratoire devient plus facile et plus transparent en utilisant les technologies du [Web3](/glossary/#web3).                    | Le partage des ressources des laboratoires est souvent **lent et opaque**.                                                                     |
-| **De nouveaux modèles de publication** peuvent être développés en utilisant les primitives Web3 pour garantir confiance, transparence et accès universel. | Vous publiez par le biais de voies établies souvent considérées comme **inefficaces, partiales et basées sur l'exploitation**.                 |
-| Vous pouvez **gagner des jetons et consolider votre réputation en faisant un travail d'évaluation par les pairs**.                                        | Votre **travail d'évaluation par les pairs n'est pas rémunéré**, ce qui profite aux éditeurs à but lucratif.                                   |
-| **Vous êtes détenteur de la propriété intellectuelle (PI)** que vous créez et diffusez ces créations dans le respect de conditions transparentes.         | **Votre institution d'origine est propriétaire de la PI** que vous générez. L'accès à la PI n'est pas transparent.                             |
-| **Partagez toutes les recherches**, y compris les données issues de recherches infructueuses, en basculant toutes les étapes sur la chaîne.               | Le **biais de publication** veut que les chercheurs soient plus susceptibles de partager des expériences qui ont donné des résultats positifs. |
+| **La science décentralisée**                                                                                                                                              | **La science traditionnelle**                                                                                                                                                        |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| La distribution des fonds est **déterminée par le public** à l'aide de mécanismes tels que les dons quadratiques ou les DAO.                              | De petits groupes, fermés et **centralisés**, contrôlent la distribution des fonds.                                                                                  |
+| Vous collaborez avec des pairs du **monde entier** au sein d'équipes dynamiques.                                                                          | Les organismes de financement et les établissements d'origine **limitent** vos collaborations.                                                                       |
+| Les décisions de financement sont prises en ligne et **en toute transparence**. De nouveaux mécanismes de financement sont explorés.      | Les décisions de financement sont prises avec un long délai d'exécution et une **transparence limitée**. Il existe peu de mécanismes de financement. |
+| Le partage des services de laboratoire est facilité et plus transparent grâce à la technologie [Web3](/glossary/#web3).                                   | Le partage des ressources de laboratoire est souvent **lent et opaque**.                                                                                             |
+| **De nouveaux modèles de publication** peuvent être développés en utilisant les primitives Web3 pour garantir confiance, transparence et accès universel. | Vous publiez par des voies établies, fréquemment reconnues comme **inefficaces, partiales et abusives**.                                                             |
+| Vous pouvez **gagner des jetons et de la réputation en évaluant le travail de vos pairs**.                                                                | Votre **travail d'évaluation par les pairs n'est pas rémunéré**, ce qui profite aux éditeurs à but lucratif.                                                         |
+| **Vous êtes propriétaire de la propriété intellectuelle (PI)** que vous générez et la distribuez selon des conditions transparentes.   | **Votre établissement d'origine est propriétaire de la PI** que vous générez. L'accès à la PI n'est pas transparent.                                 |
+| **Partage de toutes les recherches**, y compris les données des tentatives infructueuses, en plaçant toutes les étapes sur la chaîne.                     | **Le biais de publication** signifie que les chercheurs sont plus susceptibles de partager des expériences qui ont eu des résultats positifs.                        |
 
-## Ethereum et la DeSci {#ethereum-and-desci}
+## Ethereum et DeSci {#ethereum-and-desci}
 
 Pour développer des applications, un système scientifique décentralisé exigera une sécurité renforcée, des coûts monétaires et de transaction minimaux et un écosystème riche. Ethereum fournit tout ce qui est nécessaire à la création d'une technologie scientifique décentralisée.
 
-## Exemples d'utilisation de la DeSci {#use-cases}
+## Cas d'usage de la DeSci {#use-cases}
 
 La DeSci met en place les outils scientifiques nécessaires pour faire basculer le milieu traditionnel universitaire vers le digital. Vous trouverez ci-dessous un échantillon d'exemples d'utilisation que le Web3 peut offrir à la communauté scientifique.
 
-### Publications {#publishing}
+### Publication {#publishing}
 
-Comme chacun le sait, les publications scientifiques posent problème car elles sont gérées par des maisons d'édition qui s'appuient sur le travail gratuit de scientifiques, de réviseurs et d'éditeurs pour produire des articles, mais qui facturent ensuite des frais d'édition exorbitants. Le public, qui a généralement financé indirectement le travail et les coûts de publication à travers les taxes et les impôts qu'il paie, ne peut souvent pas accéder à ce même travail sans payer l'éditeur à nouveau. Le montant total des frais de publication d'articles scientifiques individuels est souvent à cinq chiffres ($USD), ce qui sape le concept même de connaissance scientifique en tant que [bien public](/glossary/#public-goods) tout en permettant à un petit groupe d'éditeurs d'engranger d'énormes profits.
+Comme chacun le sait, les publications scientifiques posent problème car elles sont gérées par des maisons d'édition qui s'appuient sur le travail gratuit de scientifiques, de réviseurs et d'éditeurs pour produire des articles, mais qui facturent ensuite des frais d'édition exorbitants. Le public, qui a généralement financé indirectement le travail et les coûts de publication à travers les taxes et les impôts qu'il paie, ne peut souvent pas accéder à ce même travail sans payer l'éditeur à nouveau. Le montant total des frais de publication d'articles scientifiques individuels atteint souvent cinq chiffres (en $ USD), ce qui sape le concept même de connaissance scientifique en tant que [bien public](/glossary/#public-goods) tout en permettant à un petit groupe d'éditeurs de générer d'énormes profits.
 
-Il existe des plateformes d'acès libre et gratuit sous forme de serveurs de pré-impression [comme ArXiv](https://arxiv.org/). Le contrôle qualité , de même que les [mécanismes anti-sybil](/glossary/#anti-sybil), font toutefois défaut sur ces plateformes, qui ne suivent généralement pas les paramètres en termes d'article, ce qui signifie qu'ils ne sont généralement utilisés que pour faire connaître un travail avant de le soumettre à un éditeur classique. SciHub permet également d'accéder gratuitement aux articles publiés, mais pas légalement, et seulement après que les éditeurs ont été réglés et ont lié l'œuvre à une législation stricte sur le droit d'auteur. Les données et articles scientifiques accessibles associés à un mécanisme de légitimité et à un modèle incitatif intégrés manquent donc cruellement. Le Web3 offre les outils nécessaire pour construire un tel système.
+Il existe des plateformes gratuites et à accès libre sous la forme de serveurs de prépublication, [comme ArXiv](https://arxiv.org/). Cependant, ces plateformes manquent de contrôle qualité, de [mécanismes anti-Sybil](/glossary/#anti-sybil) et ne suivent généralement pas les indicateurs au niveau des articles, ce qui signifie qu'elles ne sont généralement utilisées que pour faire connaître un travail avant de le soumettre à un éditeur traditionnel. SciHub permet également d'accéder gratuitement aux articles publiés, mais pas légalement, et seulement après que les éditeurs ont été réglés et ont lié l'œuvre à une législation stricte sur le droit d'auteur. Les données et articles scientifiques accessibles associés à un mécanisme de légitimité et à un modèle incitatif intégrés manquent donc cruellement. Le Web3 offre les outils nécessaire pour construire un tel système.
 
 ### Reproductibilité et réplicabilité {#reproducibility-and-replicability}
 
@@ -64,25 +64,26 @@ Avec les nouveaux outils Web3 natifs, reproductibilité et réplicabilité sont
 
 ### Financement {#funding}
 
-Dans le cadre du modèle de financement actuel de la science, des personnes ou des groupes de scientifiques présentent des demandes de financement écrites à des organismes de financement. Un petit groupe de personnes de confiance notent les candidats, puis les interrogent avant d'attribuer des fonds à une fraction d'entre eux. En plus de créer un goulot d'étranglement qui mène parfois à **des années d'attente** entre l'application de la demande et la réception d'une subvention, ce modèle est réputé pour être hautement **vulnérable aux biais, aux intérêts personnels et aux politiques** du comité d'étude.
+Dans le cadre du modèle de financement actuel de la science, des personnes ou des groupes de scientifiques présentent des demandes de financement écrites à des organismes de financement. Un petit groupe de personnes de confiance notent les candidats, puis les interrogent avant d'attribuer des fonds à une fraction d'entre eux. En plus de créer des goulots d'étranglement qui entraînent parfois des **années d'attente** entre la demande et la réception d'une subvention, ce modèle est connu pour être très **vulnérable aux préjugés, aux intérêts personnels et aux politiques** du comité d'évaluation.
 
 Des études ont montré que les comités d'étude des demandes de subventions ont du mal à sélectionner les propositions de qualité. En effet, les mêmes propositions soumises à des comités différents donnent des résultats très différents. Le financement étant de plus en plus limité, il s’est concentré sur un groupe plus restreint de chercheurs plus âgés, porteurs de projets plus classiques sur le plan intellectuel. Cela a eu pour effet de créer un paysage de financement hyperconcurrentiel, d'ancrer des incitations perverses et d'étouffer l'innovation.
 
-Le Web3 a le potentiel d'ébranler ce modèle de financement dépassé en expérimentant différents modèles d'incitation développés par les DAO et le Web3 dans l'ensemble. [Le financement rétroactif des biens publics](https://medium.com/ethereum-optimism/retroactive-public-goods-funding-33c9b7d00f0c),[ le financement quadratique](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531),[ la gouvernance de DAO](https://www.antler.co/blog/daos-and-web3-governance-the-promise-implications-and-challenges-ahead) et [ les structures incitatives basées sur l'utilisation de jetons](https://cdixon.org/2017/05/27/crypto-tokens-a-breakthrough-in-open-network-design) sont quelques-uns des outils Web3 qui pourraient révolutionner le financement de la science.
+Le Web3 a le potentiel d'ébranler ce modèle de financement dépassé en expérimentant différents modèles d'incitation développés par les DAO et le Web3 dans l'ensemble. Le [financement rétroactif des biens publics](https://medium.com/ethereum-optimism/retroactive-public-goods-funding-33c9b7d00f0c), le [financement quadratique](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531), la [gouvernance des DAO](https://www.antler.co/blog/daos-and-web3-governance-the-promise-implications-and-challenges-ahead) et les [structures d'incitation tokenisées](https://cdixon.org/2017/05/27/crypto-tokens-a-breakthrough-in-open-network-design) sont quelques-uns des outils Web3 qui pourraient révolutionner le financement de la science.
 
 ### Propriété et développement de la PI {#ip-ownership}
 
-La propriété intellectuelle (PI) pose problème dans la science traditionnelle : cantonnée aux universités ou inutilisée dans les entreprises de biotechnologie, elle est de surcroît et comme chacun le sait difficile à évaluer. Le Web est cependant particulièrement performant en matière de propriété des actifs numériques (notamment des données scientifiques ou des articles), grâce au recours aux [jetons non fongibles (NFTs)](/glossary/#nft).
+La propriété intellectuelle (PI) pose problème dans la science traditionnelle : cantonnée aux universités ou inutilisée dans les entreprises de biotechnologie, elle est de surcroît et comme chacun le sait difficile à évaluer. Cependant, la propriété des actifs numériques (tels que les données ou articles scientifiques) est une chose que le Web3 fait exceptionnellement bien en utilisant des [jetons non fongibles (NFT)](/glossary/#nft).
 
 De la même manière que les NFT peuvent transmettre les recettes de futures transactions au créateur initial, vous pouvez établir des chaînes d'attribution de valeur transparentes pour récompenser les chercheurs, les organes directeurs (les DAO par exemple), ou même les personnes dont les données sont collectées.
 
-Les [NFT liés à la PI](https://medium.com/molecule-blog/ip-nfts-for-researchers-a-new-biomedical-funding-paradigm-91312d8d92e6) peuvent également servir de clé d'accès à un référentiel de données décentralisé relatif aux expériences de recherche en cours, et puiser dans les NFT et le financement de la [DeFi](/glossary/#defi) (de la fractionalisation aux groupes de prêt et à l'estimation de la valeur). Ils permettent également aux entités nativement en chaîne, telles que les DAO comme [VitaDAO](https://www.vitadao.com/), de mener des recherches directement en chaîne. Les [jetons « soulbound »](https://vitalik.eth.limo/general/2022/01/26/soulbound.html) non transférables peuvent également jouer un rôle important en matière de DeSci en permettant aux individus d'apporter la preuve de leur expérience et leurs identifiants liés à leur adresse Ethereum.
+Les [IP-NFT](https://medium.com/molecule-blog/ip-nfts-for-researchers-a-new-biomedical-funding-paradigm-91312d8d92e6) peuvent également servir de clé à un référentiel de données décentralisé des expériences de recherche en cours, et se connecter à la financiarisation des NFT et de la [DeFi](/glossary/#defi) (du fractionnement aux pools de prêt et à l'évaluation de la valeur). Cela permet également à des entités nativement sur la chaîne telles que des DAO comme [VitaDAO](https://www.vitadao.com/) de mener des recherches directement sur la chaîne.
+L'avènement des [jetons « soulbound »](https://vitalik.eth.limo/general/2022/01/26/soulbound.html) non transférables pourrait également jouer un rôle important dans la DeSci en permettant aux individus de prouver leur expérience et leurs références liées à leur adresse Ethereum.
 
 ### Stockage de données, accès et architecture {#data-storage}
 
 Les données scientifiques peuvent être rendues beaucoup plus accessibles en utilisant les modèles Web3, sachant que le stockage distribué permet aux recherches et études de survivre à des événements cataclysmiques.
 
-Le tout doit reposer sur un système accessible par toute identité décentralisée disposant d'identifiants vérifiables appropriés. Les données sensibles peuvent ainsi être répliquées en toute sécurité par des parties de confiance, ce qui permet de résister à la redondance et à la censure, de reproduire les résultats et même à plusieurs parties de collaborer et d'ajouter de nouvelles données à l'ensemble de données. Des méthodes de calcul confidentielles telles que [compute-to-data](https://7wdata.be/predictive-analytics/compute-to-data-using-blockchain-to-decentralize-data-science-and-ai-with-the-ocean-protocol) offrent des mécanismes d'accès alternatifs à la réplication des données brutes, créant des environnements de recherche fiables pour les données les plus sensibles. Les environnements de recherche fiables ont été [cités par le NHS](https://medium.com/weavechain/whats-in-store-for-the-future-of-healthcare-data-b6398745fbbb) comme une solution de préservation de la confidentialité des données et de collaboration orientée vers l'avenir dans la mesure où ils créent un écosystème au sein duquel les chercheurs peuvent travailler en toute sécurité avec les données directement sur place en utilisant des environnements normalisés pour le partage de code et de pratiques.
+Le tout doit reposer sur un système accessible par toute identité décentralisée disposant d'identifiants vérifiables appropriés. Les données sensibles peuvent ainsi être répliquées en toute sécurité par des parties de confiance, ce qui permet de résister à la redondance et à la censure, de reproduire les résultats et même à plusieurs parties de collaborer et d'ajouter de nouvelles données à l'ensemble de données. Les méthodes de calcul confidentiel comme le [compute-to-data](https://7wdata.be/predictive-analytics/compute-to-data-using-blockchain-to-decentralize-data-science-and-ai-with-the-ocean-protocol) fournissent des mécanismes d'accès alternatifs à la réplication des données brutes, créant des environnements de recherche fiables pour les données les plus sensibles. Les environnements de recherche fiables ont été [cités par le NHS](https://medium.com/weavechain/whats-in-store-for-the-future-of-healthcare-data-b6398745fbbb) comme une solution d'avenir pour la confidentialité des données et la collaboration en créant un écosystème où les chercheurs peuvent travailler en toute sécurité avec des données sur site en utilisant des environnements normalisés pour le partage de code et de pratiques.
 
 Les solutions Web 3 flexibles axées sur les données prennent en charge les scénarios ci-dessus et fournissent les bases d'une science réellement ouverte, où les chercheurs peuvent créer des biens publics sans autorisation d'accès ni frais. Les solutions Web3 relatives aux données publiques telles qu'IPFS, Arweave et Filecoin sont optimisées pour la décentralisation. dClimate, par exemple, fournit un accès universel aux données climatiques et météorologiques, y compris à partir de stations météo et de modèles climatiques prédictifs.
 
@@ -90,47 +91,48 @@ Les solutions Web 3 flexibles axées sur les données prennent en charge les sc
 
 Explorer les projets et rejoindre la communauté DeSci.
 
-- [DeSci.Global : calendrier des événements et des rencontres à l'échelle mondiale](https://desci.global)
-- [La blockchain au service de la science avec Telegram](https://t.me/BlockchainForScience)
-- [Molecule : Financer et recevoir des fonds pour vos projets de recherche](https://www.molecule.xyz/)
-- [VitaDAO : recevoir des fonds par le biais d'accords de recherche sponsorisés en vue de recherches sur la longévité](https://www.vitadao.com/)
-- [Research Hub : publier un résultat scientifique et participer à une conversation avec des pairs](https://www.researchhub.com/)
-- [dClimate API : envoyer des requêtes concernant les données climatiques recueillies par une communauté décentralisée](https://www.dclimate.net/)
-- [DeSci Foundation : fabricant d'outils de publication DeSci](https://descifoundation.org/)
-- [DeSci.World : guichet unique grâce auquel les utilisateurs peuvent avoir une visibilité, échanger avec la science décentralisée](https://desci.world)
-- [OceanDAO : source de financement régi par une DAO pour les études scientifiques liées aux données](https://oceanprotocol.com/)
-- [Opscientia : flux de travaux scientifiques décentralisés ouverts](https://opsci.io/research/)
-- [Bio.xyz : financer votre projet DAO ou desci biotech](https://www.bio.xyz/)
-- [Institut d'inférence active](https://www.activeinference.org/)
-- [IdeaMarkets : pour une crédibilité scientifique décentralisée renforcée](https://ideamarket.io/)
+- [DeSci.Global : calendrier mondial des événements et des rencontres](https://desci.global)
+- [Blockchain for Science Telegram](https://t.me/BlockchainForScience)
+- [Molecule : Financez et soyez financé pour vos projets de recherche](https://www.molecule.xyz/)
+- [VitaDAO : recevez un financement pour la recherche sur la longévité via des accords de recherche sponsorisés](https://www.vitadao.com/)
+- [ResearchHub : publiez un résultat scientifique et engagez la conversation avec vos pairs](https://www.researchhub.com/)
+- [dClimate API : interrogez les données climatiques collectées par une communauté décentralisée](https://www.dclimate.net/)
+- [DeSci Foundation : créateur d'outils de publication DeSci](https://descifoundation.org/)
+- [DeSci.World : un guichet unique pour que les utilisateurs puissent consulter et s'engager dans la science décentralisée](https://desci.world)
+- [OceanDAO : financement régi par une DAO pour la science liée aux données](https://oceanprotocol.com/)
+- [Opscientia : flux de travail scientifiques décentralisés et ouverts](https://opsci.io/research/)
+- [Bio.xyz : obtenez un financement pour votre projet de DAO biotechnologique ou de DeSci](https://www.bio.xyz/)
+- [Active Inference Institute](https://www.activeinference.org/)
+- [IdeaMarkets : pour une crédibilité scientifique décentralisée](https://ideamarket.io/)
 - [DeSci Labs](https://www.desci.com/)
-- [ValleyDAO : une communauté ouverte et mondiale offrant un financement et un support translationnel à la recherche en biologie synthétique](https://www.valleydao.bio)
-- [Cerebrum DAO : recherche et développement de solutions pour améliorer la santé cérébrale et prévenir la neurodégénérescence](https://www.cerebrumdao.com/)
-- [CryoDAO : financement de recherches audacieuses dans le domaine de la cryopréservation](https://www.cryodao.org)
+- [ValleyDAO : une communauté mondiale ouverte offrant un financement et un soutien translationnel pour la recherche en biologie synthétique](https://www.valleydao.bio)
+- [Cerebrum DAO : trouver et développer des solutions pour faire progresser la santé du cerveau et prévenir la neurodégénérescence](https://www.cerebrumdao.com/)
+- [CryoDAO : financement de recherches audacieuses dans le domaine de la cryoconservation](https://www.cryodao.org)
+- [Elata : Ayez votre mot à dire sur l'avenir de la médecine psychiatrique](https://www.elata.bio/)
 
-Nous accueillons volontiers les suggestions de nouveaux projets à répertorier - veuillez consulter notre [politique d'inscription](/contributing/adding-desci-projects/) pour commencer !
+Nous sommes ouverts aux suggestions de nouveaux projets à répertorier. Veuillez consulter notre [politique de référencement](/contributing/adding-desci-projects/) pour commencer !
 
 ## En savoir plus {#further-reading}
 
 - [DeSci Wiki par Jocelynn Pearl et Ultrarare](https://docs.google.com/document/d/1aQC6zn-eXflSmpts0XGE7CawbUEHwnL6o-OFXO52PTc/edit#)
-- [Un guide sur la biotech décentralisée par Jocelynn Pearl pour a16z future](https://future.a16z.com/a-guide-to-decentralized-biotech/)
-- [Arguments en faveur de la DeSci](https://gitcoin.co/blog/desci-the-case-for-decentralised-science/)
-- [Guide relatif à la DeSci](https://future.com/what-is-decentralized-science-aka-desci/)
-- [Ressources relatives à la science décentralisée](https://www.vincentweisser.com/desci)
-- [Les IP-NFT de Molecule dans le domaine biopharmaceutique - Description technique](https://www.molecule.xyz/blog/molecules-biopharma-ip-nfts-a-technical-description)
-- [Construire des systèmes scientifiques sans tiers de confiance par Jon Starr](https://medium.com/@jringo/building-systems-of-trustless-science-1cd2d072f673)
+- [Un guide sur la biotechnologie décentralisée par Jocelynn Pearl pour a16z future](https://future.a16z.com/a-guide-to-decentralized-biotech/)
+- [Plaidoyer pour la DeSci](https://gitcoin.co/blog/desci-the-case-for-decentralised-science/)
+- [Guide de la DeSci](https://future.com/what-is-decentralized-science-aka-desci/)
+- [Ressources sur la science décentralisée](https://www.vincentweisser.com/desci)
+- [Les IP-NFT biopharmaceutiques de Molecule – Une description technique](https://www.molecule.xyz/blog/molecules-biopharma-ip-nfts-a-technical-description)
+- [Construire des systèmes scientifiques sans confiance par Jon Starr](https://medium.com/@jringo/building-systems-of-trustless-science-1cd2d072f673)
 - [Paul Kohlhaas - DeSci : L'avenir de la science décentralisée (podcast)](https://anchor.fm/andrew-steinwold/episodes/Paul-Kohlhaas---DeSci-The-Future-of-Decentralized-Science---Zima-Red-ep-117-e1h683a)
-- [Une ontologie des Inférences actives pour une science décentralisée : de la création de sens en situation aux biens communs épistémiques](https://zenodo.org/record/6320575)
+- [Une ontologie de l'inférence active pour la science décentralisée : de la création de sens en situation aux biens communs épistémiques](https://zenodo.org/record/6320575)
 - [DeSci : l'avenir de la recherche par Samuel Akinosho](https://lucidsamuel.medium.com/desci-the-future-of-research-b76cfc88c8ec)
-- [Financement de la science (Épilogue : la DeSci et les nouvelles primitives dans les cryptomonnaies) par Nadia](https://nadia.xyz/science-funding)
-- [La décentralisation perturbe développement des médicaments](https://medium.com/id-theory/decentralisation-is-disrupting-drug-development-28b5ba5d447f)
-- [Qu'est-ce que la DeSci – Science Décentralisée ?](https://usadailytimes.com/2022/09/12/what-is-desci-decentralized-science/)
+- [Financement de la science (Épilogue : DeSci et nouvelles primitives de cryptomonnaies) par Nadia](https://nadia.xyz/science-funding)
+- [La décentralisation bouleverse le développement de médicaments](https://medium.com/id-theory/decentralisation-is-disrupting-drug-development-28b5ba5d447f)
+- [Qu'est-ce que la DeSci – la science décentralisée ?](https://usadailytimes.com/2022/09/12/what-is-desci-decentralized-science/)
 
 ### Vidéos {#videos}
 
 - [Qu'est-ce que la science décentralisée ?](https://www.youtube.com/watch?v=-DeMklVWNdA)
-- [Conversation entre Vitalik Buterin et le scientifique Aubrey de Grey sur le croisement entre recherche sur la longévité et cryptomonnaie](https://www.youtube.com/watch?v=x9TSJK1widA)
-- [La publication scientifique est en panne. Est-ce que le Web3 peut améliorer ?](https://www.youtube.com/watch?v=WkvzYgCvWj8)
-- [Juan Benet - DeSci, laboratoires indépendants, & dcience des données à grande échelle](https://www.youtube.com/watch?v=zkXM9H90g_E)
-- [Sebastian Brunemeier - Comment la DeSci peut transformer la recherche biomédicale & le capital risque](https://www.youtube.com/watch?v=qB4Tc3FcVbM)
-- [Paige Donner - Outils pour la science ouverte avec le Web3 & La Blockchain](https://www.youtube.com/watch?v=nC-2QWQ-lgw&t=17s)
+- [Conversation entre Vitalik Buterin et le scientifique Aubrey de Grey sur le croisement entre la recherche sur la longévité et les cryptomonnaies](https://www.youtube.com/watch?v=x9TSJK1widA)
+- [La publication scientifique est en panne. Le Web3 peut-il y remédier ?](https://www.youtube.com/watch?v=WkvzYgCvWj8)
+- [Juan Benet - DeSci, laboratoires indépendants et science des données à grande échelle](https://www.youtube.com/watch?v=zkXM9H90g_E)
+- [Sebastian Brunemeier - Comment la DeSci peut transformer la recherche biomédicale et le capital-risque](https://www.youtube.com/watch?v=qB4Tc3FcVbM)
+- [Paige Donner - Outiller la science ouverte avec le Web3 et la blockchain](https://www.youtube.com/watch?v=nC-2QWQ-lgw&t=17s)
diff --git a/public/content/translations/fr/developers/docs/accounts/index.md b/public/content/translations/fr/developers/docs/accounts/index.md
index 381a07c5d2a..bf4eaf09393 100644
--- a/public/content/translations/fr/developers/docs/accounts/index.md
+++ b/public/content/translations/fr/developers/docs/accounts/index.md
@@ -1,10 +1,10 @@
 ---
 title: Comptes Ethereum
-description: Explication des comptes Ethereum – leurs structures de données et leur relation avec la cryptographie asymétrique.
+description: "Explication des comptes Ethereum – leurs structures de données et leur relation avec la cryptographie asymétrique."
 lang: fr
 ---
 
-Un compte Ethereum est une entité avec un solde en ether (ETH) qui peut réaliser des transactions sur Ethereum. Les comptes peuvent être contrôlés par l'utilisateur ou déployés en tant que contrats intelligents.
+Un compte Ethereum est une entité avec un solde d'éther (ETH) qui peut envoyer des messages sur Ethereum. Les comptes peuvent être contrôlés par l'utilisateur ou déployés en tant que contrats intelligents.
 
 ## Prérequis {#prerequisites}
 
@@ -15,39 +15,40 @@ Pour vous aider à mieux comprendre cette page, nous vous recommandons de commen
 Ethereum comprend deux types de comptes :
 
 - Compte détenu en externe (EOA) – contrôlé par toute personne ayant les clés privées
-- Compte de contrat – un contrat intelligent déployé sur le réseau, contrôlé par le code. En savoir plus sur [ les contrats intelligents](/developers/docs/smart-contracts/)
+- Compte de contrat – un contrat intelligent déployé sur le réseau, contrôlé par le code. En savoir plus sur les [contrats intelligents](/developers/docs/smart-contracts/)
 
 Les deux types de comptes peuvent :
 
 - Recevoir, détenir et envoyer des ETH et des jetons
 - Interagir avec les contrats intelligents déployés
 
-### Différences principales {#key-differences}
+### Principales différences {#key-differences}
 
-**Propriété externe**
+**externe**
 
 - La création d'un compte est gratuite
 - Vous pouvez initier des transactions
 - Les transactions entre des comptes externes ne peuvent être que des transferts en ETH/jeton
 - Composé d'une paire de clés cryptographiques : clés publiques et privées qui contrôlent les activités du compte
 
-**Contrats**
+**Contrat**
 
 - La création d'un contrat a un coût dû à l'utilisation de stockage réseau
-- Vous pouvez seulement envoyer des transactions en réponse à la réception d'une transaction
+- Ne peut envoyer des messages qu'en réponse à la réception d'une transaction
 - Les transactions depuis un compte externe vers un compte de contrat peuvent déclencher un code pouvant exécuter plein d'actions différentes, comme transférer des tokens ou même créer un nouveau contrat
 - Les comptes de contrat n'ont pas de clés privées. Au lieu de cela, ils sont contrôlés par la logique du code du contrat intelligent
 
-## Description d'un compte {#an-account-examined}
+## Examen d'un compte {#an-account-examined}
 
 Les comptes Ethereum comportent quatre champs :
 
-- `nonce` - Il s'agit soit d'un code indiquant le nombre de transactions envoyées à partir d'une adresse émettrice, soit du nombre de contrats créés auxquels vous pouvez avoir accès par le biais de la page dédiée aux contrats et aux adresses Ethereum (Account). Chaque adresse Ethereum (Account) peut être utilisée uniquement à chaque transaction en choisissant un nonce associé au bloc. Le rôle de ce dernier est de rendre impossible les attaques par rejeu, durant lesquelles des transactions signées sur une chaîne, sont réalisées et retransmises de manière continue sur l'autre chaîne.
-- `balance` – le nombre de wei possédés par cette adresse. Le wei est une unité divisionnaire de l'ETH. Il y a 1e+18 wei pour 1 ETH.
-- `codeHash` – ce hash est une référence au _code_ d'un compte dans la machine virtuelle Ethereum (EVM). Les comptes de contrat possèdent des fragments de code qui peuvent réaliser différentes opérations. Ce code EVM est exécuté si le compte reçoit un message. Contrairement aux autres champs, il ne peut pas être modifié. Tous ces fragments de code sont stockés dans une base de données à états, sous leur hachage correspondant, pour une récupération future. Cette valeur de hachage est connue en tant que codeHash. Pour les comptes externes, le champ du codeHash contient le hachage d'une chaîne vide.
-- `storageRoot` – Parfois connu sous le nom de hachage de stockage. Un hash 256 bits du nœud racine d'un arbre de Merkle qui encode le contenu de stockage du compte (une correspondance entre 256 bits entiers), encodé dans un arbre préfixé comme correspondance d'un hach Keccak 256 bits des clés d'entier en 256 bits en des valeurs entières encodées en RLP. Cet arbre encode le hash des contenus stockés de ce compte, et est vide pas défaut.
+- `nonce` – Un compteur qui indique le nombre de transactions envoyées depuis un compte externe ou le nombre de contrats créés par un compte de contrat. Chaque adresse Ethereum (Account) peut être utilisée uniquement à chaque transaction en choisissant un nonce associé au bloc. Le rôle de ce dernier est de rendre impossible les attaques par rejeu, durant lesquelles des transactions signées sur une chaîne, sont réalisées et retransmises de manière continue sur l'autre chaîne.
+- `balance` – Le nombre de wei détenus par cette adresse. Le wei est une unité divisionnaire de l'ETH. Il y a 1e+18 wei pour 1 ETH.
+- `codeHash` – Ce hachage fait référence au _code_ d'un compte sur la machine virtuelle Ethereum (EVM). Les comptes de contrat possèdent des fragments de code qui peuvent réaliser différentes opérations. Ce code EVM est exécuté si le compte reçoit un message. Contrairement aux autres champs, il ne peut pas être modifié. Tous ces fragments de code sont stockés dans une base de données à états, sous leur hachage correspondant, pour une récupération future. Cette valeur de hachage est connue en tant que codeHash. Pour les comptes externes, le champ du codeHash contient le hachage d'une chaîne vide.
+- `storageRoot` – Parfois appelé hachage de stockage. Un hachage de 256 bits du nœud racine d'un [arbre de Merkle Patricia](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/) qui encode le contenu de stockage du compte (une correspondance entre des valeurs entières de 256 bits), encodé dans l'arbre en tant que correspondance entre le hachage Keccak-256 des clés entières de 256 bits et les valeurs entières de 256 bits encodées en RLP. Cet arbre encode le hash des contenus stockés de ce compte, et est vide pas défaut.
 
-![Schéma montrant la composition d'un compte](./accounts.png) _Schéma adapté à partir du document [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Un schéma montrant la composition d'un compte](./accounts.png)
+_Schéma adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 ## Comptes externes et paires de clés {#externally-owned-accounts-and-key-pairs}
 
@@ -63,25 +64,25 @@ Lorsque vous souhaitez créer un compte, la plupart des bibliothèques générer
 
 Une clé privée est composée de 64 caractères hexadécimaux et peut être chiffrée avec un mot de passe.
 
-Exemple :
+Exemple :
 
 `fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036415f`
 
-La clé publique est générée à partir de la clé privée à l'aide d'un [algorithme de signature numérique basé sur les courbes elliptiques](https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm). On obtient l'adresse d'un compte en concatenant `0x` suivi des 20 derniers octets du code de hashage Keccak-256 de la clé pubique.
+La clé publique est générée à partir de la clé privée en utilisant l'[algorithme de signature numérique à courbe elliptique](https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm). Vous obtenez une adresse publique pour votre compte en prenant les 20 derniers octets du hachage Keccak-256 de la clé publique et en ajoutant `0x` au début.
 
-Cela signifie qu'un compte externe (EOA) possède une adresse de 42 caractères (un segment de 20 octets, soit 40 caractères hexadécimaux plus le préfixe `0x`).
+Cela signifie qu'un compte externe (EOA) a une adresse de 42 caractères (un segment de 20 octets qui correspond à 40 caractères hexadécimaux plus le préfixe `0x`).
 
-Exemple :
+Exemple :
 
 `0x5e97870f263700f46aa00d967821199b9bc5a120`
 
-L'exemple suivant montre comment utiliser un outil de signature appelé [Clef](https://geth.ethereum.org/docs/tools/clef/introduction) pour générer un nouveau compte. Clef est un outil de gestion de compte et de signature qui est fourni avec le client Ethereum [Geth](https://geth.ethereum.org). La commande `clef newaccount` crée une nouvelle paire de clés et les enregistre dans un magasin de clés chiffré.
+L'exemple suivant montre comment utiliser un outil de signature appelé [Clef](https://geth.ethereum.org/docs/tools/clef/introduction) pour générer un nouveau compte. Clef est un outil de gestion de compte et de signature fourni avec le client Ethereum, [Geth](https://geth.ethereum.org). La commande `clef newaccount` crée une nouvelle paire de clés et l'enregistre dans un keystore chiffré.
 
 ```
-> clef newaccount --keystore <path>
+> clef newaccount --keystore <chemin>
 
-Please enter a password for the new account to be created:
-> <password>
+Veuillez saisir un mot de passe pour le nouveau compte à créer :
+> <mot de passe>
 
 ------------
 INFO [10-28|16:19:09.156] Your new key was generated       address=0x5e97870f263700f46aa00d967821199b9bc5a120
@@ -92,15 +93,15 @@ Generated account 0x5e97870f263700f46aa00d967821199b9bc5a120
 
 [Documentation Geth](https://geth.ethereum.org/docs)
 
-Il est possible de dériver de nouvelles clés publiques à partir de votre clé privée, mais pas l'inverse. Il est impératif de conserver vos clés privées en sécurité. Comme leur nom l'indique, elles sont **PRIVÉES**.
+Il est possible de dériver de nouvelles clés publiques à partir de votre clé privée, mais pas l'inverse. Il est essentiel de conserver vos clés privées en lieu sûr et, comme leur nom l'indique, de les garder **PRIVÉES**.
 
-Vous avez besoin d'une clé privée pour signer les messages et les transactions produisant une signature. Les autres peuvent alors prendre la signature pour dériver votre clé publique, prouvant l'auteur du message. Dans votre application, vous pouvez utiliser une bibliothèque JavaScript pour envoyer des transactions au réseau.
+Vous avez besoin d'une clé privée pour signer des messages et des transactions qui génèrent une signature. Les autres peuvent alors prendre la signature pour dériver votre clé publique, prouvant l'auteur du message. Dans votre application, vous pouvez utiliser une bibliothèque JavaScript pour envoyer des transactions au réseau.
 
-## Les comptes de contrats {#contract-accounts}
+## Comptes de contrat {#contract-accounts}
 
 Les comptes de contrats possèdent également une adresse hexadécimale de 42 caractères :
 
-Exemple :
+Exemple :
 
 `0x06012c8cf97bead5deae237070f9587f8e7a266d`
 
@@ -116,7 +117,7 @@ Il existe également un autre type de clé dans Ethereum, qui a été mis en pla
 
 Un compte n'est pas un portefeuille. Un portefeuille est une interface ou une application qui vous permet d'interagir avec votre compte Ethereum, qu'il s'agisse d'un compte externe ou d'un compte de contrat.
 
-## Démonstration visuelle {#a-visual-demo}
+## Une démo visuelle {#a-visual-demo}
 
 Regardez Austin vous guider à travers les fonctions de hachage et les paires de clés.
 
@@ -124,9 +125,9 @@ Regardez Austin vous guider à travers les fonctions de hachage et les paires de
 
 <YouTube id="9LtBDy67Tho" />
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Comprendre les Comptes Ethereum](https://info.etherscan.com/understanding-ethereum-accounts/) - etherscan
+- [Comprendre les comptes Ethereum](https://info.etherscan.com/understanding-ethereum-accounts/) - etherscan
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
diff --git a/public/content/translations/fr/developers/docs/apis/backend/index.md b/public/content/translations/fr/developers/docs/apis/backend/index.md
index f68c6e713fc..9617369525b 100644
--- a/public/content/translations/fr/developers/docs/apis/backend/index.md
+++ b/public/content/translations/fr/developers/docs/apis/backend/index.md
@@ -1,5 +1,5 @@
 ---
-title: Bibliothèques d'API backend
+title: "Bibliothèques d'API backend"
 description: Introduction aux API clientes Ethereum, qui vous permettent d'interagir avec la blockchain depuis votre application.
 lang: fr
 ---
@@ -8,15 +8,15 @@ Pour qu'une application logicielle puisse interagir avec la blockchain Ethereum
 
 À cette fin, chaque client Ethereum met en œuvre la spécification [JSON-RPC](/developers/docs/apis/json-rpc/), de sorte qu'il existe un ensemble uniforme de [méthodes](/developers/docs/apis/json-rpc/#json-rpc-methods) sur lesquelles les applications peuvent s'appuyer.
 
-Si vous souhaitez utiliser un langage de programmation spécifique pour vous connecter à un nœud Ethereum, vous pouvez développer votre propre solution, mais il existe plusieurs bibliothèques pratiques au sein de l'écosystème qui facilitent grandement cette tâche. Grâce à ces bibliothèques, les développeurs peuvent rédiger des méthodes intuitives d'une seule ligne pour initialiser des demandes RPC JSON (sous le capot) qui interagissent avec Ethereum.
+Si vous souhaitez utiliser un langage de programmation spécifique pour vous connecter à un nœud Ethereum, il existe de nombreuses bibliothèques pratiques au sein de l'écosystème qui facilitent grandement cette tâche. Avec ces bibliothèques, les développeurs peuvent écrire des méthodes intuitives d'une seule ligne pour initialiser les requêtes JSON-RPC (en arrière-plan) qui interagissent avec Ethereum.
 
 ## Prérequis {#prerequisites}
 
-Il peut être utile de comprendre en quoi consiste la [pile Ethereum](/developers/docs/ethereum-stack/) et les [clients Ethereum](/developers/docs/nodes-and-clients/).
+Il peut être utile de comprendre la [pile Ethereum](/developers/docs/ethereum-stack/) et les [clients Ethereum](/developers/docs/nodes-and-clients/).
 
 ## Pourquoi utiliser une bibliothèque ? {#why-use-a-library}
 
-Les bibliothèques suppriment une grande partie de la complexité de l'interaction directe 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.
+Ces bibliothèques suppriment une grande partie de la complexité d'une interaction directe avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex. la conversion d'ETH en Gwei) afin que, en tant que développeur, vous puissiez passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous concentrer sur les fonctionnalités uniques de votre application.
 
 ## Bibliothèques disponibles {#available-libraries}
 
@@ -25,7 +25,7 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 **Alchemy -** **_Plateforme de développement Ethereum._**
 
 - [alchemy.com](https://www.alchemy.com/)
-- [Documentation](https://docs.alchemy.com/)
+- [Documentation](https://www.alchemy.com/docs/)
 - [GitHub](https://github.com/alchemyplatform)
 - [Discord](https://discord.com/invite/alchemyplatform)
 
@@ -35,11 +35,11 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 - [Documentation](https://docs.allthatnode.com)
 - [Discord](https://discord.gg/GmcdVEUbJM)
 
-**Blast by Bware Labs-** **_ API décentralisées pour le réseau principal et les réseaux de tests Ethereum._**
+**Blast by Bware Labs -** **_API décentralisées pour le réseau principal et les réseaux de test Ethereum._**
 
 - [blastapi.io](https://blastapi.io/)
 - [Documentation](https://docs.blastapi.io)
-- [Discord](https://discord.gg/bwarelabs)
+- [Discord](https://discord.gg/SaRqmRUjjQ)
 
 **BlockPi -** **_Fournit des services RPC plus efficaces et plus rapides_**
 
@@ -48,19 +48,24 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 - [GitHub](https://github.com/BlockPILabs)
 - [Discord](https://discord.com/invite/xTvGVrGVZv)
 
-**Passerelle Ethereum de Cloudflare**
+**Passerelle Ethereum de Cloudflare.**
 
 - [cloudflare-eth.com](https://www.cloudflare.com/application-services/products/web3/)
 
 **Etherscan - Explorateur de blocs et APIs de transaction**
+
 - [Documentation](https://docs.etherscan.io/)
 
-**GetBlock-** **_Blockchain-as-a-service pour le développement du Web3_**
+**Blockscout - Open Source Block Explorer**
+
+- [Documentation](https://docs.blockscout.com/)
+
+**GetBlock -** **_Blockchain en tant que service pour le développement Web3_**
 
 - [GetBlock.io](https://getblock.io/)
-- [Documentation](https://getblock.io/docs/)
+- [Documentation](https://docs.getblock.io/)
 
-**Infura -** **_L'API Ethereum en tant que service_**
+**Infura -** **_L'API Ethereum en tant que service._**
 
 - [infura.io](https://infura.io)
 - [Documentation](https://docs.infura.io/api)
@@ -71,23 +76,24 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 - [noderpc.xyz](https://www.noderpc.xyz/)
 - [Documentation](https://docs.noderpc.xyz/node-rpc)
 
-**NOWNodes - _Explorateurs de nœuds complets et de blocs._**
+**NOWNodes - _Nœuds complets et explorateurs de blocs._**
 
 - [NOWNodes.io](https://nownodes.io/)
+- [Documentation](https://nownodes.gitbook.io/documentation)
 
-**Quinone -** **_Infrastructure Blockchain en tant que service_**
+**QuickNode -** **_Infrastructure de blockchain en tant que service._**
 
 - [quicknode.com](https://quicknode.com)
 - [Documentation](https://www.quicknode.com/docs/welcome)
 - [Discord](https://discord.gg/quicknode)
 
-**Rivet -** **_API Ethereum et Ethereum Classic en tant que service alimenté par des logiciels libres._**
+**Rivet -** **_API Ethereum et Ethereum Classic en tant que service, propulsées par des logiciels open source._**
 
 - [rivet.cloud](https://rivet.cloud)
 - [Documentation](https://rivet.cloud/docs/)
 - [GitHub](https://github.com/openrelayxyz/ethercattle-deployment)
 
-**Zmok -** **_Nœuds Ethereum orientés vitesse comme API JSON-RPC/WebSockets_**
+**Zmok -** **_Nœuds Ethereum axés sur la vitesse via une API JSON-RPC/WebSockets._**
 
 - [zmok.io](https://zmok.io/)
 - [GitHub](https://github.com/zmok-io)
@@ -96,60 +102,62 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 
 ### Outils de développement {#development-tools}
 
-**ethers-kt** - **_Librairie Kotlin/Java/Andoid asynchrone et haute performance pour les blockchains basées sur l'EVM_**
+**ethers-kt -** **_Bibliothèque Kotlin/Java/Android asynchrone et très performante pour les blockchains basées sur l'EVM._**
 
 - [GitHub](https://github.com/Kr1ptal/ethers-kt)
 - [Exemples](https://github.com/Kr1ptal/ethers-kt/tree/master/examples)
 - [Discord](https://discord.gg/rx35NzQGSb)
 
-**Nethereum -** **_Une bibliothèque d’intégration .NET open source pour la blockchain._**
+**Nethereum -** **_Une bibliothèque d'intégration .NET open source pour la blockchain._**
 
 - [GitHub](https://github.com/Nethereum/Nethereum)
 - [Documentation](http://docs.nethereum.com/en/latest/)
 - [Discord](https://discord.com/invite/jQPrR58FxX)
 
-**Python Tooling -** **_Diverses bibliothèques pour interagir avec Ethereum via Python_**
+**Outils Python -** **_Diverses bibliothèques pour interagir avec Ethereum via Python._**
 
-- [py.ethereum.org](https://snakecharmers.ethereum.org)
-- [GitHub Web3.py](https://github.com/ethereum/web3.py)
-- [Chat Web3.py](https://gitter.im/ethereum/web3.py)
+- [py.ethereum.org](https://snakecharmers.ethereum.org/)
+- [GitHub de web3.py](https://github.com/ethereum/web3.py)
+- [Chat de web3.py](https://gitter.im/ethereum/web3.py)
 
-**Tatum -** **_Plateforme de développement de la blockchain._**
+**Tatum -** **_La plateforme de développement blockchain ultime._**
 
 - [Tatum](https://tatum.io/)
 - [GitHub](https://github.com/tatumio/)
 - [Documentation](https://docs.tatum.io/)
 - [Discord](https://discord.gg/EDmW3kjTC9)
 
-**web3j -** **_Bibliothèque d'intégration Java/Android/Kotlin/Scala pour Ethereum_**
+**web3j -** **_Une bibliothèque d'intégration Java/Android/Kotlin/Scala pour Ethereum._**
 
 - [GitHub](https://github.com/web3j/web3j)
 - [Documentation](https://docs.web3j.io/)
 - [Gitter](https://gitter.im/web3j/web3j)
 
-### Services blockchain {#blockchain-services}
+### Services de blockchain {#blockchain-services}
 
-**BlockCypher -** **_APIs Ethereum Web_**
+**BlockCypher -** **_API Web Ethereum._**
 
 - [blockcypher.com](https://www.blockcypher.com/)
 - [Documentation](https://www.blockcypher.com/dev/ethereum/)
 
+**Chainbase -** **_Infrastructure de données Web3 tout-en-un pour Ethereum._**
+
 - [chainbase.com](https://chainbase.com/)
 - [Documentation](https://docs.chainbase.com/)
 - [Discord](https://discord.gg/Wx6qpqz4AF)
 
-**Chainstack -** **_Nœuds Ethereum partagés et dédiés en tant que service_**
+**Chainstack -** **_Nœuds Ethereum élastiques et dédiés en tant que service._**
 
 - [chainstack.com](https://chainstack.com)
-- [Documentation](https://docs.chainbase.com/docs)
+- [Documentation](https://docs.chainstack.com/)
 - [Référence de l'API Ethereum](https://docs.chainstack.com/reference/ethereum-getting-started)
 
-**Nœud Cloud Coinbase -** **_API d'infrastructure blockchain._**
+**Coinbase Cloud Node -** **_API d'infrastructure de blockchain._**
 
-- [Nœud cloud de Coinbase](https://www.coinbase.com/cloud)
-- [Documentation](https://docs.cloud.coinbase.com/)
+- [Nœud Cloud Coinbase](https://www.coinbase.com/developer-platform)
+- [Documentation](https://docs.cdp.coinbase.com/)
 
-**DataHub by Figment -** **_Services API Web3 avec réseau principal et réseaux de tests Ethereum._**
+**DataHub by Figment -** **_Services d'API Web3 avec le réseau principal et les réseaux de test Ethereum._**
 
 - [DataHub](https://www.figment.io/)
 - [Documentation](https://docs.figment.io/)
@@ -162,7 +170,7 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 - [Discord](https://moralis.io/joindiscord/)
 - [Forum](https://forum.moralis.io/)
 
-**NFTPort -** **_API de frappe et de données Ethereum._**
+**NFTPort -** **_API de données et de frappe Ethereum._**
 
 - [nftport.xyz](https://www.nftport.xyz/)
 - [Documentation](https://docs.nftport.xyz/)
@@ -175,30 +183,29 @@ Les bibliothèques suppriment une grande partie de la complexité de l'interacti
 - [Documentation](https://services.tokenview.io/docs?type=api)
 - [GitHub](https://github.com/Tokenview)
 
-**Watchdata** **_ - fournit un accès API simple et fiable à la blockchain Ethereum._**
+**Watchdata -** **_Fournit un accès API simple et fiable à la blockchain Ethereum._**
 
 - [Watchdata](https://watchdata.io/)
 - [Documentation](https://docs.watchdata.io/)
 - [Discord](https://discord.com/invite/TZRJbZ6bdn)
 
-**Covalent** - **_APIs blockchain enrichie pour plus de 200 chaines._**
+**Covalent -** **_API de blockchain enrichies pour plus de 200 chaînes._**
 
 - [covalenthq.com](https://www.covalenthq.com/)
 - [Documentation](https://www.covalenthq.com/docs/api/)
 - [GitHub](https://github.com/covalenthq)
 - [Discord](https://www.covalenthq.com/discord/)
 
-
-## 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}
 
-- [ Nœuds et clients](/developers/docs/nodes-and-clients/)
+- [Nœuds et clients](/developers/docs/nodes-and-clients/)
 - [Frameworks de développement](/developers/docs/frameworks/)
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Configurer Web3js pour utiliser la blockchain Ethereum avec JavaScript](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/)_ - Instructions pour installer et intégrer Web3js à votre projet_
-- [Appel d'un contrat intelligent à partir de JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _ - À l'aide du jeton DAI, découvrez comment appeler une fonction de contrat en utilisant JavaScript._
+- [Configurer Web3js pour utiliser la blockchain Ethereum avec JavaScript](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/) _– Instructions pour installer et intégrer web3.js dans votre projet._
+- [Appeler un contrat intelligent depuis JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _– À l'aide du jeton DAI, découvrez comment appeler des fonctions de contrat en JavaScript._
diff --git a/public/content/translations/fr/developers/docs/apis/javascript/index.md b/public/content/translations/fr/developers/docs/apis/javascript/index.md
index 98969ec8413..07d5cad0a3d 100644
--- a/public/content/translations/fr/developers/docs/apis/javascript/index.md
+++ b/public/content/translations/fr/developers/docs/apis/javascript/index.md
@@ -1,40 +1,42 @@
 ---
-title: Bibliothèques d'API JavaScript
-description: Introduction aux bibliothèques clientes JavaScript, qui vous permettent d'interagir avec la blockchain depuis votre application.
+title: "Bibliothèques d'API JavaScript"
+description: "Introduction aux bibliothèques clientes JavaScript, qui vous permettent d'interagir avec la blockchain depuis votre application."
 lang: fr
 ---
 
-Pour qu'une application Web puisse interagir avec la blockchain Ethereum (c'est-à-dire lire les données de la blockchain et/ou envoyer des transactions sur le réseau), elle doit se connecter à un nœud  Ethereum.
+Pour qu'une application Web puisse interagir avec la blockchain Ethereum (c'est-à-dire lire les données de la blockchain et/ou envoyer des transactions sur le réseau), elle doit se connecter à un nœud Ethereum.
 
-À cette fin, chaque client Ethereum met en œuvre la spécification [JSON-RPC](/developers/docs/apis/json-rpc/), de sorte qu'il existe un ensemble uniforme de [méthodes](/developers/docs/apis/json-rpc/#json-rpc-methods) sur lesquelles les applications peuvent s'appuyer.
+Dans ce but, chaque client Ethereum implémente la spécification [JSON-RPC](/developers/docs/apis/json-rpc/), afin qu'il existe un ensemble uniforme de [méthodes](/developers/docs/apis/json-rpc/#json-rpc-methods) sur lesquelles les applications peuvent s'appuyer.
 
-Si vous voulez utiliser JavaScript pour vous connecter à un nœud Ethereum, il est possible d'avoir recours à Vanilla JavaScript, mais plusieurs bibliothèques de commodité existent à l'intérieur même de l'écosystème, ce qui rend les choses beaucoup plus simples. Grâce à ces bibliothèques, les développeurs peuvent rédiger des méthodes intuitives d'une seule ligne pour initialiser des demandes RPC JSON (sous le capot) qui interagissent avec Ethereum.
+Si vous voulez utiliser JavaScript pour vous connecter à un nœud Ethereum, il est possible d'avoir recours à Vanilla JavaScript, mais plusieurs bibliothèques de commodité existent à l'intérieur même de l'écosystème, ce qui rend les choses beaucoup plus simples. Avec ces bibliothèques, les développeurs peuvent écrire des méthodes intuitives d'une seule ligne pour initialiser les requêtes JSON-RPC (en arrière-plan) qui interagissent avec Ethereum.
 
-Veuillez noter que depuis [La Fusion](/roadmap/merge/), deux parties de logiciels Ethereum connectés - un client d'exécution et un client de consensus - sont nécessaires pour exécuter un nœud. Veuillez vous assurer que votre nœud inclut à la fois un client d'exécution et un client de consensus. Si votre nœud n'est pas sur votre machine en local (par ex. votre nœud est exécuté sur une instance AWS), mettez à jour les adresses IP dans le tutoriel en conséquence. Pour plus d'informations, veuillez consulter notre page sur [l'exécution d'un noeud](/developers/docs/nodes-and-clients/run-a-node/).
+Veuillez noter que depuis [La Fusion](/roadmap/merge/), deux logiciels Ethereum connectés - un client d'exécution et un client de consensus - sont nécessaires pour exécuter un nœud. Veuillez vous assurer que votre nœud inclut à la fois un client d'exécution et un client de consensus. Si votre nœud ne se trouve pas sur votre machine locale (par ex., votre nœud s'exécute sur une instance AWS), mettez à jour les adresses IP dans le tutoriel en conséquence. Pour plus d'informations, veuillez consulter notre page sur [l'exécution d'un nœud](/developers/docs/nodes-and-clients/run-a-node/).
 
 ## Prérequis {#prerequisites}
 
-Il peut être utile de comprendre non seulement en quoi consiste JavaScript, mais aussi la [pile Ethereum](/developers/docs/ethereum-stack/) et les [clients Ethereum](/developers/docs/nodes-and-clients/).
+En plus de comprendre JavaScript, il peut être utile de comprendre la [pile Ethereum](/developers/docs/ethereum-stack/) et les [clients Ethereum](/developers/docs/nodes-and-clients/).
 
 ## Pourquoi utiliser une bibliothèque ? {#why-use-a-library}
 
-Ces bibliothèques suppriment une grande partie de la complexité d'une interaction directe 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.
+Ces bibliothèques suppriment une grande partie de la complexité d'une interaction directe avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex. la conversion d'ETH en Gwei) afin que, en tant que développeur, vous puissiez passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous concentrer sur les fonctionnalités uniques de votre application.
 
-## Fonctionnalités d'une bibliothèque {#library-features}
+## Fonctionnalités de la bibliothèque {#library-features}
 
-### Se connecter à des nœud Ethereum {#connect-to-ethereum-nodes}
+### Se connecter aux nœuds Ethereum {#connect-to-ethereum-nodes}
 
 En utilisant des fournisseurs, les bibliothèques vous permettent de vous connecter à Ethereum et de lire ses données, que ce soit sur JSON-RPC, INFURA, Etherscan, Alchemy ou Metamask.
 
+> **Avertissement :** Web3.js a été archivé le 4 mars 2025. [Lire l'annonce](https://blog.chainsafe.io/web3-js-sunset/) Envisagez d'utiliser des bibliothèques alternatives comme [ethers.js](https://ethers.org) ou [viem](https://viem.sh) pour les nouveaux projets.
+
 **Exemple Ether**
 
 ```js
-// Un BrowserProvider enveloppe un fournisseur Web3 standard, qui est
-// ce que MetaMask injecte comme window.ethereum dans chaque page.
-const provider = new ethers.providers.BrowserProvider (window.ethereum)
+// Un BrowserProvider encapsule un fournisseur Web3 standard, qui est
+// ce que MetaMask injecte en tant que window.ethereum dans chaque page
+const provider = new ethers.BrowserProvider(window.ethereum)
 
 // Le plugin MetaMask permet également de signer des transactions pour
-// envoyer de l'ether et payer pour changer l'état de la blockchain.
+// envoyer de l'éther et payer pour changer l'état au sein de la blockchain.
 // Pour cela, nous avons besoin du signataire du compte...
 const signer = provider.getSigner()
 ```
@@ -68,41 +70,41 @@ Une fois la configuration effectuée, vous pourrez interroger la blockchain pour
 - le gaz estimé ;
 - les événements du contract intelligent ;
 - l'ID du réseau ;
-- et plus encore...
+- Et plus encore...
 
-### Fonctionnalités d'un portefeuille {#wallet-functionality}
+### Fonctionnalité du portefeuille {#wallet-functionality}
 
 Les bibliothèques vous permettent de créer des portefeuilles, gérer vos clés et signer des transactions.
 
 Voici un exemple provenant de la bibliothèque Ethers
 
 ```js
-// Créer une instance de portefeuille à partir d'un mnémonique...
+// Créer une instance de portefeuille à partir d'une phrase mnémonique...
 mnemonic =
   "announce room limb pattern dry unit scale effort smooth jazz weasel alcohol"
 walletMnemonic = Wallet.fromPhrase(mnemonic)
 
-// ...or from a private key
+// ...ou à partir d'une clé privée
 walletPrivateKey = new Wallet(walletMnemonic.privateKey)
 
 walletMnemonic.address === walletPrivateKey.address
-// true
+// vrai
 
-// The address as a Promise per the Signer API
+// L'adresse en tant que promesse selon l'API du signataire
 walletMnemonic.getAddress()
 // { Promise: '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1' }
 
-// A Wallet address is also available synchronously
+// L'adresse d'un portefeuille est également disponible de manière synchrone
 walletMnemonic.address
 // '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1'
 
-// The internal cryptographic components
+// Les composants cryptographiques internes
 walletMnemonic.privateKey
 // '0x1da6847600b0ee25e9ad9a52abbd786dd2502fa4005dd5af9310b7cc7a3b25db'
 walletMnemonic.publicKey
 // '0x04b9e72dfd423bcf95b3801ac93f4392be5ff22143f9980eb78b3a860c4843bfd04829ae61cdba4b3b1978ac5fc64f5cc2f4350e35a108a9c9a92a81200a60cd64'
 
-// The wallet mnemonic
+// La phrase mnémonique du portefeuille
 walletMnemonic.mnemonic
 // {
 //   locale: 'en',
@@ -110,12 +112,12 @@ walletMnemonic.mnemonic
 //   phrase: 'announce room limb pattern dry unit scale effort smooth jazz weasel alcohol'
 // }
 
-// Note: A wallet created with a private key does not
-//       have a mnemonic (the derivation prevents it)
+// Remarque : Un portefeuille créé avec une clé privée n'a pas
+//       de phrase mnémonique (la dérivation l'empêche)
 walletPrivateKey.mnemonic
-// null
+// nul
 
-// Signing a message
+// Signer un message
 walletMnemonic.signMessage("Hello World")
 // { Promise: '0x14280e5885a19f60e536de50097e96e3738c7acae4e9e62d67272d794b8127d31c03d9cd59781d4ee31fb4e1b893bd9b020ec67dfa65cfb51e2bdadbb1de26d91c' }
 
@@ -124,34 +126,34 @@ tx = {
   value: utils.parseEther("1.0"),
 }
 
-// Signing a transaction
+// Signer une transaction
 walletMnemonic.signTransaction(tx)
 // { Promise: '0xf865808080948ba1f109551bd432803012645ac136ddd64dba72880de0b6b3a7640000801ca0918e294306d177ab7bd664f5e141436563854ebe0a3e523b9690b4922bbb52b8a01181612cec9c431c4257a79b8c9f0c980a2c49bb5a0e6ac52949163eeb565dfc' }
 
-// The connect method returns a new instance of the
-// Wallet connected to a provider
+// La méthode connect renvoie une nouvelle instance du
+// portefeuille connecté à un fournisseur
 wallet = walletMnemonic.connect(provider)
 
-// Querying the network
+// Interroger le réseau
 wallet.getBalance()
 // { Promise: { BigNumber: "42" } }
 wallet.getTransactionCount()
 // { Promise: 0 }
 
-// Sending ether
+// Envoyer de l'éther
 wallet.sendTransaction(tx)
 ```
 
-[Lire les documents complets](https://docs.ethers.io/v5/api/signer/#Wallet)
+[Lire la documentation complète](https://docs.ethers.io/v5/api/signer/#Wallet)
 
 Une fois la configuration effectuée, vous pourrez :
 
 - créer un compte ;
 - envoyer des transactions ;
 - signer des transactions ;
-- et plus encore...
+- Et plus encore...
 
-### Interagir avec les fonctions d'un contrat intelligent {#interact-with-smart-contract-functions}
+### Interagir avec les fonctions de contrats intelligents {#interact-with-smart-contract-functions}
 
 Les bibliothèques clientes JavaScript autorisent votre application à appeler des fonctions de contrat intelligent en lisant l'interface binaire d'application (ABI) d'un contrat compilé.
 
@@ -164,7 +166,7 @@ contract Test {
     uint a;
     address d = 0x12345678901234567890123456789012;
 
-    function Test(uint testInt)  { a = testInt;}
+    constructor(uint testInt)  { a = testInt;}
 
     event Event(uint indexed b, bytes32 c);
 
@@ -217,7 +219,7 @@ Cela veut dire que vous pouvez :
 
 Les fonctions utilitaires vous offrent des raccourcis pour améliorer le développement Ethereum.
 
-Les valeurs ETH sont en wei par défaut. 1 ETH = 1 000 000 000 000 000 000 WEI – ça en fait, des chiffres à gérer ! `web3.utils.toWei` convertit l'ether en wei pour vous.
+Les valeurs ETH sont en wei par défaut. 1 ETH = 1 000 000 000 000 000 000 WEI – ça en fait, des chiffres à gérer ! `web3.utils.toWei` convertit l'ether en Wei pour vous.
 
 Et en ethers, cela ressemble à ce qui suit :
 
@@ -232,49 +234,46 @@ ethers.utils.formatEther(balance)
 // '2.337132817842795605'
 ```
 
-- [Fonctions utilitaires Web3js](https://docs.web3js.org/api/web3-utils)
-- [Fonctions utilitaires Ethers](https://docs.ethers.io/v5/api/utils/)
+- [Fonctions utilitaires de Web3js](https://docs.web3js.org/api/web3-utils)
+- [Fonctions utilitaires d'Ethers.js](https://docs.ethers.org/v6/api/utils/)
 
 ## Bibliothèques disponibles {#available-libraries}
 
-**Web3.js -** **_Api JavaScript Ethereum _**
+**Web3.js –** **_API JavaScript d'Ethereum._**
 
-- [Documentation](https://docs.web3js.org/)
-- [GitHub](https://github.com/ethereum/web3.js/)
+- [Documentation](https://docs.web3js.org)
+- [GitHub](https://github.com/ethereum/web3.js)
 
-**Ethers.js -** **_Implémentation complète d'un portefeuille Ethereum, et utilitaires en JavaScript et TypeScript_**
+**Ethers.js –** **_Implémentation complète de portefeuille Ethereum et utilitaires en JavaScript et TypeScript._**
 
-- [Documentation](https://docs.ethers.io/)
-- [GitHub](https://github.com/ethers-io/ethers.js/)
+- [Accueil d'Ethers.js](https://ethers.org/)
+- [Documentation](https://docs.ethers.io)
+- [GitHub](https://github.com/ethers-io/ethers.js)
 
-**The Graph -** **_Protocole permettant d'indexer les données Ethereum et IPFS, et d'exécuter des requêtes sur celles-ci en utilisant GraphQL_**
+**The Graph –** **_Un protocole pour indexer les données d'Ethereum et d'IPFS et les interroger à l'aide de GraphQL._**
 
-- [The Graph](https://thegraph.com/)
-- [Explorateur Graph](https://thegraph.com/explorer/)
-- [Documentation](https://thegraph.com/docs/)
-- [GitHub](https://github.com/graphprotocol/)
+- [The Graph](https://thegraph.com)
+- [Explorateur Graph](https://thegraph.com/explorer)
+- [Documentation](https://thegraph.com/docs)
+- [GitHub](https://github.com/graphprotocol)
 - [Discord](https://thegraph.com/discord)
 
-**light.js -** **_Bibliothèque JS réactive de haut niveau optimisée pour les clients légers_**
-
-- [GitHub](https://github.com/openethereum/js-libs/tree/master/packages/light.js)
-
-**Alchemyweb3 -** **_Enveloppe autour de Web3.js avec nouvelles tentatives automatiques et API améliorées._**
+**Alchemy SDK –** **_Wrapper autour d'Ethers.js avec des API améliorées._**
 
-- [Documentation](https://docs.alchemy.com/reference/api-overview)
-- [GitHub](https://github.com/alchemyplatform/alchemy-web3)
+- [Documentation](https://www.alchemy.com/docs)
+- [GitHub](https://github.com/alchemyplatform/alchemy-sdk-js)
 
-**Alchemy NFT API -** **_API pour récupérer les données NFT, y compris la détention, les attributs de métadonnées et plus encore._**
-
-- [Documentation](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api)
-- [GitHub](https://github.com/alchemyplatform/alchemy-web3)
-
-**viem -** **_Interface TypeScript pour Ethereum._**
+**viem –** **_Interface TypeScript pour Ethereum._**
 
 - [Documentation](https://viem.sh)
 - [GitHub](https://github.com/wagmi-dev/viem)
 
-## Complément d'information {#further-reading}
+**Drift –** **_Méta-bibliothèque TypeScript avec mise en cache, hooks et mocks de test intégrés._**
+
+- [Documentation](https://ryangoree.github.io/drift/)
+- [GitHub](https://github.com/ryangoree/drift/)
+
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
@@ -285,6 +284,6 @@ _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Configurer Web3js pour utiliser la blockchain Ethereum avec JavaScript](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/)_ - Instructions pour installer et intégrer Web3js à votre projet_
-- [Appel d'un contrat intelligent à partir de JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _ - À l'aide du jeton DAI, découvrez comment appeler une fonction de contrat en utilisant JavaScript._
-- [Envoi des transactions en utilisant Web3 et Alchemy](/developers/tutorials/sending-transactions-using-Web3-and-alchemy/) _ - Procédure étape par étape pour envoyer des transactions depuis le backend._
+- [Configurer Web3js pour utiliser la blockchain Ethereum avec JavaScript](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/) _– Instructions pour installer et intégrer web3.js dans votre projet._
+- [Appeler un contrat intelligent depuis JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _– À l'aide du jeton DAI, découvrez comment appeler des fonctions de contrat en JavaScript._
+- [Envoyer des transactions avec web3 et Alchemy](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) _– Guide pas à pas pour envoyer des transactions depuis le backend._
diff --git a/public/content/translations/fr/developers/docs/apis/json-rpc/index.md b/public/content/translations/fr/developers/docs/apis/json-rpc/index.md
index 727b550bb1e..075edd61c13 100644
--- a/public/content/translations/fr/developers/docs/apis/json-rpc/index.md
+++ b/public/content/translations/fr/developers/docs/apis/json-rpc/index.md
@@ -1,36 +1,36 @@
 ---
 title: API JSON-RPC
-description: Un protocole allégé de procédure à distance (RPC) pour les clients Ethereum.
+description: "Un protocole allégé de procédure à distance (RPC) pour les clients Ethereum."
 lang: fr
 ---
 
 Afin qu'une application logicielle interagisse avec la blockchain Ethereum (en lisant les données de la blockchain ou en envoyant des transactions au réseau), elle doit se connecter à un nœud Ethereum.
 
-À cet effet, chaque [client Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implémente une [spécification JSON-RPC](https://github.com/ethereum/execution-apis), ainsi il existe un ensemble uniforme de méthodes sur lesquelles les applications peuvent s'appuyer en fonction des spécificités du nœud ou de l'implémentation client.
+À cette fin, chaque [client Ethereum](/developers/docs/nodes-and-clients/#execution-clients) met en œuvre une [spécification JSON-RPC](https://github.com/ethereum/execution-apis), de sorte qu'il existe un ensemble uniforme de méthodes sur lesquelles les applications peuvent s'appuyer, quelle que soit l'implémentation spécifique du nœud ou du client.
 
-[JSON-RPC](https://www.jsonrpc.org/specification) est un protocole léger de procédure d'appel à distance (RPC). Il définit plusieurs structures de données et les règles entourant leur traitement. C'est un système de transport agnostique en ce sens que les concepts peuvent être utilisés dans le même processus, via les sockets et HTTP, ou dans de nombreux environnements de passage de messages. Il utilise JSON (RFC 4627) comme format de données.
+[JSON-RPC](https://www.jsonrpc.org/specification) est un protocole d'appel de procédure à distance (RPC) léger et sans état. Il définit plusieurs structures de données et les règles entourant leur traitement. C'est un système de transport agnostique en ce sens que les concepts peuvent être utilisés dans le même processus, via les sockets et HTTP, ou dans de nombreux environnements de passage de messages. Il utilise JSON (RFC 4627) comme format de données.
 
-## Implémentations de client {#client-implementations}
+## Implémentations du client {#client-implementations}
 
-Les clients Ethereum peuvent chacun utiliser différents langages de programmation lors de l'implémentation de la spécification JSON-RPC. Consultez la documentation individuelle [client](/developers/docs/nodes-and-clients/#execution-clients) pour plus de détails concernant des langages de programmation spécifiques. Nous vous recommandons de consulter la documentation de chaque client pour connaître les dernières informations de support de l'API.
+Les clients Ethereum peuvent chacun utiliser différents langages de programmation lors de l'implémentation de la spécification JSON-RPC. Consultez la [documentation de chaque client](/developers/docs/nodes-and-clients/#execution-clients) pour plus de détails sur les langages de programmation spécifiques. Nous vous recommandons de consulter la documentation de chaque client pour connaître les dernières informations de support de l'API.
 
-## Bibliothèques pratiques {#convenience-libraries}
+## Bibliothèques de commodité {#convenience-libraries}
 
-Bien que vous puissiez choisir d'interagir directement avec les clients Ethereum via l'API JSON-RPC, il y a souvent des options plus faciles pour les développeurs de dapp. De nombreuses librairies [JavaScript](/developers/docs/apis/javascript/#available-libraries) et [backend API](/developers/docs/apis/backend/#available-libraries) existent pour fournir des wrappers sur l'API JSON-RPC. Avec ces bibliothèques, les développeurs peuvent écrire de manières intuitives des méthodes d'une seule ligne pour initialiser les requêtes JSON-RPC (sans avoir besoin d'en voir les détails) qui interagissent avec Ethereum.
+Bien que vous puissiez choisir d'interagir directement avec les clients Ethereum via l'API JSON-RPC, il y a souvent des options plus faciles pour les développeurs de dapp. Il existe de nombreuses bibliothèques [JavaScript](/developers/docs/apis/javascript/#available-libraries) et [API backend](/developers/docs/apis/backend/#available-libraries) qui fournissent des wrappers en plus de l'API JSON-RPC. Avec ces bibliothèques, les développeurs peuvent écrire de manières intuitives des méthodes d'une seule ligne pour initialiser les requêtes JSON-RPC (sans avoir besoin d'en voir les détails) qui interagissent avec Ethereum.
 
-## API client de consensus {#consensus-clients}
+## API du client de consensus {#consensus-clients}
 
-Cette page traite principalement de l'API JSON-RPC utilisée par les clients d'exécution Ethereum. Cependant, les clients de consensus ont également une API RPC qui permet aux utilisateurs de interroger des informations sur le nœud, demander des blocs de balises, l'état de la balise et d'autres informations liées au consensus directement depuis un nœud. Cette API est documentée sur la [page Web de l'API de la chaîne phare](https://ethereum.github.io/beacon-APIs/#/).
+Cette page traite principalement de l'API JSON-RPC utilisée par les clients d'exécution Ethereum. Cependant, les clients de consensus ont également une API RPC qui permet aux utilisateurs de interroger des informations sur le nœud, demander des blocs de balises, l'état de la balise et d'autres informations liées au consensus directement depuis un nœud. Cette API est documentée sur la [page Web de l'API Beacon](https://ethereum.github.io/beacon-APIs/#/).
 
-Une API interne est également utilisée pour la communication entre les clients dans un noeud - c'est-à-dire permet au client de consensus et au client d'exécution d'échanger des données. Cela s'appelle une « API moteur » et les spécifications sont disponibles sur [GitHub](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md).
+Une API interne est également utilisée pour la communication entre les clients dans un noeud - c'est-à-dire permet au client de consensus et au client d'exécution d'échanger des données. C'est ce qu'on appelle l'« API Engine » et les spécifications sont disponibles sur [GitHub](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md).
 
-## Spécifications de client d'exécution {#spec}
+## Spécification du client d'exécution {#spec}
 
-[Lisez la spécification complète de l'API JSON-RPC sur GitHub](https://github.com/ethereum/execution-apis). Cette API est documentée sur la [page web d'exécution API](https://ethereum.github.io/execution-apis/api-documentation/) et comprend un inspecteur pour tester toutes les méthodes disponibles.
+[Lisez la spécification complète de l'API JSON-RPC sur GitHub](https://github.com/ethereum/execution-apis). Cette API est documentée sur la [page Web de l'API d'exécution](https://ethereum.github.io/execution-apis/) et comprend un inspecteur pour essayer toutes les méthodes disponibles.
 
 ## Conventions {#conventions}
 
-### Encodage hexadécimal {#hex-encoding}
+### Encodage des valeurs hexadécimales {#hex-encoding}
 
 Deux types de données clés sont passés par JSON : des tableaux d'octets non formatés et des quantités. Les deux sont passés avec un encodage hexadécimal mais avec des formatages différents.
 
@@ -58,9 +58,9 @@ Voici quelques exemples :
 - FAUX : 0xf0f0f (doit avoir un nombre pair de chiffres)
 - FAUX : 004200 (doit être préfixé par 0x)
 
-### Le paramètre de bloc par défaut {#default-block}
+### Le paramètre de bloc {#block-parameter}
 
-Les méthodes suivantes ont un paramètre de bloc par défaut supplémentaire :
+Les méthodes suivantes possèdent un paramètre de bloc :
 
 - [eth_getBalance](#eth_getbalance)
 - [eth_getCode](#eth_getcode)
@@ -68,26 +68,27 @@ Les méthodes suivantes ont un paramètre de bloc par défaut supplémentaire :
 - [eth_getStorageAt](#eth_getstorageat)
 - [eth_call](#eth_call)
 
-Lorsque des requêtes qui agissent sur l'état d'Ethereum sont exécutées, le dernier paramètre de bloc par défaut détermine la hauteur du bloc.
+Lorsqu’une requête interroge l’état d’Ethereum, le paramètre de bloc fourni détermine la hauteur du bloc.
 
-Les options suivantes sont possibles pour le paramètre defaultBlock :
+Les options suivantes sont possibles pour le paramètre de bloc :
 
-- `chaîne HEX` - un nombre de bloc entier
-- `Chaîne « earliest »` pour le bloc d'origine/le plus ancien
-- `String "latest"` - pour le dernier bloc proposé
-- `Chaine « latest »` - pour le dernier bloc de tête sûr
-- `Chaîne « finalized »` - pour le dernier bloc finalisé
-- `Chaîne "pending"` - pour l'état ou les transactions en attente
+- `Chaîne HEX` - un numéro de bloc entier
+- `Chaîne \"earliest\"` pour le bloc le plus ancien/d'origine
+- `Chaîne \"latest\"` - pour le dernier bloc proposé
+- `Chaîne \"safe\"` - pour le dernier bloc de tête sûr
+- `Chaîne \"finalized\"` - pour le dernier bloc finalisé
+- `Chaîne \"pending\"` - pour l'état ou les transactions en attente
 
 ## Exemples
 
-Sur cette page, nous fournissons des exemples d'utilisation des points de terminaison individuels de l'API JSON_RPC à l'aide de l'outil de ligne de commande, [curl](https://curl.se). Ces exemples de points de terminaison individuels se trouvent ci-dessous dans la section [Exemples Curl](#curl-examples). Plus bas sur la page, nous fournissons également un [exemple de bout en bout](#usage-example) pour compiler et déployer un contrat intelligent à l'aide d'un nœud Geth, de l'API JSON_RPC et de curl.
+Sur cette page, nous fournissons des exemples sur la façon d'utiliser des points de terminaison individuels de l'API JSON-RPC en utilisant l'outil de ligne de commande, [curl](https://curl.se). Ces exemples de points de terminaison individuels se trouvent ci-dessous dans la section [Exemples de Curl](#curl-examples). Plus bas sur la page, nous fournissons également un [exemple de bout en bout](#usage-example) pour compiler et déployer un contrat intelligent en utilisant un nœud Geth, l'API JSON-RPC et curl.
 
 ## Exemples de Curl {#curl-examples}
 
-Des exemples d'utilisation de l'API JSON_RPC en effectuant des requêtes [curl](https://curl.se) vers un nœud Ethereum sont fournis ci-dessous. Chaque exemple comprend une description du point de terminaison spécifique, de ses paramètres, du type de retour et un exemple concret de son utilisation.
+Des exemples d'utilisation de l'API JSON-RPC en faisant des requêtes [curl](https://curl.se) à un nœud Ethereum sont fournis ci-dessous. Chaque exemple
+comprend une description du point de terminaison spécifique, de ses paramètres, du type de retour et un exemple concret de son utilisation.
 
-Les requêtes curl peuvent retourner un message d'erreur relatif au type de contenu. Ceci est dû au fait que l'option `--data` définit le type de contenu à `application/x-www-form-urlencoded`. Si votre nœud se plaint à ce sujet, définissez manuellement l'en-tête en plaçant `-H "Content-Type: application/json"` au début de l'appel. Les exemples ne comprennent pas non plus la combinaison URL/IP & port qui doit être le dernier argument donné à curl ( par exemple : `127.0.0.1:8545`). Une requête curl complète incluant ces données supplémentaires prend la forme suivante :
+Les requêtes curl peuvent retourner un message d'erreur relatif au type de contenu. C'est parce que l'option `--data` définit le type de contenu à `application/x-www-form-urlencoded`. Si votre nœud se plaint de cela, définissez manuellement l'en-tête en plaçant `-H \"Content-Type: application/json\"` au début de l'appel. Les exemples n'incluent pas non plus la combinaison URL/IP et port qui doit être le dernier argument donné à curl (par exemple, `127.0.0.1:8545`). Une requête curl complète incluant ces données supplémentaires prend la forme suivante :
 
 ```shell
 curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":67}' 127.0.0.1:8545
@@ -95,7 +96,7 @@ curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","metho
 
 ## Gossip, État, Historique {#gossip-state-history}
 
-Une poignée de méthodes JSON-RPC de base nécessitent des données du réseau Ethereum, et se classent aisément dans 3 catégories principales : _Gossip, État, Historique_. Utilisez les liens dans ces sections pour passer à chaque méthode, ou utilisez la table des matières pour explorer la liste complète des méthodes.
+Une poignée de méthodes JSON-RPC de base nécessitent des données du réseau Ethereum et se classent nettement dans trois catégories principales : _Gossip, État et Historique_. Utilisez les liens dans ces sections pour passer à chaque méthode, ou utilisez la table des matières pour explorer la liste complète des méthodes.
 
 ### Méthodes Gossip {#gossip-methods}
 
@@ -134,9 +135,9 @@ Une poignée de méthodes JSON-RPC de base nécessitent des données du réseau
 
 ## Terrain de jeu pour l'API JSON-RPC
 
-Vous pouvez utiliser [l'outil de terrain de jeu](https://ethereum-json-rpc.com) pour découvrir et tester les méthodes de l'API. Cela vous montre également quelles méthodes et réseaux sont pris en charge par les différents fournisseurs de nœud.
+Vous pouvez utiliser l'[outil de terrain de jeu](https://ethereum-json-rpc.com) pour découvrir et essayer les méthodes de l'API. Cela vous montre également quelles méthodes et réseaux sont pris en charge par les différents fournisseurs de nœud.
 
-## Méthodes API JSON-RPC {#json-rpc-methods}
+## Méthodes de l'API JSON-RPC {#json-rpc-methods}
 
 ### web3_clientVersion {#web3_clientversion}
 
@@ -146,11 +147,11 @@ Retourne la version courante du client.
 
 Aucun
 
-**Valeur de retour**
+**Retours**
 
-`String` - La version actuelle du client
+`Chaîne` - La version actuelle du client
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -165,26 +166,26 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],
 
 ### web3_sha3 {#web3_sha3}
 
-Retourne le Keccak-256 (_non pas_ le SHA3-256 standard) des données.
+Renvoie le Keccak-256 (_pas_ le SHA3-256 normalisé) des données fournies.
 
 **Paramètres**
 
-1. `DATA` - Les données à convertir en hachage SHA3
+1. `DONNÉES` - Les données à convertir en hachage SHA3
 
 ```js
 params: ["0x68656c6c6f20776f726c64"]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`DATA` - Le résultat SHA3 pour la chaîne donnée.
+`DONNÉES` - Le résultat SHA3 de la chaîne donnée.
 
-**Exemple**
+**Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"web3_sha3","params":["0x68656c6c6f20776f726c64"],"id":64}'
-// Result
+// Résultat
 {
   "id":64,
   "jsonrpc": "2.0",
@@ -198,24 +199,24 @@ Retourne l'identifiant du réseau actuel.
 
 **Paramètres**
 
-Aucune
+Aucun
 
 **Retours**
 
-`String` - L'id actuelle du réseau.
+`Chaîne` - L'ID de réseau actuel.
 
-La liste complète des identifiants de réseau actuels est disponible à l'adresse suivante : [chainlist.org](https://chainlist.org). Quelques spécifications habituelles sont :
+La liste complète des ID de réseau actuels est disponible sur [chainlist.org](https://chainlist.org). Quelques spécifications habituelles sont :
 
-- `1`: réseau principal Ethereum
-- `11155111`: Réseau de test Sepolia
-- `560048`: Réseau de test Hoodi
+- `1` : Réseau principal Ethereum
+- `11155111` : Réseau de test Sepolia
+- `560048` : Réseau de test Hoodi
 
-**Exemple**
+**Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"net_version","params":[],"id":67}'
-// Result
+// Résultat
 {
   "id":67,
   "jsonrpc": "2.0",
@@ -229,18 +230,18 @@ Retourne `true` si le client écoute activement les connexions réseau.
 
 **Paramètres**
 
-Aucune
+Aucun
 
 **Retours**
 
-`Boolean` - `true` lors de l'écoute, sinon `false`.
+`Booléen` - `true` lors de l'écoute, sinon `false`.
 
-**Exemple**
+**Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"net_listening","params":[],"id":67}'
-// Result
+// Résultat
 {
   "id":67,
   "jsonrpc":"2.0",
@@ -254,18 +255,18 @@ Retourne le nombre de pairs actuellement connectés au client.
 
 **Paramètres**
 
-Aucune
+Aucun
 
 **Retours**
 
-`QUANTITY` - nombre entier du nombre de pairs connectés.
+`QUANTITÉ` - nombre entier de pairs connectés.
 
-**Exemple**
+**Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":74}'
-// Result
+// Résultat
 {
   "id":74,
   "jsonrpc": "2.0",
@@ -279,18 +280,18 @@ Retourne la version actuelle du protocole Ethereum. Notez que cette méthode n'e
 
 **Paramètres**
 
-Aucune
+Aucun
 
 **Retours**
 
-`String` - La version actuelle du protocole Ethereum
+`Chaîne` - La version actuelle du protocole Ethereum
 
-**Exemple**
+**Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"eth_protocolVersion","params":[],"id":67}'
-// Result
+// Résultat
 {
   "id":67,
   "jsonrpc": "2.0",
@@ -300,21 +301,25 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_protocolVersion","params":[]
 
 ### eth_syncing {#eth_syncing}
 
-Renvoie un objet contenant des données sur l'état de la synchronisation ou `false`.
+Renvoie un objet avec des données sur l'état de synchronisation ou `false`.
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_syncing">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-Aucune
+Aucun
 
 **Retours**
 
-Les données précises renvoyées varient entre les différentes implémentations de clients. Tous les clients renvoient `False` lorsque le nœud n'est pas en synchronisation, et tous les clients renvoient les champs suivants.
+Les données précises renvoyées varient entre les différentes implémentations de clients. Tous les clients retournent `False` lorsque le nœud n'est pas en cours de synchronisation, et tous les clients retournent les champs suivants.
 
-`Objet|Booléen`, un objet avec des données sur l'état de la synchronisation ou `FALSE`, s'il n'y a pas de synchronisation :
+`Objet|Booléen`, un objet avec des données d'état de synchronisation ou `FALSE` lorsque la synchronisation n'a pas lieu :
 
-- `startingBlock`: `QUANTITY` - Le bloc où l'importation a commencé (ne sera remis à zéro que lorsque la synchronisation aura atteint sa tête)
-- `currentBlock`: `QUANTITY` - Le bloc actuel, identique à eth_blockNumber
-- `highestBlock`: `QUANTITY` - Le bloc estimé le plus élevé
+- `startingBlock` : `QUANTITÉ` - le bloc où l'importation a commencé (ne sera réinitialisé qu'une fois que la synchronisation aura atteint sa tête)
+- `currentBlock` : `QUANTITÉ` - le bloc actuel, identique à eth_blockNumber
+- `highestBlock` : `QUANTITÉ` - le plus haut bloc estimé
 
 Cependant, chaque client peut également fournir des données supplémentaires. Par exemple, Geth renvoie les informations suivantes :
 
@@ -359,7 +364,7 @@ Alors que Besu renvoie :
 
 Reportez-vous à la documentation de votre client spécifique pour plus de détails.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -386,17 +391,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}
 
 Renvoie l'adresse coinbase du client.
 
-> **Note :** Cette méthode est obsolète depuis la version **v1.14.0** et n'est plus prise en charge. Essayer d’utiliser cette méthode entraînera une erreur « Méthode non prise en charge ».
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_coinbase">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
+> **Remarque :** Cette méthode est obsolète depuis la **v1.14.0** et n'est plus prise en charge. Essayer d’utiliser cette méthode entraînera une erreur « Méthode non prise en charge ».
 
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`DATA`, 20 octets - l'adresse actuelle de coinbase.
+`DONNÉES`, 20 octets - l'adresse coinbase actuelle.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -413,15 +422,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":6
 
 Retourne la chaîne ID utilisée pour la signature d'opérations protégées par la rediffusion.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_chainId">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`chainId`, valeur hexadécimale comme une chaîne représentant le nombre entier de l'id de la chaîne courante.
+`chainId`, valeur hexadécimale sous forme de chaîne représentant l'entier de l'ID de la chaîne actuelle.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -436,17 +449,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67
 
 ### eth_mining {#eth_mining}
 
-Retourne `true` si le client est en train de miner activement de nouveaux blocs. Cela ne peut renvoyer que `vrai` pour les réseaux en preuve de travail et peut ne pas être disponible dans certains clients depuis [La Fusion](/roadmap/merge/).
+Retourne `true` si le client mine activement de nouveaux blocs. Cela ne peut renvoyer `true` que pour les réseaux à preuve de travail et peut ne pas être disponible dans certains clients depuis [La Fusion](/roadmap/merge/).
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_mining">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`Boolean` - renvoie `true` du client en train de miner, sinon `false`.
+`Booléen` - renvoie `true` si le client mine, sinon `false`.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -461,17 +478,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_mining","params":[],"id":71}
 
 ### eth_hashrate {#eth_hashrate}
 
-Retourne le nombre de hachages par seconde avec lesquels le nœud est miné. Cela ne peut renvoyer que `vrai` pour les réseaux en preuve de travail et peut ne pas être disponible dans certains clients depuis [La Fusion](/roadmap/merge/).
+Retourne le nombre de hachages par seconde avec lesquels le nœud est miné. Cela ne peut renvoyer `true` que pour les réseaux à preuve de travail et peut ne pas être disponible dans certains clients depuis [La Fusion](/roadmap/merge/).
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_hashrate">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre de hachages par seconde.
+`QUANTITÉ` - nombre de hachages par seconde.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -488,15 +509,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":7
 
 Retourne une estimation du prix actuel de gaz en wei. Par exemple, le client Besu examine les 100 derniers blocs et renvoie le prix médian du gaz en unité par défaut.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_gasPrice">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - entier du prix actuel du gaz en wei.
+`QUANTITÉ` - entier du prix actuel du gaz en wei.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -513,15 +538,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":7
 
 Renvoie une liste d'adresses appartenant au client.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_accounts">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`Array of DATA`, 20 octets - adresses appartenant au client.
+`Tableau de DONNÉES`, 20 Octets - adresses appartenant au client.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -538,15 +567,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1
 
 Renvoie le numéro du bloc le plus récent.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_blockNumber">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-Aucune
+Aucun
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du numéro de bloc actuel sur lequel se trouve le client.
+`QUANTITÉ` - entier du numéro de bloc actuel sur lequel se trouve le client.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -561,22 +594,26 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id
 
 ### eth_getBalance {#eth_getbalance}
 
-Renvoie le solde du compte de l'adresse donnée.
+Renvoie le solde du compte à une adresse donnée.
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getBalance">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-1. `DATA`, 20 octets - adresse pour vérifier le solde.
-2. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block)
+1. `DONNÉES`, 20 octets - adresse pour vérifier le solde.
+2. `QUANTITÉ|TAG` - numéro de bloc entier, ou la chaîne `\"latest\"`, `\"earliest\"`, `\"pending\"`, `\"safe\"`, ou `\"finalized\"`, voir le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter)
 
 ```js
 params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du solde actuel en wei.
+`QUANTITÉ` - entier du solde actuel en wei.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -593,30 +630,35 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407
 
 Renvoie la valeur d'une position de stockage à une adresse donnée.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getStorageAt">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 20 octets - adresse du stockage.
-2. `QUANTITY` - nombre entier de la position dans le stockage.
-3. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block)
+1. `DONNÉES`, 20 octets - adresse du stockage.
+2. `QUANTITÉ` - entier de la position dans le stockage.
+3. `QUANTITÉ|TAG` - numéro de bloc entier, ou la chaîne `\"latest\"`, `\"earliest\"`, `\"pending\"`, `\"safe\"`, `\"finalized\"`, voir le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter)
 
-**Valeur de retour**
+**Retours**
 
-`DATA` - la valeur à cette position de stockage.
+`DONNÉES` - la valeur à cette position de stockage.
 
-**Exemple** Le calcul de la position correcte dépend du stockage à récupérer. Considérons le contrat suivant déployé à `0x295a70b2de5e3953354a6a8344e616ed314d7251` par l'adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298`.
+**Exemple**
+Le calcul de la position correcte dépend du stockage à récupérer. Considérez le contrat suivant déployé à l'adresse `0x295a70b2de5e3953354a6a8344e616ed314d7251` par l'adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298`.
 
 ```
 contract Storage {
     uint pos0;
-    mapping(address => uint) pos1;
-    function Storage() {
+    mapping(adresse => uint) pos1;
+    constructor() {
         pos0 = 1234;
         pos1[msg.sender] = 5678;
     }
 }
 ```
 
-La récupération de la valeur pos0 est simple :
+Récupérer la valeur de pos0 est simple :
 
 ```js
 curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545
@@ -658,12 +700,16 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [
 
 ### eth_getTransactionCount {#eth_gettransactioncount}
 
-Renvoie le nombre de transactions _envoyées_ à partir d'une adresse.
+Renvoie le nombre de transactions _envoyées_ depuis une adresse.
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getTransactionCount">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-1. `DATA`, 20 octets - adresse.
-2. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block)
+1. `DONNÉES`, 20 octets - adresse.
+2. `QUANTITÉ|TAG` - numéro de bloc entier, ou la chaîne `\"latest\"`, `\"earliest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, voir le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter)
 
 ```js
 params: [
@@ -672,11 +718,11 @@ params: [
 ]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du nombre de transactions envoyées depuis cette adresse.
+`QUANTITÉ` - entier du nombre de transactions envoyées depuis cette adresse.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -693,19 +739,23 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params
 
 Renvoie le nombre de transactions dans un bloc à partir d'un bloc correspondant au hachage de bloc donné.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getBlockTransactionCountByHash">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 32 octets - hachage d'un bloc
+1. `DONNÉES`, 32 octets - hachage d'un bloc
 
 ```js
 params: ["0xd03ededb7415d22ae8bac30f96b2d1de83119632693b963642318d87d1bece5b"]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du nombre de transactions dans ce bloc.
+`QUANTITÉ` - entier du nombre de transactions dans ce bloc.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -722,9 +772,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHa
 
 Renvoie le nombre de transactions dans un bloc correspondant au numéro de bloc donné.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getBlockTransactionCountByNumber">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block).
+1. `QUANTITÉ|TAG` - entier d'un numéro de bloc, ou la chaîne `\"earliest\"`, `\"latest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, comme dans le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter).
 
 ```js
 params: [
@@ -732,11 +786,11 @@ params: [
 ]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du nombre de transactions dans ce bloc.
+`QUANTITÉ` - entier du nombre de transactions dans ce bloc.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -753,19 +807,23 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByNu
 
 Renvoie le nombre d'oncles dans un bloc à partir d'un bloc correspondant au hachage de bloc donné.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getUncleCountByBlockHash">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 32 octets - hachage d'un bloc
+1. `DONNÉES`, 32 octets - hachage d'un bloc
 
 ```js
 params: ["0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2"]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du nombre d'oncles dans ce bloc.
+`QUANTITÉ` - entier du nombre d'oncles dans ce bloc.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -782,9 +840,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","p
 
 Renvoie le nombre d'oncles dans un bloc à partir d'un bloc correspondant au numéro de bloc donné.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getUncleCountByBlockNumber">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block)
+1. `QUANTITÉ|TAG` - entier d'un numéro de bloc, ou la chaîne `\"latest\"`, `\"earliest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, voir le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter)
 
 ```js
 params: [
@@ -792,11 +854,11 @@ params: [
 ]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - nombre entier du nombre d'oncles dans ce bloc.
+`QUANTITÉ` - entier du nombre d'oncles dans ce bloc.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -813,10 +875,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockNumber",
 
 Renvoie le code à une adresse donnée.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getCode">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 20 octets - adresse
-2. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block)
+1. `DONNÉES`, 20 octets - adresse
+2. `QUANTITÉ|TAG` - numéro de bloc entier, ou la chaîne `\"latest\"`, `\"earliest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, voir le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter)
 
 ```js
 params: [
@@ -825,11 +891,11 @@ params: [
 ]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`DATA` - le code issu de l'adresse donnée.
+`DONNÉES` - le code de l'adresse donnée.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -844,22 +910,22 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCode","params":["0xC02aaA
 
 ### eth_sign {#eth_sign}
 
-La méthode du signe calcule une signature spécifique à Ethereum avec : `sign(keccak256("\x19Message signé Ethereum :\n" + len(message) + message)))`.
+La méthode de signature calcule une signature spécifique à Ethereum avec : `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`.
 
-En ajoutant un préfixe au message, la signature calculée peut être reconnue comme une signature spécifique à Ethereum. Cela empêche l'utilisation abusive où une DApp malveillante peut signer des données arbitraires (par exemple une transaction) et utiliser la signature pour usurper l'identité de la victime.
+En ajoutant un préfixe au message, la signature calculée peut être reconnue comme une signature spécifique à Ethereum. Cela empêche une utilisation abusive où une dapp malveillante peut signer des données arbitraires (par exemple, une transaction) et utiliser la signature pour usurper l'identité de la victime.
 
 Remarque : l'adresse avec laquelle signer doit être déverrouillée.
 
 **Paramètres**
 
-1. `DATA`, 20 octets - adresse
-2. `DATA`, N octets - message à signer
+1. `DONNÉES`, 20 octets - adresse
+2. `DONNÉES`, N octets - message à signer
 
-**Valeur de retour**
+**Retours**
 
-`DATA` : Signature
+`DONNÉES` : Signature
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -874,26 +940,26 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d37
 
 ### eth_signTransaction {#eth_signtransaction}
 
-Signale une transaction qui peut être soumise au réseau plus tard en utilisant [eth_sendRawTransaction](#eth_sendrawtransaction).
+Signe une transaction qui pourra être soumise ultérieurement au réseau en utilisant [eth_sendRawTransaction](#eth_sendrawtransaction).
 
 **Paramètres**
 
-1. `Object` - L'objet de la transaction
+1. `Objet` - L'objet de la transaction
 
-- `type`:
-- `from`: `DATA`, 20 octets - L'adresse à partir de laquelle la transaction est envoyée.
-- `to`: `DATA`, 20 octets - (optionnel lors de la création d'un nouveau contrat) L'adresse vers laquelle la transaction est orientée.
-- `gaz` : `QUANTITY` - (facultatif, par défaut : 90 000) Nombre entier du gaz fourni pour l'exécution de la transaction. Il retournera du gaz inutilisé.
-- `gasPrice` : `QUANTITY` - (facultatif, par défaut : To-Be-Determined) Nombre entier du prix du gaz utilisé pour chaque gaz payé, à Wei.
-- `value`: `QUANTITY` - (facultatif) Nombre entier de la valeur envoyée avec cette transaction, dans Wei.
-- `data` : `DATA` - Le code compilé d'un contrat OU le hachage de la signature de la méthode invoquée et des paramètres encodés.
-- `nonce` : `QUANTITY` - (facultatif) Entier d'un nonce. Cela permet d'écraser vos propres transactions en attente qui utilisent le même nonce.
+- `type` :
+- `from` : `DONNÉES`, 20 octets - L'adresse depuis laquelle la transaction est envoyée.
+- `to` : `DONNÉES`, 20 octets - (facultatif lors de la création d'un nouveau contrat) L'adresse à laquelle la transaction est destinée.
+- `gas` : `QUANTITÉ` - (facultatif, par défaut : 90000) Entier du gaz fourni pour l'exécution de la transaction. Il retournera du gaz inutilisé.
+- `gasPrice` : `QUANTITÉ` - (facultatif, par défaut : à déterminer) Entier du gasPrice utilisé pour chaque gaz payé, en Wei.
+- `value` : `QUANTITÉ` - (facultatif) Entier de la valeur envoyée avec cette transaction, en Wei.
+- `data` : `DONNÉES` - Le code compilé d'un contrat OU le hachage de la signature de la méthode invoquée et des paramètres encodés.
+- `nonce` : `QUANTITÉ` - (facultatif) Entier d'un nonce. Cela permet d'écraser vos propres transactions en attente qui utilisent le même nonce.
 
-**Valeur de retour**
+**Retours**
 
-`DATA`, L'objet de transaction encodé en RLP signé par le compte spécifié.
+`DONNÉES`, l'objet de transaction encodé en RLP signé par le compte spécifié.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -908,19 +974,19 @@ curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction","
 
 ### eth_sendTransaction {#eth_sendtransaction}
 
-Crée une nouvelle transaction d'appel ou une création de contrat, si le champ de données contient du code, et la signe en utilisant le compte spécifié dans `from`.
+Crée une nouvelle transaction d'appel de message ou une création de contrat, si le champ de données contient du code, et la signe en utilisant le compte spécifié dans `from`.
 
 **Paramètres**
 
-1. `Object` - L'objet de la transaction
+1. `Objet` - L'objet de la transaction
 
-- `from`: `DATA`, 20 octets - L'adresse à partir de laquelle la transaction est envoyée.
-- `to`: `DATA`, 20 octets - (optionnel lors de la création d'un nouveau contrat) L'adresse vers laquelle la transaction est orientée.
-- `gaz` : `QUANTITY` - (facultatif, par défaut : 90 000) Nombre entier du gaz fourni pour l'exécution de la transaction. Il retournera du gaz inutilisé.
-- `gasPrice` : `QUANTITY` - (facultatif, par défaut : To-Be-Determined) Nombre entier du prix du gaz utilisé pour chaque gaz payé.
-- `value` : `QUANTITY` - (facultatif) Nombre entier de la valeur envoyée avec cette transaction.
-- `input` : `DATA` - Le code compilé d'un contrat OU le hachage de la signature de la méthode invoquée et des paramètres encodés.
-- `nonce` : `QUANTITY` - (facultatif) Entier d'un nonce. Cela permet d'écraser vos propres transactions en attente qui utilisent le même nonce.
+- `from` : `DONNÉES`, 20 octets - L'adresse depuis laquelle la transaction est envoyée.
+- `to` : `DONNÉES`, 20 octets - (facultatif lors de la création d'un nouveau contrat) L'adresse à laquelle la transaction est destinée.
+- `gas` : `QUANTITÉ` - (facultatif, par défaut : 90000) Entier du gaz fourni pour l'exécution de la transaction. Il retournera du gaz inutilisé.
+- `gasPrice` : `QUANTITÉ` - (facultatif, par défaut : à déterminer) Entier du gasPrice utilisé pour chaque gaz payé.
+- `value` : `QUANTITÉ` - (facultatif) Entier de la valeur envoyée avec cette transaction.
+- `input` : `DONNÉES` - Le code compilé d'un contrat OU le hachage de la signature de la méthode invoquée et des paramètres encodés.
+- `nonce` : `QUANTITÉ` - (facultatif) Entier d'un nonce. Cela permet d'écraser vos propres transactions en attente qui utilisent le même nonce.
 
 ```js
 params: [
@@ -936,13 +1002,13 @@ params: [
 ]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`DATA`, 32 octets - le hachage de la transaction, ou le hachage zéro si la transaction n'est pas encore disponible.
+`DONNÉES`, 32 octets - le hachage de la transaction, ou le hachage zéro si la transaction n'est pas encore disponible.
 
-Utilisez [eth_getTransactionReceipt](#eth_gettransactionreceipt) pour obtenir l'adresse du contrat, après que la transaction a été proposée dans un block, lorsque vous avez créé un contrat.
+Utilisez [eth_getTransactionReceipt](#eth_gettransactionreceipt) pour obtenir l'adresse du contrat, une fois que la transaction a été proposée dans un bloc, lorsque vous avez créé un contrat.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -961,7 +1027,7 @@ Crée une nouvelle transaction d'appel de message ou une création de contrat po
 
 **Paramètres**
 
-1. `DATA`, Les données de transaction signées.
+1. `DONNÉES`, les données de transaction signées.
 
 ```js
 params: [
@@ -969,13 +1035,13 @@ params: [
 ]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`DATA`, 32 octets - le hachage de la transaction, ou le hachage zéro si la transaction n'est pas encore disponible.
+`DONNÉES`, 32 octets - le hachage de la transaction, ou le hachage zéro si la transaction n'est pas encore disponible.
 
-Utilisez [eth_getTransactionReceipt](#eth_gettransactionreceipt) pour obtenir l'adresse du contrat, après que la transaction a été proposée dans un block, lorsque vous avez créé un contrat.
+Utilisez [eth_getTransactionReceipt](#eth_gettransactionreceipt) pour obtenir l'adresse du contrat, une fois que la transaction a été proposée dans un bloc, lorsque vous avez créé un contrat.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -990,26 +1056,30 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params"
 
 ### eth_call {#eth_call}
 
-Exécute un nouvel appel de message immédiatement sans créer de transaction sur la chaîne de blocs. Souvent utilisé pour exécuter des fonctions de contrat intelligent en lecture seule, par exemple le `balanceOf` pour un contrat ERC-20.
+Exécute un nouvel appel de message immédiatement sans créer de transaction sur la chaîne de blocs. Souvent utilisé pour exécuter des fonctions de contrat intelligent en lecture seule, par exemple `balanceOf` pour un contrat ERC-20.
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_call">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-1. `Object` - L'objet d'appel de transaction
+1. `Objet` - L'objet d'appel de transaction
 
-- `from` : `DATA`, 20 octets - (optionnel) - L'adresse à partir de laquelle la transaction est envoyée.
-- `to` : `DATA`, 20 octets - L'adresse à laquelle la transaction est orientée.
-- `gaz`: `QUANTITY` - (facultatif) Nombre entier du gaz fourni pour l'exécution de la transaction. eth_call consomme zéro gaz, mais ce paramètre peut être nécessaire pour certaines exécutions.
-- `gasPrice` : `QUANTITY` - (facultatif) Nombre entier du prix du gaz utilisé pour chaque gaz payé
-- `value` : `QUANTITY` - (facultatif) Nombre entier de la valeur envoyée avec cette transaction
-- `input` : `DATA` - Hachage (facultatif) de la signature de la méthode et des paramètres encodés. Pour plus de détails, voir [le contrat Ethereum ABI dans la documentation de Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html).
+- `from` : `DONNÉES`, 20 octets - (facultatif) L'adresse depuis laquelle la transaction est envoyée.
+- `to` : `DONNÉES`, 20 octets - L'adresse à laquelle la transaction est destinée.
+- `gas` : `QUANTITÉ` - (facultatif) Entier du gaz fourni pour l'exécution de la transaction. eth_call consomme zéro gaz, mais ce paramètre peut être nécessaire pour certaines exécutions.
+- `gasPrice` : `QUANTITÉ` - (facultatif) Entier du gasPrice utilisé pour chaque gaz payé
+- `value` : `QUANTITÉ` - (facultatif) Entier de la valeur envoyée avec cette transaction
+- `input` : `DONNÉES` - (facultatif) Hachage de la signature de la méthode et des paramètres encodés. Pour plus de détails, voir l'[ABI du contrat Ethereum dans la documentation de Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html).
 
-2. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block)
+2. `QUANTITÉ|TAG` - numéro de bloc entier, ou la chaîne `\"latest\"`, `\"earliest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, voir le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter)
 
-**Valeur de retour**
+**Retours**
 
-`DATA` - la valeur de retour du contrat exécuté.
+`DONNÉES` - la valeur de retour du contrat exécuté.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1026,15 +1096,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}]
 
 Génère et retourne une estimation de la quantité de gaz nécessaire à la réalisation de la transaction. La transaction ne sera pas ajoutée à la blockchain. Notez que l'estimation peut être beaucoup plus grande que la quantité de gaz réellement utilisée par la transaction, pour diverses raisons, y compris la mécanique EVM et la performance des nœuds.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_estimateGas">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-Voir les paramètres de [eth_call](#eth_call) , hormis le fait que toutes les propriétés sont facultatives. Si aucune limite de gaz n'est spécifiée, geth utilise la limite de gaz du bloc en attente comme une limite supérieure. En conséquence, l'estimation retournée pourrait ne pas suffire à exécuter l'appel/la transaction lorsque la quantité de gaz est supérieure à la limite de gaz bloc en attente.
+Voir les paramètres de [eth_call](#eth_call), sauf que toutes les propriétés sont facultatives. Si aucune limite de gaz n'est spécifiée, geth utilise la limite de gaz du bloc en attente comme une limite supérieure. Par conséquent, l'estimation retournée peut ne pas être suffisante pour exécuter l'appel/la transaction lorsque la quantité de gaz est supérieure à la limite de gaz du bloc en attente.
 
-**Valeur de retour**
+**Retours**
 
-`QUANTITY` - la quantité de gaz utilisée.
+`QUANTITÉ` - la quantité de gaz utilisée.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1051,10 +1125,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{see
 
 Retourne des informations à propos d'un bloc par hachage.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getBlockByHash">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 32 octets - Hachage d'un bloc.
-2. `Boolean` - Si `true` il retourne les objets de transaction complets, si `false` seulement les hachages des transactions.
+1. `DONNÉES`, 32 octets - Hachage d'un bloc.
+2. `Booléen` - Si `true`, il renvoie les objets de transaction complets, si `false`, seulement les hachages des transactions.
 
 ```js
 params: [
@@ -1063,41 +1141,40 @@ params: [
 ]
 ```
 
-**Valeur de retour**
-
-`Object` - Un objet bloc, ou `null` quand aucun bloc n'a été trouvé :
-
-- `number` : `QUANTITY` - le numéro du bloc. `null` quand son bloc est en attente.
-- `hash` : `DATA`, 32 octets - hachage du bloc. `null` quand son bloc est en attente.
-- `parentHash` : `DATA`, 32 octets - hachage du bloc parent.
-- `nonce` : `DATA`, 8 octets - hachage de la preuve de travail générée. `null` quand son bloc est en attente.
-- `sha3Uncles` : `DATA`, 32 octets - SHA3 des oncles données dans le bloc.
-- `logsBloom` : `DATA`, 256 octets - le filtre bloom pour les logs du bloc. `null` quand son bloc est en attente.
-- `transactionsRoot` : `DATA`, 32 octets - la racine de la tentative de transaction du bloc.
-- `stateRoot` : `DATA`, 32 octets - la racine de l'état final du bloc.
-- `receiptsRoot` : `DATA`, 32 octets - la racine de la tentative de réception du bloc.
-- `miner` : `DATA`, 20 octets - l'adresse du bénéficiaire auquel les récompenses minières ont été données.
-- `difficulty` : `QUANTITY` - entier de la difficulté pour ce bloc.
-- `totalDifficulty` : `QUANTITY` - entier de la difficulté globale de la chaîne jusqu'à ce bloc.
-- `extraData` : `DATA` - le champ « données supplémentaires » de ce bloc.
-- `size` : `QUANTITY` - entier de la taille de ce bloc en octets.
-- `gasLimit` : `QUANTITY` - le gaz maximum autorisé dans ce bloc.
-- `gasUsed`: `QUANTITY` - le total utilisé par toutes les transactions de ce bloc.
-- `timestamp`: `QUANTITY` - l'horodatage unix pour le moment où le bloc a été assemblé.
-- `transactions`: `Array` - Tableau d'objets de transaction, ou hachage de transaction 32 octets dépendant du dernier paramètre donné.
-- `uncles`: `Array` - Tableau de hachages d'oncle.
-
-**Exemple**
+**Retours**
 
-```js
-// Request
+`Objet` - un objet de bloc, ou `null` si aucun bloc n'a été trouvé :
+
+- `number` : `QUANTITÉ` - le numéro du bloc. `null` quand il s'agit d'un bloc en attente.
+- `hash` : `DONNÉES`, 32 octets - hachage du bloc. `null` quand il s'agit d'un bloc en attente.
+- `parentHash` : `DONNÉES`, 32 octets - hachage du bloc parent.
+- `nonce` : `DONNÉES`, 8 octets - hachage de la preuve de travail générée. `null` lorsqu'il s'agit d'un bloc en attente, `0x0` pour les blocs à preuve d'enjeu (depuis La Fusion)
+- `sha3Uncles` : `DONNÉES`, 32 octets - SHA3 des données des oncles dans le bloc.
+- `logsBloom` : `DONNÉES`, 256 octets - le filtre de bloom pour les journaux du bloc. `null` quand il s'agit d'un bloc en attente.
+- `transactionsRoot` : `DONNÉES`, 32 octets - la racine du trie de transactions du bloc.
+- `stateRoot` : `DONNÉES`, 32 octets - la racine du trie d'état final du bloc.
+- `receiptsRoot` : `DONNÉES`, 32 octets - la racine du trie de reçus du bloc.
+- `miner` : `DONNÉES`, 20 octets - l'adresse du bénéficiaire à qui les récompenses de bloc ont été données.
+- `difficulty` : `QUANTITÉ` - entier de la difficulté pour ce bloc.
+- `totalDifficulty` : `QUANTITÉ` - entier de la difficulté totale de la chaîne jusqu'à ce bloc.
+- `extraData` : `DONNÉES` - le champ « données supplémentaires » de ce bloc.
+- `size` : `QUANTITÉ` - entier de la taille de ce bloc en octets.
+- `gasLimit` : `QUANTITÉ` - le gaz maximum autorisé dans ce bloc.
+- `gasUsed` : `QUANTITÉ` - le gaz total utilisé par toutes les transactions dans ce bloc.
+- `timestamp` : `QUANTITÉ` - l'horodatage unix du moment où le bloc a été assemblé.
+- `transactions` : `Tableau` - Tableau d'objets de transaction, ou hachages de transaction de 32 octets en fonction du dernier paramètre donné.
+- `uncles` : `Tableau` - Tableau de hachages d'oncles.
+
+**Exemple **
+
+```js
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", false],"id":1}'
-// Result
+// Résultat
 {
-{
-"jsonrpc": "2.0",
-"id": 1,
-"result": {
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
     "difficulty": "0x4ea3f27bc",
     "extraData": "0x476574682f4c5649562f76312e302e302f6c696e75782f676f312e342e32",
     "gasLimit": "0x1388",
@@ -1120,7 +1197,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0
     "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
     "uncles": [
     ]
-}
+  }
 }
 ```
 
@@ -1128,10 +1205,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0
 
 Renvoie des informations sur un bloc par numéro de bloc.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getBlockByNumber">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `QUANTITY|TAG` - nombre entier d'un numéro de bloc, ou la chaîne `« latest »`, `« earliest »`, `« pending »`, `« safe »`, ou `« finalized »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block).
-2. `Boolean` - Si `true` il retourne les objets de transaction complètes, si `false` seulement les hachages des transactions.
+1. `QUANTITÉ|TAG` - entier d'un numéro de bloc, ou la chaîne `\"earliest\"`, `\"latest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, comme dans le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter).
+2. `Booléen` - Si `true`, il renvoie les objets de transaction complets, si `false`, seulement les hachages des transactions.
 
 ```js
 params: [
@@ -1140,9 +1221,10 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getBlockByHash](#eth_getblockbyhash)
+**Retours**
+Voir [eth_getBlockByHash](#eth_getblockbyhash)
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1155,34 +1237,38 @@ Résultat voir [eth_getBlockByHash](#eth_getblockbyhash)
 
 Retourne les informations sur une transaction demandée par le hachage de la transaction.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getTransactionByHash">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 32 octets - hachage d'une transaction
+1. `DONNÉES`, 32 octets - hachage d'une transaction
 
 ```js
 params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"]
 ```
 
-**Valeur de retour**
+**Retours**
 
-`Object` - Un objet de transaction, ou `null` quand aucune transaction n'a été trouvée :
+`Objet` - un objet de transaction, ou `null` si aucune transaction n'a été trouvée :
 
-- `blockHash`: `DATA`, 32 octets - hachage du bloc dans lequel se trouvait cette transaction. `null` lors de son attente.
-- `blockNumber`: `QUANTITY` - numéro de bloc où se trouvait cette transaction. `null` lors de son attente.
-- `from`: `DATA`, 20 octets - adresse de l'expéditeur.
-- `gas`: `QUANTITY` - gaz fourni par l'expéditeur.
-- `gasPrice`: `QUANTITY` - prix du gaz fourni par l'expéditeur en Wei.
-- `hash`: `DATA`, 32 octets - hachage de la transaction.
-- `input`: `DATA` - les données envoyées avec la transaction.
-- `nonce`: `QUANTITY` - le nombre de transactions effectuées par l'expéditeur avant celle-ci.
-- `to`: `DATA`, 20 octets - adresse du destinataire. `null` lors d'une transaction de création de contrat.
-- `transactionIndex`: `QUANTITY` - nombre entier de la position de l'indice des transactions dans le bloc. `null` lors de son attente.
-- `valeur`: `QUANTITY` - valeur transférée dans Wei.
-- `v`: `QUANTITY` - Identifiant de récupération ECDSA
-- `r`: `QUANTITY` - Signature ECDSA r
-- `s`: `QUANTITY` - Signature ECDSA s
+- `blockHash` : `DONNÉES`, 32 octets - hachage du bloc dans lequel se trouvait cette transaction. `null` lorsqu'elle est en attente.
+- `blockNumber` : `QUANTITÉ` - numéro de bloc où se trouvait cette transaction. `null` lorsqu'elle est en attente.
+- `from` : `DONNÉES`, 20 octets - adresse de l'expéditeur.
+- `gas` : `QUANTITÉ` - gaz fourni par l'expéditeur.
+- `gasPrice` : `QUANTITÉ` - prix du gaz fourni par l'expéditeur en Wei.
+- `hash` : `DONNÉES`, 32 octets - hachage de la transaction.
+- `input` : `DONNÉES` - les données envoyées avec la transaction.
+- `nonce` : `QUANTITÉ` - le nombre de transactions effectuées par l'expéditeur avant celle-ci.
+- `to` : `DONNÉES`, 20 octets - adresse du destinataire. `null` lorsqu'il s'agit d'une transaction de création de contrat.
+- `transactionIndex` : `QUANTITÉ` - entier de la position de l'index des transactions dans le bloc. `null` lorsqu'elle est en attente.
+- `value` : `QUANTITÉ` - valeur transférée en Wei.
+- `v` : `QUANTITÉ` - ID de récupération ECDSA
+- `r` : `QUANTITÉ` - signature ECDSA r
+- `s` : `QUANTITÉ` - signature ECDSA s
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1214,10 +1300,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","param
 
 Retourne des informations sur une transaction par hachage de bloc et la position de l'indice de transaction.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getTransactionByBlockHashAndIndex">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `DATA`, 32 octets - hachage d'un bloc.
-2. `QUANTITY` - nombre entier de la position de l'indice de transaction.
+1. `DONNÉES`, 32 octets - hachage d'un bloc.
+2. `QUANTITÉ` - entier de la position de l'index de transaction.
 
 ```js
 params: [
@@ -1226,9 +1316,10 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getTransactionByHash](#eth_gettransactionbyhash)
+**Retours**
+Voir [eth_getTransactionByHash](#eth_gettransactionbyhash)
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1241,10 +1332,14 @@ Résultat voir [eth_getTransactionByHash](#eth_gettransactionbyhash)
 
 Retourne des informations sur une transaction par numéro de bloc et la position de l'indice de transaction.
 
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getTransactionByBlockNumberAndIndex">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
+
 **Paramètres**
 
-1. `QUANTITY|TAG` - un numéro de bloc, ou la chaîne `« earliest »`, `« latest »`, `« pending »`, `« safe »`, ou `« finalized »`, comme dans le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block).
-2. `QUANTITY` - position de l'indice de transaction.
+1. `QUANTITÉ|TAG` - un numéro de bloc, ou la chaîne `\"earliest\"`, `\"latest\"`, `\"pending\"`, `\"safe\"` ou `\"finalized\"`, comme dans le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter).
+2. `QUANTITÉ` - position de l'indice de transaction.
 
 ```js
 params: [
@@ -1253,12 +1348,13 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getTransactionByHash](#eth_gettransactionbyhash)
+**Retours**
+Voir [eth_getTransactionByHash](#eth_gettransactionbyhash)
 
-**Exemple**
+**Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockNumberAndIndex","params":["0x9c47cf", "0x24"],"id":1}'
 ```
 
@@ -1268,38 +1364,39 @@ Résultat voir [eth_getTransactionByHash](#eth_gettransactionbyhash)
 
 Retourne la réception d'une transaction par hachage de la transaction.
 
-**Remarque** que le reçu n'est pas disponible pour les transactions en attente.
+**Remarque** Ce reçu n'est pas disponible pour les transactions en attente.
 
 **Paramètres**
 
-1. `DATA`, 32 octets - hachage d'une transaction
+1. `DONNÉES`, 32 octets - hachage d'une transaction
 
 ```js
 params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"]
 ```
 
-**Renvoie** `Object` - Un objet de réception de transaction, ou `null` quand aucun reçu n'a été trouvé :
+**Retours**
+`Objet` - Un objet de reçu de transaction, ou `null` si aucun reçu n'a été trouvé :
 
-- `transactionHash`: `DATA`, 32 octets - hachage de la transaction.
-- `transactionIndex`: `QUANTITY` - nombre entier de la position de l'indice des transactions dans le bloc.
-- `blockHash`: `DATA`, 32 octets - hachage du bloc dans lequel se trouvait cette transaction.
-- `blockNumber`: `QUANTITY` - numéro de bloc où se trouvait cette transaction.
-- `from`: `DATA`, 20 octets - adresse de l'expéditeur.
-- `to`: `DATA`, 20 octets - adresse du destinataire. null lors d'une transaction de création de contrat.
-- `cumulativeGasUsed` : `QUANTITY` - Le montant total de gaz utilisé lorsque cette transaction a été exécutée dans le bloc.
-- `effectiveGasPrice` : `QUANTITY` - La somme des frais de base et du pourboire payés par unité de gaz.
-- `gasUsed`: `QUANTITY` - La quantité de gaz utilisée par cette transaction spécifique seule.
-- `contractAddress`: `DATA`, 20 octets - L'adresse du contrat a été créée, si la transaction était une création de contrat, sinon `null`.
-- `logs`: `Tableau` - Tableau d'objets de log, que cette transaction a générés.
-- `logsBloom`: `DATA`, 256 octets - Filtre Bloom pour les clients légers pour récupérer rapidement les logs associés.
-- `type`: `QUANTITY` - nombre entier du type de transaction, `0x00` pour les transactions héritées, `0x01` pour les types de listes d'accès, `0x02` pour les frais dynamiques.
+- `transactionHash ` : `DONNÉES`, 32 octets - hachage de la transaction.
+- `transactionIndex` : `QUANTITÉ` - entier de la position de l'index des transactions dans le bloc.
+- `blockHash` : `DONNÉES`, 32 octets - hachage du bloc dans lequel se trouvait cette transaction.
+- `blockNumber` : `QUANTITÉ` - numéro de bloc où se trouvait cette transaction.
+- `from` : `DONNÉES`, 20 octets - adresse de l'expéditeur.
+- `to` : `DONNÉES`, 20 octets - adresse du destinataire. null lors d'une transaction de création de contrat.
+- `cumulativeGasUsed` : `QUANTITÉ ` - Le montant total de gaz utilisé lorsque cette transaction a été exécutée dans le bloc.
+- `effectiveGasPrice` : `QUANTITÉ` - La somme des frais de base et du pourboire payés par unité de gaz.
+- `gasUsed ` : `QUANTITÉ ` - La quantité de gaz utilisée par cette transaction spécifique seule.
+- `contractAddress ` : `DONNÉES`, 20 octets - L'adresse du contrat créée, si la transaction était une création de contrat, sinon `null`.
+- `logs` : `Tableau` - Tableau d'objets de journal que cette transaction a générés.
+- `logsBloom` : `DONNÉES`, 256 octets - Filtre de Bloom pour que les clients légers puissent récupérer rapidement les journaux associés.
+- `type` : `QUANTITÉ` - entier du type de transaction, `0x0` pour les transactions héritées, `0x1` pour les types de listes d'accès, `0x2` pour les frais dynamiques.
 
-Il renvoie aussi _soit_ :
+Il renvoie également _soit_ :
 
-- `root` : `DATA` 32 octets de stateroot post-transaction (avant Byzantium)
-- `status`: `QUANTITY` soit `1` (succès) ou `0` (échec)
+- `root` : `DONNÉES` 32 octets de la racine de l'état post-transaction (avant Byzance)
+- `status` : `QUANTITÉ` soit `1` (succès), soit `0` (échec)
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1333,12 +1430,16 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","para
 
 ### eth_getUncleByBlockHashAndIndex {#eth_getunclebyblockhashandindex}
 
-Retourne des informations à propos d'un oncle d'un bloc par hachage et position de l'indice.
+Renvoie des informations sur un oncle d'un bloc par hachage et position de l'index de l'oncle.
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getUncleByBlockHashAndIndex">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-1. `DATA`, 32 octets - Le hachage d'un bloc.
-2. `QUANTITY` - La position de l'oncle dans l'indice.
+1. `DONNÉES`, 32 octets - Le hachage d'un bloc.
+2. `QUANTITÉ` - La position de l'indice de l'oncle.
 
 ```js
 params: [
@@ -1347,9 +1448,10 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getBlockByHash](#eth_getblockbyhash)
+**Retours**
+Voir [eth_getBlockByHash](#eth_getblockbyhash)
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1358,16 +1460,20 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex"
 
 Résultat voir [eth_getBlockByHash](#eth_getblockbyhash)
 
-**Remarque** : Un oncle ne contient pas de transactions individuelles.
+**Remarque** : un oncle ne contient pas de transactions individuelles.
 
 ### eth_getUncleByBlockNumberAndIndex {#eth_getunclebyblocknumberandindex}
 
-Renvoie des informations à propos d'un oncle d'un bloc par nombre et par position de l'indice.
+Renvoie des informations sur un oncle d'un bloc par numéro et position de l'index de l'oncle.
+
+<ButtonLink size="sm" variant="outline" href="https://ethereum-json-rpc.com/?method=eth_getUncleByBlockNumberAndIndex">
+  Essayer le point de terminaison dans le terrain de jeu
+</ButtonLink>
 
 **Paramètres**
 
-1. `QUANTITY|TAG` - un numéro de bloc, ou la chaîne `« earliest »`, `« latest »`, `« pending »`, `« safe »`, ou `« finalized »`, comme dans le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block).
-2. `QUANTITY` - la position de l'oncle dans l'indice.
+1. `QUANTITÉ|TAG` - un numéro de bloc, ou la chaîne `\"earliest\"`, `\"latest\"`, `\"pending\"`, `\"safe\"`, `\"finalized\"`, comme dans le [paramètre de bloc](/developers/docs/apis/json-rpc/#block-parameter).
+2. `QUANTITÉ` - la position de l'indice de l'oncle.
 
 ```js
 params: [
@@ -1376,11 +1482,12 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getBlockByHash](#eth_getblockbyhash)
+**Retours**
+Voir [eth_getBlockByHash](#eth_getblockbyhash)
 
-**Remarque** : Un oncle ne contient pas de transactions individuelles.
+**Remarque** : un oncle ne contient pas de transactions individuelles.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1391,23 +1498,25 @@ Résultat voir [eth_getBlockByHash](#eth_getblockbyhash)
 
 ### eth_newFilter {#eth_newfilter}
 
-Crée un objet filtre, basé sur les options de filtre, pour avertir lorsque l'état change (logs). Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges).
+Crée un objet filtre, basé sur les options de filtre, pour avertir lorsque l'état change (logs).
+Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges).
 
-**Une note sur la spécification des filtres de sujet :** Les sujets sont dépendants de l'ordre. Une transaction avec un journal avec des sujets [A, B] sera mise en correspondance par les filtres de discussion suivants :
+**Remarque sur la spécification des filtres de sujets :**
+Les sujets dépendent de l'ordre. Une transaction avec un journal avec des sujets [A, B] sera mise en correspondance par les filtres de discussion suivants :
 
-- `[]` « n'importe quoi »
-- `[A]`: « A en première position (et n'importe quoi après) »
-- `[null, B]` « tout ce qui est en première position ET B en seconde position (et tout ce qui est après) »
-- `[A, B]` « A en première position ET B en deuxième position (et tout ce qui suivra) »
-- `[[A, B], [A, B]]` « (A OU B) en première position ET (A OU B) en deuxième position (et n'importe quoi après) »
+- `[]` « n'importe quoi »
+- `[A]` « A en première position (et n'importe quoi après) »
+- `[null, B]` « n'importe quoi en première position ET B en deuxième position (et n'importe quoi après) »
+- `[A, B]` « A en première position ET B en deuxième position (et n'importe quoi après) »
+- `[[A, B], [A, B]]` « (A OU B) en première position ET (A OU B) en deuxième position (et n'importe quoi après) »
 - **Paramètres**
 
-1. `Object` - Les options de filtre :
+1. `Objet` - Les options de filtre :
 
-- `fromBlock`: `QUANTITY|TAG` - (optionnel, par défaut : `« latest »`) nombre entier de blocs, ou `« latest »` pour le dernier bloc proposé, `« safe »` pour le dernier bloc sécurisé, `« finalized »` pour le dernier bloc finalisé, ou `« pending »`, `« earliest »` pour les transactions ne faisant pas encore partie d'un bloc.
-- `toBlock`: `QUANTITY|TAG` - (optionnel, par défaut : `« latest »`) nombre entier de blocs, ou `« latest »` pour le dernier bloc proposé, `« safe »` pour le dernier bloc sécurisé, `« finalized »` pour le dernier bloc finalisé, ou `« pending »`, `« earliest »` pour les transactions ne faisant pas encore partie d'un bloc.
-- `address`: `DATA|Array`, 20 octets - (facultatif) adresse contractuelle ou une liste d'adresses d'où les logs doivent provenir.
-- `topics`: `Array of DATA`, - (facultatif) tableau de 32 bytes `DATA` topics. Les sujets dépendent de l'ordre. Chaque sujet peut également être un tableau de DATA avec des options "ou".
+- `fromBlock` : `QUANTITÉ|TAG` - (facultatif, par défaut : `\"latest\"`) Numéro de bloc entier, ou `\"latest\"` pour le dernier bloc proposé, `\"safe\"` pour le dernier bloc sûr, `\"finalized\"` pour le dernier bloc finalisé, ou `\"pending\"`, `\"earliest\"` pour les transactions qui ne sont pas encore dans un bloc.
+- `toBlock` : `QUANTITÉ|TAG` - (facultatif, par défaut : `\"latest\"`) Numéro de bloc entier, ou `\"latest\"` pour le dernier bloc proposé, `\"safe\"` pour le dernier bloc sûr, `\"finalized\"` pour le dernier bloc finalisé, ou `\"pending\"`, `\"earliest\"` pour les transactions qui ne sont pas encore dans un bloc.
+- `address` : `DONNÉES|Tableau`, 20 octets - (facultatif) Adresse de contrat ou liste d'adresses d'où les journaux doivent provenir.
+- `topics` : `Tableau de DONNÉES`, - (facultatif) Tableau de sujets `DONNÉES` de 32 octets. Les sujets dépendent de l'ordre. Chaque sujet peut également être un tableau de DATA avec des options « ou ».
 
 ```js
 params: [
@@ -1427,9 +1536,10 @@ params: [
 ]
 ```
 
-**Renvoie** `QUANTITY` - Un id de filtre.
+**Retours**
+`QUANTITÉ` - Un ID de filtre.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1444,13 +1554,16 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topic
 
 ### eth_newBlockFilter {#eth_newblockfilter}
 
-Crée un filtre dans le nœud, pour avertir lorsqu'un nouveau bloc arrive. Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges).
+Crée un filtre dans le nœud, pour avertir lorsqu'un nouveau bloc arrive.
+Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges).
 
-**Paramètres :** Aucun
+**Paramètres**
+Aucun
 
-**Renvoie** `QUANTITY` - Un id de filtre.
+**Retours**
+`QUANTITÉ` - Un ID de filtre.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1465,13 +1578,16 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[],
 
 ### eth_newPendingTransactionFilter {#eth_newpendingtransactionfilter}
 
-Crée un filtre dans le nœud, pour notifier quand de nouvelles transactions en attente arrivent. Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges).
+Crée un filtre dans le nœud, pour notifier quand de nouvelles transactions en attente arrivent.
+Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges).
 
-**Paramètres :** Aucun
+**Paramètres**
+Aucun
 
-**Renvoie** `QUANTITY` - Un id de filtre.
+**Retours**
+`QUANTITÉ` - Un ID de filtre.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1486,11 +1602,12 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter"
 
 ### eth_uninstallFilter {#eth_uninstallfilter}
 
-Désinstalle un filtre avec un identifiant donné. Doit toujours être appelé lorsque la montre n'est plus nécessaire. De plus, filtre le délai d'attente quand ils ne sont pas demandés avec [eth_getFilterChanges](#eth_getfilterchanges) pour une période de temps.
+Désinstalle un filtre avec un identifiant donné. Doit toujours être appelé lorsque la montre n'est plus nécessaire.
+De plus, les filtres expirent lorsqu'ils ne sont pas demandés avec [eth_getFilterChanges](#eth_getfilterchanges) pendant un certain temps.
 
 **Paramètres**
 
-1. `QUANTITY` - L'identifiant du filtre.
+1. `QUANTITÉ` - L'ID du filtre.
 
 ```js
 params: [
@@ -1498,9 +1615,10 @@ params: [
 ]
 ```
 
-**Retourne** `Boolean` - `true` si le filtre a été désinstallé avec succès, sinon `false`.
+**Retours**
+`Booléen` - `true` si le filtre a été désinstallé avec succès, sinon `false`.
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
@@ -1519,7 +1637,7 @@ Méthode de vote pour un filtre, qui retourne un tableau de logs qui s'est produ
 
 **Paramètres**
 
-1. `QUANTITY` - L'identifiant du filtre.
+1. `QUANTITÉ` - l'ID du filtre.
 
 ```js
 params: [
@@ -1527,26 +1645,30 @@ params: [
 ]
 ```
 
-**Retourne** `Array` - Tableau d'objets de log, ou un tableau vide si rien n'a changé depuis le dernier sondage.
+**Retours**
+`Tableau` - Tableau d'objets de journal, ou un tableau vide si rien n'a changé depuis le dernier sondage.
+
+- Pour les filtres créés avec `eth_newBlockFilter`, le retour est un hachage de bloc (`DONNÉES`, 32 octets), par exemple, `[\"0x3454645634534...\"]`.
+
+- Pour les filtres créés avec `eth_newPendingTransactionFilter`, le retour est un hachage de transaction (`DONNÉES`, 32 octets), par exemple `[\"0x6345343454645...\"]`.
+
+- Pour les filtres créés avec `eth_newFilter`, les journaux sont des objets avec les paramètres suivants :
+  - `removed` : `TAG` - `true` lorsque le journal a été supprimé, en raison d'une réorganisation de la chaîne. `false` s'il s'agit d'un journal valide.
+  - `logIndex` : `QUANTITÉ` - entier de la position de l'index du journal dans le bloc. `null` lorsqu'il s'agit d'un journal en attente.
+  - `transactionIndex` : `QUANTITÉ` - entier de la position de l'index des transactions à partir de laquelle le journal a été créé. `null` lorsqu'il s'agit d'un journal en attente.
+  - `transactionHash` : `DONNÉES`, 32 octets - hachage des transactions à partir desquelles ce journal a été créé. `null` lorsqu'il s'agit d'un journal en attente.
+  - `blockHash` : `DONNÉES`, 32 octets - hachage du bloc dans lequel se trouvait ce journal. `null` lorsqu'elle est en attente. `null` lorsqu'il s'agit d'un journal en attente.
+  - `blockNumber` : `QUANTITÉ` - le numéro de bloc où se trouvait ce journal. `null` lorsqu'elle est en attente. `null` lorsqu'il s'agit d'un journal en attente.
+  - `address` : `DONNÉES`, 20 octets - adresse d'où provient ce journal.
+  - `data` : `DONNÉES` - données de journal non indexées de longueur variable. (En _Solidity_ : zéro ou plusieurs arguments de journal non indexés de 32 octets.)
+  - `topics` : `Tableau de DONNÉES` - Tableau de 0 à 4 `DONNÉES` de 32 octets d'arguments de journal indexés. (En _Solidity_ : le premier sujet est le _hachage_ de la signature de l'événement (par ex., `Deposit(address,bytes32,uint256)`), sauf si vous avez déclaré l'événement avec le spécificateur `anonymous`.)
 
-- Pour les filtres créés avec `eth_newBlockFilter` le retour constitue des hachages de blocs (`DATA`, 32 octets), par exemple `["0x3454645634534..."]`.
-- Pour les filtres créés avec `eth_newPendingTransactionFilter` le retour constitue des hachages de transaction (`DATA`, 32 octets), par exemple `["0x6345343454645..."]`.
-- Pour les filtres créés avec `eth_newFilter`, les logs sont des objets avec les paramètres suivants :
-  - `removed` : `TAG` - `true` lorsque le journal a été supprimé, en raison d'une réorganisation de chaîne. `false` si c'est un journal valide.
-  - `logIndex`: `QUANTITY` - nombre entier de la position de l'indice des logs dans le bloc. `null` lors de son log en attente.
-  - `transactionIndex` : `QUANTITY` - nombre entier à partir duquel le log de position de l'indice des transactions a été créé. `null` lors de son log en attente.
-  - `transactionHash` : `DATA`, 32 octets - hachage des transactions à partir desquelles ce log a été créé. `null` lors de son log en attente.
-  - `blockHash` : `DATA`, 32 octets - hachage du bloc dans lequel se trouvait ce log. `null` lors de son attente. `null` lors de son log en attente.
-  - `blockNumber` : `QUANTITY` - le numéro de bloc où se trouvait ce log. `null` lors de son attente. `null` lors de son log en attente.
-  - `address`: `DATA`, 20 octets - adresse à partir de laquelle ce journal est originaire.
-  - `data`: `DATA` - contient zéro ou plus de 32 octets d'arguments non indexés du log.
-  - `topics`: `Array of DATA` - Tableau de 0 à 4 32 octets `DATA` d'arguments de log indexés. (Dans _Solidity_: Le premier sujet est le _hash_ de la signature de l'événement (par ex. `Déposit(adresse,octets32,uint256)`), sauf que vous avez déclaré l'événement avec le `spécificateur anonyme`.)
-- **Exemple**
+- **Exemple **
 
 ```js
-// Request
+// Requête
 curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":["0x16"],"id":73}'
-// Result
+// Résultat
 {
   "id":1,
   "jsonrpc":"2.0",
@@ -1571,7 +1693,7 @@ Retourne un tableau de tous les logs correspondant au filtre avec l'identifiant
 
 **Paramètres**
 
-1. `QUANTITY` - L'identifiant du filtre.
+1. `QUANTITÉ` - L'ID du filtre.
 
 ```js
 params: [
@@ -1579,16 +1701,17 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getFilterChanges](#eth_getfilterchanges)
+**Retours**
+Voir [eth_getFilterChanges](#eth_getfilterchanges)
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
 curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x16"],"id":74}'
 ```
 
-Résultats voir [eth_getFilterChanges](#eth_getfilterchanges)
+Résultat voir [eth_getFilterChanges](#eth_getfilterchanges)
 
 ### eth_getLogs {#eth_getlogs}
 
@@ -1596,13 +1719,13 @@ Retourne un tableau de tous les logs correspondant à un objet filtre donné.
 
 **Paramètres**
 
-1. `Object` - Les options de filtre :
+1. `Objet` - Les options de filtre :
 
-- `fromBlock`: `QUANTITY|TAG` - (optionnel, par défaut : `« latest »`) nombre entier de blocs, ou `« latest »` pour le dernier bloc proposé, `« safe »` pour le dernier bloc sécurisé, `« finalized »` pour le dernier bloc finalisé, ou `« pending »`, `« earliest »` pour les transactions ne faisant pas encore partie d'un bloc.
-- `toBlock`: `QUANTITY|TAG` - (optionnel, par défaut : `« latest »`) nombre entier de blocs, ou `« latest »` pour le dernier bloc proposé, `« safe »` pour le dernier bloc sécurisé, `« finalized »` pour le dernier bloc finalisé, ou `« pending »`, `« earliest »` pour les transactions ne faisant pas encore partie d'un bloc.
-- `address`: `DATA|Array`, 20 octets - (facultatif) adresse contractuelle ou une liste d'adresses d'où les logs doivent provenir.
-- `topics`: `Array of DATA`, - (facultatif) tableau de 32 bytes `DATA` topics. Les sujets dépendent de l'ordre. Chaque sujet peut également être un tableau de DATA avec des options "ou".
-- `blockhash`: `DATA`, 32 octets - (facultatif, **futur**) À l'ajout de EIP-234, `blockHash` sera une nouvelle option de filtre qui restreint les logs retournés au bloc unique avec le hachage de 32 octets `blockHash`. Utiliser `blockHash` est équivalent à `fromBlock` = `toBlock` = le numéro de bloc avec le hachage `blockHash`. Si `blockHash` est présent dans les critères de filtre, alors ni `fromBlock` ni `toBlock` ne sont autorisés.
+- `fromBlock` : `QUANTITÉ|TAG` - (facultatif, par défaut : `\"latest\"`) Numéro de bloc entier, ou `\"latest\"` pour le dernier bloc proposé, `\"safe\"` pour le dernier bloc sûr, `\"finalized\"` pour le dernier bloc finalisé, ou `\"pending\"`, `\"earliest\"` pour les transactions qui ne sont pas encore dans un bloc.
+- `toBlock` : `QUANTITÉ|TAG` - (facultatif, par défaut : `\"latest\"`) Numéro de bloc entier, ou `\"latest\"` pour le dernier bloc proposé, `\"safe\"` pour le dernier bloc sûr, `\"finalized\"` pour le dernier bloc finalisé, ou `\"pending\"`, `\"earliest\"` pour les transactions qui ne sont pas encore dans un bloc.
+- `address` : `DONNÉES|Tableau`, 20 octets - (facultatif) Adresse de contrat ou liste d'adresses d'où les journaux doivent provenir.
+- `topics` : `Tableau de DONNÉES`, - (facultatif) Tableau de sujets `DONNÉES` de 32 octets. Les sujets dépendent de l'ordre. Chaque sujet peut également être un tableau de DATA avec des options « ou ».
+- `blockHash` : `DONNÉES`, 32 octets - (facultatif, **futur**) Avec l'ajout de l'EIP-234, `blockHash` sera une nouvelle option de filtre qui restreint les journaux retournés au seul bloc avec le hachage de 32 octets `blockHash`. L'utilisation de `blockHash` est équivalente à `fromBlock` = `toBlock` = le numéro de bloc avec le hachage `blockHash`. Si `blockHash` est présent dans les critères de filtre, ni `fromBlock` ni `toBlock` ne sont autorisés.
 
 ```js
 params: [
@@ -1614,24 +1737,25 @@ params: [
 ]
 ```
 
-**Retourne** Voir [eth_getFilterChanges](#eth_getfilterchanges)
+**Retours**
+Voir [eth_getFilterChanges](#eth_getfilterchanges)
 
-**Exemple**
+**Exemple **
 
 ```js
 // Request
 curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}'
 ```
 
-Résultats voir [eth_getFilterChanges](#eth_getfilterchanges)
+Résultat voir [eth_getFilterChanges](#eth_getfilterchanges)
 
 ## Exemple d'utilisation {#usage-example}
 
-### Déploiement d'un contrat en utilisant JSON_RPC {#deploying-contract}
+### Déploiement d'un contrat à l'aide de JSON-RPC {#deploying-contract}
 
-Cette section comprend une démonstration de la façon de déployer un contrat en utilisant uniquement l'interface RPC. Il existe des voies alternatives pour le déploiement de contrats où cette complexité est abstraite, par exemple, en utilisant des bibliothèques construites au dessus de l'interface RPC comme [web3.js](https://web3js.readthedocs.io/) et [web3.py](https://github.com/ethereum/web3.py). Ces abstractions sont généralement plus faciles à comprendre et moins sujettes aux erreurs, mais il est toujours utile de comprendre ce qui se passe sous le capot.
+Cette section comprend une démonstration de la façon de déployer un contrat en utilisant uniquement l'interface RPC. Il existe d'autres moyens de déployer des contrats où cette complexité est abstraite, par exemple, en utilisant des bibliothèques construites sur l'interface RPC telles que [web3.js](https://web3js.readthedocs.io/) et [web3.py](https://github.com/ethereum/web3.py). Ces abstractions sont généralement plus faciles à comprendre et moins sujettes aux erreurs, mais il est toujours utile de comprendre ce qui se passe sous le capot.
 
-Ce qui suit est un contrat intelligent simple appelé `Multiply7` qui sera déployé à l'aide de l'interface JSON-RPC sur un nœud Ethereum. Ce tutoriel suppose que le lecteur exécute déjà un nœud Geth. Plus d'informations sur les nœuds et les clients sont disponibles [ici](/developers/docs/nodes-and-clients/run-a-node). Veuillez vous référer à la documentation de [client](/developers/docs/nodes-and-clients/) individuelle pour voir comment démarrer le JSON-RPC HTTP pour les clients non-Geth. La plupart des clients servent par défaut sur `localhost:8545`.
+Ce qui suit est un contrat intelligent simple appelé `Multiply7` qui sera déployé à l'aide de l'interface JSON-RPC sur un nœud Ethereum. Ce tutoriel suppose que le lecteur exécute déjà un nœud Geth. Plus d'informations sur les nœuds et les clients sont disponibles [ici](/developers/docs/nodes-and-clients/run-a-node). Veuillez vous référer à la documentation de chaque [client](/developers/docs/nodes-and-clients/) pour voir comment démarrer le JSON-RPC HTTP pour les clients non-Geth. La plupart des clients servent par défaut sur `localhost:8545`.
 
 ```javascript
 contract Multiply7 {
@@ -1649,12 +1773,12 @@ La première chose à faire est de s'assurer que l'interface HTTP RPC est activ
 geth --http --dev console 2>>geth.log
 ```
 
-Cela démarrera l'interface HTTP RPC sur `http://localhost:8545`.
+Cela démarrera l'interface RPC HTTP sur `http://localhost:8545`.
 
 Nous pouvons vérifier que l'interface est en cours d'exécution en récupérant l'adresse coinbase (en obtenant la première adresse dans le tableau des comptes) et le solde en utilisant [curl](https://curl.se). Veuillez noter que les données contenues dans ces exemples seront différentes sur votre noeud local. Si vous voulez essayer ces commandes, remplacez les paramètres de la requête dans la deuxième requête avec le résultat retourné par la première.
 
 ```bash
-curl --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[]", "id":1}' -H "Content-Type: application/json" localhost:8545
+curl --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[], "id":1}' -H "Content-Type: application/json" localhost:8545
 {"id":1,"jsonrpc":"2.0","result":["0x9b1d35635cc34752ca54713bb99d38614f63c955"]}
 
 curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635cc34752ca54713bb99d38614f63c955", "latest"], "id":2}' -H "Content-Type: application/json" localhost:8545
@@ -1668,9 +1792,9 @@ web3.fromWei("0x1639e49bba16280000", "ether")
 // "410"
 ```
 
-Maintenant que notre chaîne de développement privé a un certain poids, nous pouvons déployer le contrat. La première étape est de compiler le contrat Multiply7 en byte code qui peut être envoyé à l'EVM. Pour installer solc, le compilateur Solidity, suivez la [documentation Solidity](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Vous pouvez utiliser une ancienne version `solc` à des fins de correspondance à [la version du compilateur utilisée pour notre exemple](https://github.com/ethereum/solidity/releases/tag/v0.4.20).)
+Maintenant que notre chaîne de développement privé a un certain poids, nous pouvons déployer le contrat. La première étape est de compiler le contrat Multiply7 en byte code qui peut être envoyé à l'EVM. Pour installer solc, le compilateur Solidity, suivez la [documentation Solidity](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Vous voudrez peut-être utiliser une ancienne version de `solc` pour correspondre à [la version du compilateur utilisée pour notre exemple](https://github.com/ethereum/solidity/releases/tag/v0.4.20).)
 
-L'étape suivante est de compiler le contrat Multiply7 en code d'octets qui peut être envoyé à l'EVM.
+L'étape suivante consiste à compiler le contrat Multiply7 en code d'octet qui peut être envoyé à l'EVM.
 
 ```bash
 echo 'pragma solidity ^0.4.16; contract Multiply7 { event Print(uint); function multiply(uint input) public returns (uint) { Print(input * 7); return input * 7; } }' | solc --bin
@@ -1694,7 +1818,7 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from
 {"id":6,"jsonrpc":"2.0","result":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"}
 ```
 
-La transaction est acceptée par le noeud et un hachage de la transaction est retourné. Ce hachage peut être utilisé pour suivre la transaction. La prochaine étape consiste à déterminer l'adresse où notre contrat est déployé. Chaque transaction exécutée créera un reçu. Ce reçu contient diverses informations sur la transaction telle que le bloc dans lequel la transaction a été incluse et la quantité de gaz utilisée par l'EVM. Si une transaction crée un contrat, elle contiendra également l'adresse du contrat. Nous pouvons récupérer le reçu avec la méthode `eth_getTransactionReceipt` RPC.
+La transaction est acceptée par le noeud et un hachage de la transaction est retourné. Ce hachage peut être utilisé pour suivre la transaction. La prochaine étape consiste à déterminer l'adresse où notre contrat est déployé. Chaque transaction exécutée créera un reçu. Ce reçu contient diverses informations sur la transaction telle que le bloc dans lequel la transaction a été incluse et la quantité de gaz utilisée par l'EVM. Si une transaction crée un contrat, elle contiendra également l'adresse du contrat. Nous pouvons récupérer le reçu avec la méthode RPC `eth_getTransactionReceipt`.
 
 ```bash
 curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": ["0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"], "id": 7}' -H "Content-Type: application/json" localhost:8545
@@ -1705,9 +1829,9 @@ Notre contrat a été créé sur `0x4d03d617d700cf81935d7f797f4e2ae719648262`. U
 
 #### Interagir avec les contrats intelligents {#interacting-with-smart-contract}
 
-Dans cet exemple, nous enverrons une transaction en utilisant `eth_sendTransaction` à la méthode `multiply` du contrat.
+Dans cet exemple, nous allons envoyer une transaction en utilisant `eth_sendTransaction` à la méthode `multiply` du contrat.
 
-`eth_sendTransaction` nécessite plusieurs arguments, spécifiquement `from`, `to` et `data`. `From` est l'adresse publique de notre compte et `to` est l'adresse du contrat. L'argument `data` contient une charge utile qui définit quelle méthode doit être appelée et avec quels arguments. C'est ici que [l'ABI (interface binaire de l'application)](https://docs.soliditylang.org/en/latest/abi-spec.html) entre en jeu. L'ABI est un fichier JSON qui définit comment définir et encoder les données pour l'EVM.
+`eth_sendTransaction` nécessite plusieurs arguments, en particulier `from`, `to` et `data`. `From` est l'adresse publique de notre compte et `to` est l'adresse du contrat. L'argument `data` contient une charge utile qui définit quelle méthode doit être appelée et avec quels arguments. C'est là que l'[ABI (interface binaire d'application)](https://docs.soliditylang.org/en/latest/abi-spec.html) entre en jeu. L'ABI est un fichier JSON qui définit comment définir et encoder les données pour l'EVM.
 
 Les octets de la charge utile définissent quelle méthode dans le contrat est appelée. Il s'agit des 4 premiers octets du hachage de Keccak sur le nom de la fonction et ses types d'arguments, encodés en hexa. La fonction multiplier accepte un uint qui est un alias pour uint256. Cela nous laisse avec :
 
@@ -1718,11 +1842,11 @@ web3.sha3("multiply(uint256)").substring(0, 10)
 
 L'étape suivante est d'encoder les arguments. Il n'y a qu'un seul uint256, par exemple, la valeur 6. L'ABI a une section qui spécifie comment encoder les types uint256.
 
-`int<M>: enc(X)` est l'encodage gros-boutiste en complément à deux de X, ajouté sur le côté supérieur (gauche) avec Jeff pour X négatif et avec zéro > octets pour X positif de sorte que la longueur est un multiple de 32 octets.
+`int<M>: enc(X)` est l'encodage en complément à deux gros-boutiste de X, complété sur le côté d'ordre supérieur (gauche) avec 0xff pour X négatif et avec des octets nuls pour X positif de sorte que la longueur soit un multiple de 32 octets.
 
 Ceci encode en `0000000000000000000000000000000000000000000000000000000000000006`.
 
-La combinaison du sélecteur de fonction et de l'argument encodé sera `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`.
+En combinant le sélecteur de fonction et l'argument encodé, nos données seront `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`.
 
 Cela peut maintenant être envoyé au nœud :
 
@@ -1755,7 +1879,7 @@ Puisqu'une transaction a été envoyée, un hachage de transaction a été retou
 }
 ```
 
-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 :
+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é déclenché avec l'entrée fois 7. Puisque l'argument pour l'événement `Print` était un uint256, nous pouvons le décoder selon les règles de l'ABI, ce qui nous donnera la décimale attendue 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)")
@@ -1767,7 +1891,7 @@ Il ne s'agissait que d'une brève introduction à certaines des tâches les plus
 ## Sujets connexes {#related-topics}
 
 - [Spécification JSON-RPC](http://www.jsonrpc.org/specification)
-- [ Nœuds et clients](/developers/docs/nodes-and-clients/)
+- [Nœuds et clients](/developers/docs/nodes-and-clients/)
 - [API JavaScript](/developers/docs/apis/javascript/)
-- [API back-end](/developers/docs/apis/backend/)
+- [API backend](/developers/docs/apis/backend/)
 - [Clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients)
diff --git a/public/content/translations/fr/developers/docs/blocks/index.md b/public/content/translations/fr/developers/docs/blocks/index.md
index 0f2746b983a..357fb5a1d3b 100644
--- a/public/content/translations/fr/developers/docs/blocks/index.md
+++ b/public/content/translations/fr/developers/docs/blocks/index.md
@@ -1,6 +1,6 @@
 ---
 title: Blocs
-description: Présentation des blocs de la blockchain Ethereum, leur structure de données, pourquoi ils sont nécessaires et comment ils sont créés.
+description: "Présentation des blocs de la blockchain Ethereum, leur structure de données, pourquoi ils sont nécessaires et comment ils sont créés."
 lang: fr
 ---
 
@@ -8,13 +8,14 @@ Les blocs sont des lots de transactions avec un hachage du bloc précédent dans
 
 ## Prérequis {#prerequisites}
 
-Les blocs sont un sujet très accessible pour les débutants. Mais pour vous aider à mieux comprendre cette page, nous vous recommandons de commencer par lire les pages [Comptes](/developers/docs/accounts/), [Transactions](/developers/docs/transactions/) et [Introduction à Ethereum](/developers/docs/intro-to-ethereum/).
+Les blocs sont un sujet très accessible pour les débutants. Mais pour vous aider à mieux comprendre cette page, nous vous recommandons de lire d'abord [Comptes](/developers/docs/accounts/), [Transactions](/developers/docs/transactions/), et notre [introduction à Ethereum](/developers/docs/intro-to-ethereum/).
 
 ## Pourquoi les blocs? {#why-blocks}
 
 Afin de s'assurer que tous les participants du réseau Ethereum restent synchronisés et s'accordent sur l'historique exacte des transactions, les transactions sont traitées par blocs. Cela signifie que des dizaines (ou centaines) de transactions sont engagées, acceptées et synchronisées en même temps.
 
-![Un schéma montrant la transaction dans un bloc provoquant des changements d'état](./tx-block.png) _Schéma adapté à partir du document [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Un diagramme montrant une transaction dans un bloc provoquant des changements d'état](./tx-block.png)
+_Diagramme adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 En espaçant les engagements, nous donnons à tous les participants du serveur assez de temps pour parvenir à un consensus : même si les demande de transaction se présentent des dizaines de fois par seconde, les blocs sont seulement créés et engagés sur Ethereum toutes les douze secondes.
 
@@ -24,39 +25,39 @@ Pour préserver l'historique des transactions, les blocs sont strictement ordonn
 
 Une fois qu'un bloc a été lié aux autres blocs par un validateur sélectionné aléatoirement sur le réseau, il est scellé au reste du réseau ; ce bloc ajouté à la chaîne de bloc (blockchain) est lié au précédent, et une copie est transmise à tous les noeuds du réseau, ensuite un autre validateur est sélectionné pour créer le nouveau bloc. Le processus exact d'assemblage de blocs et le processus d'engagement/consensus sont actuellement spécifiés par le protocole de la « preuve d'enjeu » d'Ethereum.
 
-## Protocole de la preuve d'enjeu {#proof-of-work-protocol}
+## Protocole de preuve d'enjeu {#proof-of-stake-protocol}
 
 La preuve d'enjeu implique les éléments suivants :
 
 - La validation des nœuds nécessite de miser 32 ETH dans un contrat de dépôt comme collatéral contre les mauvais comportements. Cela aide à protéger le réseau puisque des activités manifestement malhonnêtes mènent à la destruction de tout ou partie des mises.
 - Dans chaque créneau (espacés de douze secondes), un validateur est sélectionné aléatoirement pour être le proposant de bloc. Ils regroupent les transactions ensemble, les exécutent et déterminent un nouvel « état ». Ils enveloppent ces informations dans un bloc et les transmettent à d'autres validateurs.
-- Les autres validateurs qui entendent parler d'un nouveau bloc exécutent à nouveau les transactions pour s'assurer qu'ils sont d'accord avec le changement proposé d'état global. En supposant que le bloc soit valide, ils l'ajoutent à leur propre base de données.
+- Les autres validateurs qui ont connaissance du nouveau bloc réexécutent les transactions pour s'assurer qu'ils sont d'accord avec la modification proposée de l'état global. En supposant que le bloc soit valide, ils l'ajoutent à leur propre base de données.
 - Si des validateurs entendent parler de deux blocs en conflit pour le même créneau, ils utilisent leur algorithme de choix de fourche pour choisir celui supporté par le plus grand nombre de mise en jeu d'ETH.
 
 [En savoir plus sur la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos)
 
-## Que contient un bloc ? {#block-anatomy}
+## Que contient un bloc ? Anatomie du bloc {#block-anatomy}
 
 Un bloc contient de nombreuses informations. Au plus haut niveau, un bloc contient les champs suivants :
 
 | Champ            | Description                                                    |
-|:---------------- |:-------------------------------------------------------------- |
-| `Créneau`        | le créneau auquel appartient le bloc                           |
+| :--------------- | :------------------------------------------------------------- |
+| `créneau`        | le créneau auquel appartient le bloc                           |
 | `proposer_index` | l'ID du validateur proposant le bloc                           |
 | `parent_root`    | le hachage du bloc précédent                                   |
 | `state_root`     | le hachage racine de l'objet état                              |
 | `présentation`   | un objet contenant plusieurs champs, tel que défini ci-dessous |
 
-Le corps `body` du bloc contient plusieurs champs propres :
+Le corps `body` du bloc contient plusieurs champs qui lui sont propres :
 
 | Champ                | Description                                                          |
-|:-------------------- |:-------------------------------------------------------------------- |
+| :------------------- | :------------------------------------------------------------------- |
 | `randao_reveal`      | une valeur utilisée pour sélectionner le prochain proposant de bloc  |
 | `eth1_data`          | informations sur le contrat de dépôt                                 |
 | `graffiti`           | données arbitraires utilisées pour étiqueter les blocs               |
 | `proposer_slashings` | liste des validateurs à délester                                     |
 | `attester_slashings` | liste des validateurs à sanctionner                                  |
-| `attestations`       | liste des attestations en faveur du bloc actuel                      |
+| `attestations`       | liste des attestations effectuées pour les créneaux précédents       |
 | `dépôts`             | liste des nouveaux dépôts au contrat de dépôt                        |
 | `voluntary_exits`    | liste des validateurs quittant le réseau                             |
 | `sync_aggregate`     | sous-ensemble de validateurs utilisés pour servir les clients légers |
@@ -64,48 +65,48 @@ Le corps `body` du bloc contient plusieurs champs propres :
 
 Le champ `attestations` contient une liste de toutes les attestations dans le bloc. Les attestations ont leur propre type de données, qui contient plusieurs morceaux de données. Chaque attestation contient :
 
-| Champ              | Description                                                   |
-|:------------------ |:------------------------------------------------------------- |
-| `aggregation_bits` | une liste des validateurs ayant participé à cette attestation |
-| `données`          | un conteneur avec plusieurs sous-champs                       |
-| `signature`        | agrégat de signature de tous les validateurs attestant        |
-
-Le champ `data` dans `attestation` contient les éléments suivants :
-
-| Champ               | Description                                         |
-|:------------------- |:--------------------------------------------------- |
-| `Créneau`           | le créneau auquel se rapporte l'attestation         |
-| `Index`             | indices pour les validateurs attestant              |
-| `beacon_block_root` | le hachage racine du bloc Phare contenant cet objet |
-| `source`            | le dernier point de contrôle justifié               |
-| `target`            | le dernier bloc limite de l'époque                  |
-
-Exécuter les transactions dans `execution_payload` met à jour l'état global. Tous les clients réexécutent les transactions dans le champ `execution_payload` pour s'assurer que le nouvel état corresponde à celui du champ `state_root` du nouveau bloc. C'est ainsi que les clients peuvent dire qu'un nouveau bloc est valide et sûr afin de l'ajouter à leur blockchain. Le `bloc d'exécution` est lui-même un objet doté de plusieurs champs. Il existe également un `execution_payload_header` qui contient des informations sommaires importantes sur les données d'exécution. Ces structures des données sont organisées de la manière suivante :
-
-`execution_payload_header` contient les champs suivants :
-
-| Champ               | Description                                                                         |
-|:------------------- |:----------------------------------------------------------------------------------- |
-| `parent_hash`       | hachage du bloc parent                                                              |
-| `fee_recipient`     | adresse du compte pour le paiement des frais de transaction                         |
-| `state_root`        | hachage racine pour l'état global après avoir appliqué les changements dans ce bloc |
-| `receipts_root`     | hachage de la transaction de l'arboresence des reçus                                |
-| `logs_bloom`        | structure de données contenant les journaux d'événements                            |
-| `prev_randao`       | valeur utilisée dans la sélection aléatoire du validateur                           |
-| `block_number`      | le numéro de bloc actuel                                                            |
-| `gas_limit`         | gaz maximum autorisé dans ce bloc                                                   |
-| `gas_used`          | la quantité de gaz réelle utilisée dans ce bloc                                     |
-| `horodatage`        | la durée du bloc                                                                    |
-| `extra_data`        | données supplémentaires arbitraires en octets bruts                                 |
-| `base_fee_per_gas`  | la valeur des frais de base                                                         |
-| `block_hash`        | hachage du bloc d'exécution                                                         |
-| `transactions_root` | hachage racine des transactions dans le bloc                                        |
-| `withdrawal_root`   | hachage racine des retraits dans le bloc                                            |
-
-`execution_payload` contient lui-même ce qui suit (notez que cela est identique à l'en-tête sauf qu'au lieu du hachage racine des transactions, il inclut la liste réelle des transactions et des informations de retrait) :
+| Champ              | Description                                                                 |
+| :----------------- | :-------------------------------------------------------------------------- |
+| `aggregation_bits` | une liste des validateurs ayant participé à cette attestation               |
+| `données`          | un conteneur avec plusieurs sous-champs                                     |
+| `signature`        | signature agrégée d'un ensemble de validateurs portant sur la partie `data` |
+
+Le champ `data` dans l'`attestation` contient les éléments suivants :
+
+| Champ               | Description                                                          |
+| :------------------ | :------------------------------------------------------------------- |
+| `créneau`           | le créneau auquel se rapporte l'attestation                          |
+| `index`             | indices pour les validateurs attestant                               |
+| `beacon_block_root` | le hachage racine du bloc phare considéré comme la tête de la chaîne |
+| `source`            | le dernier point de contrôle justifié                                |
+| `target`            | le dernier bloc limite de l'époque                                   |
+
+L'exécution des transactions dans `execution_payload` met à jour l'état global. Tous les clients réexécutent les transactions dans l'`execution_payload` pour s'assurer que le nouvel état corresponde à celui du champ `state_root` du nouveau bloc. C'est ainsi que les clients peuvent dire qu'un nouveau bloc est valide et sûr afin de l'ajouter à leur blockchain. La `charge utile d'exécution` elle-même est un objet avec plusieurs champs. Il existe également un `execution_payload_header` qui contient d'importantes informations récapitulatives sur les données d'exécution. Ces structures des données sont organisées de la manière suivante :
+
+L'`execution_payload_header` contient les champs suivants :
+
+| Champ               | Description                                                                       |
+| :------------------ | :-------------------------------------------------------------------------------- |
+| `parent_hash`       | hachage du bloc parent                                                            |
+| `fee_recipient`     | adresse du compte pour le paiement des frais de transaction                       |
+| `state_root`        | hachage racine pour l'état global une fois appliqués les changements dans ce bloc |
+| `receipts_root`     | hachage de la transaction de l'arborescence des reçus                             |
+| `logs_bloom`        | structure de données contenant les journaux d'événements                          |
+| `prev_randao`       | valeur utilisée dans la sélection aléatoire du validateur                         |
+| `block_number`      | le numéro de bloc actuel                                                          |
+| `gas_limit`         | gaz maximum autorisé dans ce bloc                                                 |
+| `gas_used`          | la quantité de gaz réelle utilisée dans ce bloc                                   |
+| `timestamp`         | le temps de bloc                                                                  |
+| `extra_data`        | données supplémentaires arbitraires en octets bruts                               |
+| `base_fee_per_gas`  | la valeur des frais de base                                                       |
+| `block_hash`        | hachage du bloc d'exécution                                                       |
+| `transactions_root` | hachage racine des transactions dans le bloc                                      |
+| `withdrawal_root`   | hachage racine des retraits dans le bloc                                          |
+
+L'`execution_payload` lui-même contient ce qui suit (notez que c'est identique à l'en-tête, sauf qu'au lieu du hachage racine des transactions, il inclut la liste réelle des transactions et les informations de retrait) :
 
 | Champ              | Description                                                                       |
-|:------------------ |:--------------------------------------------------------------------------------- |
+| :----------------- | :-------------------------------------------------------------------------------- |
 | `parent_hash`      | hachage du bloc parent                                                            |
 | `fee_recipient`    | adresse du compte pour le paiement des frais de transaction                       |
 | `state_root`       | hachage racine pour l'état global une fois appliqués les changements dans ce bloc |
@@ -119,29 +120,29 @@ Exécuter les transactions dans `execution_payload` met à jour l'état global.
 | `extra_data`       | données supplémentaires arbitraires en octets bruts                               |
 | `base_fee_per_gas` | la valeur des frais de base                                                       |
 | `block_hash`       | hachage du bloc d'exécution                                                       |
-| `des transactions` | liste des transactions à exécuter                                                 |
+| `transactions`     | liste des transactions à exécuter                                                 |
 | `retraits`         | liste des objets de retrait                                                       |
 
-La liste `withdrawals` contient les objets `withdrawal` structurée de la façon suivante :
+La liste `withdrawals` contient des objets `withdrawal` structurés de la manière suivante :
 
 | Champ            | Description                        |
-|:---------------- |:---------------------------------- |
-| `address`        | adresse du compte qui s'est retiré |
+| :--------------- | :--------------------------------- |
+| `adresse`        | adresse du compte qui s'est retiré |
 | `montant`        | montant du retrait                 |
-| `Index`          | valeur d'index du retrait          |
+| `index`          | valeur d'index du retrait          |
 | `validatorIndex` | valeur d'index du validateur       |
 
-## Durée de blocage {#block-time}
+## Temps de bloc {#block-time}
 
 Le temps de bloc fait référence au temps qui sépare les blocs. Dans Ethereum, le temps est divisé en unités de douze secondes appelées « créneau ». Pour chaque créneau, un validateur est choisi pour proposer un bloc. Si tous les validateurs sont en ligne et complétement opérationnels, il y aura un bloc dans chaque créneau, ce qui signifie que le temps de bloc est de 12 s. Occasionnellement, des validateurs peuvent être hors-ligne lorsqu'ils sont appelés pour valider un bloc, de sorte que les créneaux peuvent parfois être vide.
 
-Cette implémentation diffère des systèmes fondés sur la preuve de travail (PoW), dans lesquels la génération d'un bloc est une occurrence naturelle, compensée par la difficulté de mining du protocole. Le temps moyen de propagation des blocs d'Ethereum [average block time](https://etherscan.io/chart/blocktime) est l'exemple parfait de l'implementation de la preuve d'enjeu, et donc du passage de la preuve de travail (PoW) à la preuve d'enjeu (PoS), rendu possible grâce à un nouvel ajustement du temps de propagation des blocs, qui est passé à 12 secondes.
+Cette implémentation diffère des systèmes fondés sur la preuve de travail (PoW), dans lesquels la génération d'un bloc est une occurrence naturelle, compensée par la difficulté de mining du protocole. Le [temps de bloc moyen](https://etherscan.io/chart/blocktime) d'Ethereum en est un parfait exemple, car il permet de déduire clairement la transition de la preuve de travail à la preuve d'enjeu grâce à la régularité du nouveau temps de bloc de 12 s.
 
-## Taille des blocs {#block-size}
+## Taille de bloc {#block-size}
 
 Une dernière remarque importante : les blocs eux-mêmes sont limités par la taille. Chaque bloc vise une taille cible de 30 millions de gaz, mais leur taille s'adapte aux exigences du réseau, jusqu'à la limite de 60 millions de gaz (deux fois la taille cible de bloc). La limite de gaz d'un bloc peut être ajustée à la hausse ou à la baisse par un facteur de 1/1024 par rapport à la limite de gaz du bloc précédent. Ainsi, les validateurs peuvent modifier la limite de gaz des blocs par consensus. La quantité totale de gaz dépensée par toutes les transactions dans le bloc doit être inférieure à la limite de gaz du bloc. Ce point est important car il garantit que les blocs ne peuvent pas être arbitrairement grands. Si les blocs pouvaient être arbitrairement grands, les nœuds complets moins performants cesseraient progressivement de suivre le réseau à cause des exigences d'espace et de vitesse. Plus le bloc est grand, plus il faut de puissance de calcul pour traiter la transaction à temps pour le prochain créneau. Il s'agit d'un facteur de centralisation, auquel nous nous opposons en plafonnant la taille des blocs.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
diff --git a/public/content/translations/fr/developers/docs/bridges/index.md b/public/content/translations/fr/developers/docs/bridges/index.md
index d0c7c2af504..bb5eb5b5067 100644
--- a/public/content/translations/fr/developers/docs/bridges/index.md
+++ b/public/content/translations/fr/developers/docs/bridges/index.md
@@ -1,12 +1,12 @@
 ---
 title: Passerelles
-description: Un aperçu de la passerelle pour les développeurs
+description: "Un aperçu de la passerelle pour les développeurs"
 lang: fr
 ---
 
-Avec la prolifération des blockchains L1 et des solutions L2 [scaling](/developers/docs/scaling/), aux côtés d'un nombre sans cesse croissant d'applications décentralisées passant d'une chaîne à l'autre, la nécessité de communiquer et de déplacer les actifs d'une chaîne à l'autre est devenue un élément essentiel de l'infrastructure du réseau. Différents types de passerelles existent pour aider à rendre cela possible.
+Avec la prolifération des blockchains L1 et des solutions de [mise à l'échelle](/developers/docs/scaling/) L2, ainsi qu'un nombre toujours croissant d'applications décentralisées devenant inter-chaînes, le besoin de communication et de mouvement d'actifs entre les chaînes est devenu une partie essentielle de l'infrastructure du réseau. Différents types de passerelles existent pour aider à rendre cela possible.
 
-## Besoin de passerelles {#need-for-bridges}
+## Besoin de ponts {#need-for-bridges}
 
 Des ponts existent pour connecter les différentes blockchains. Ils permettent la connectivité et l'interopérabilité entre les blockchains.
 
@@ -14,7 +14,7 @@ Les blockchains existent dans des environnements cloisonnés, ce qui signifie qu
 
 Les ponts offrent un moyen pour des environnements isolés de la blockchain de se connecter entre eux. Ils établissent une voie de transport entre les blockchains où les jetons, les messages, les données arbitraires et même les appels de [contrats intelligents](/developers/docs/smart-contracts/) peuvent être transférés d'une chaîne à l'autre.
 
-## Avantages des passerelles {#benefits-of-bridges}
+## Avantages des ponts {#benefits-of-bridges}
 
 En termes simples, les ponts débloquent de nombreux cas d'utilisation en permettant aux réseaux blockchain d'échanger des données et de déplacer des actifs entre eux.
 
@@ -30,49 +30,49 @@ Pour les développeurs, les ponts activent les éléments suivants :
 
 ## Comment fonctionnent les ponts ? {#how-do-bridges-work}
 
-Bien qu'il existe différents [types de modèles de ponts](https://li.fi/knowledge-hub/blockchain-bridges-and-classification/), trois façons de faciliter le transfert inter-chaîne d'actifs se distinguent :
+Bien qu'il existe de nombreux [types de conceptions de ponts](https://li.fi/knowledge-hub/blockchain-bridges-and-classification/), trois manières de faciliter le transfert inter-chaînes d'actifs se distinguent :
 
-- **Verrouiller et frapper -** Verrouiller les actifs sur la chaîne source et frapper les actifs sur la chaîne de destination.
-- **Brûler et frapper -** Brûler les actifs sur la chaîne source et frapper les actifs sur la chaîne de destination.
-- **Échanges atomiques -** Échanger des actifs sur la chaîne source contre des actifs sur la chaîne de destination avec une autre partie.
+- **Verrouiller et frapper –** Verrouiller les actifs sur la chaîne source et frapper les actifs sur la chaîne de destination.
+- **Brûler et frapper –** Brûler les actifs sur la chaîne source et frapper les actifs sur la chaîne de destination.
+- **Échanges atomiques –** Échanger des actifs sur la chaîne source contre des actifs sur la chaîne de destination avec une autre partie.
 
 ## Types de ponts {#bridge-types}
 
 Les ponts peuvent généralement être classés dans l'un des compartiments suivants :
 
-- **Ponts natifs -** Ces ponts sont généralement construits pour amorcer la liquidité sur une blockchain particulière, ce qui permet aux utilisateurs de transférer plus facilement des fonds vers l'écosystème. Par exemple, l'[Arbitrum Bridge](https://bridge.arbitrum.io/) est conçu pour permettre aux utilisateurs de passer facilement du réseau principal Ethereum à Arbitrum. Parmi les autres ponts de ce type, citons le pont PoS Polygon, [Optimism Gateway](https://app.optimism.io/bridge), etc.
-- **Ponts basés sur des validateurs ou des oracles -** Ces ponts s'appuient sur un ensemble de validateurs ou d'oracles externes pour valider les transferts inter-chaînes. Exemples : Multichain et Across.
-- **Passerelles généralisées de passage de messages -** Ces passerelles peuvent transférer des actifs, ainsi que des messages et des données arbitraires à travers les chaînes. Exemples : Axelar, LayerZero, et Nomad.
-- **Réseaux de liquidité -** Ces ponts se concentrent principalement sur le transfert d'actifs d'une chaîne à une autre via des swaps atomiques. En général, ils ne prennent pas en charge le passage de messages inter-chaînes. Exemples : Connext et Hop.
+- **Ponts natifs –** Ces ponts sont généralement construits pour amorcer la liquidité sur une blockchain particulière, ce qui permet aux utilisateurs de transférer plus facilement des fonds vers l'écosystème. Par exemple, le [pont Arbitrum](https://bridge.arbitrum.io/) est conçu pour permettre aux utilisateurs de passer facilement du réseau principal Ethereum à Arbitrum. D'autres ponts de ce type incluent le pont PoS de Polygon, [Optimism Gateway](https://app.optimism.io/bridge), etc.
+- **Ponts basés sur un validateur ou un oracle –** Ces ponts s'appuient sur un ensemble de validateurs ou d'oracles externes pour valider les transferts inter-chaînes. Exemples : Multichain et Across.
+- **Ponts généralisés de transmission de messages –** Ces ponts peuvent transférer des actifs, ainsi que des messages et des données arbitraires entre les chaînes. Exemples : Axelar, LayerZero, et Nomad.
+- **Réseaux de liquidités –** Ces ponts se concentrent principalement sur le transfert d'actifs d'une chaîne à une autre via des échanges atomiques. En général, ils ne prennent pas en charge le passage de messages inter-chaînes. Exemples : Connext et Hop.
 
-## Les compromis à prendre en compte {#trade-offs}
+## Compromis à prendre en compte {#trade-offs}
 
 Avec les ponts, il n'y a pas de solution parfaite. Au contraire, il n'y a que des compromis faits pour remplir un objectif. Les développeurs et les utilisateurs peuvent évaluer les ponts en fonction des facteurs suivants :
 
-- **Sécurité -** Qui vérifie le système ? Les ponts sécurisés par des validateurs externes sont généralement moins sûrs que les ponts qui sont sécurisés localement ou nativement par les validateurs de la blockchain.
-- **Convivialité -** Combien de temps faut-il pour effectuer une transaction, et combien de transactions un utilisateur a-t-il dû signer ? Pour un développeur, combien de temps faut-il pour intégrer un pont, et quelle est la complexité du processus ?
-- **Connectivité -** Quelles sont les différentes chaînes de destination qu'un pont peut connecter (c'est-à-dire les rollups, les chaînes latérales, les autres blockchains de couche 1, etc.), et quelle est la difficulté d'intégrer une nouvelle blockchain ?
-- **Capacité à transmettre des données plus complexes -** Un pont peut-il permettre le transfert de messages et de données arbitraires plus complexes à travers les chaînes, ou ne prend-il en charge que les transferts d'actifs inter-chaînes ?
-- **Coût-efficacité -** Combien cela coûte-t-il de transférer des actifs d'une chaîne à l'autre via un pont ? En général, les ponts facturent une redevance fixe ou variable en fonction du coût du gaz et de la liquidité de certains itinéraires. Il est également essentiel d'évaluer la rentabilité d'un pont en fonction du capital nécessaire pour assurer sa sécurité.
+- **Sécurité –** Qui vérifie le système ? Les ponts sécurisés par des validateurs externes sont généralement moins sûrs que les ponts qui sont sécurisés localement ou nativement par les validateurs de la blockchain.
+- **Commodité –** Combien de temps faut-il pour finaliser une transaction et combien de transactions un utilisateur doit-il signer ? Pour un développeur, combien de temps faut-il pour intégrer un pont, et quelle est la complexité du processus ?
+- **Connectivité –** Quelles sont les différentes chaînes de destination qu'un pont peut connecter (p. ex. rollups, chaînes latérales, autres blockchains de couche 1, etc.) et quel est le degré de difficulté pour intégrer une nouvelle blockchain ?
+- **Capacité à transmettre des données plus complexes –** Un pont peut-il permettre le transfert de messages et de données arbitraires plus complexes entre les chaînes, ou ne prend-il en charge que les transferts d'actifs inter-chaînes ?
+- **Rentabilité –** Combien coûte le transfert d'actifs entre les chaînes via un pont ? En général, les ponts facturent une redevance fixe ou variable en fonction du coût du gaz et de la liquidité de certains itinéraires. Il est également essentiel d'évaluer la rentabilité d'un pont en fonction du capital nécessaire pour assurer sa sécurité.
 
 À un niveau élevé, les ponts peuvent être classés en deux catégories : ceux qui sont fiables et ceux qui ne le sont pas.
 
-- **Trusted -** Les ponts de confiance sont vérifiés de l'extérieur. Ils utilisent un ensemble externe de vérificateurs (fédérations avec multi-sig, systèmes de calcul multi-parties, réseau d'oracles) pour envoyer des données à travers les chaînes. Par conséquent, ils peuvent offrir une grande connectivité et permettre un passage de messages entièrement généralisé à travers les chaînes. Ils ont également tendance à être performants en termes de rapidité et de rentabilité. Cela se fait au détriment de la sécurité, car les utilisateurs doivent s'en remettre à la sécurité du pont.
-- **Trustless -** Ces ponts s'appuient sur les blockchains qu'ils connectent et leurs validateurs pour transférer des messages et des jetons. Elles sont « sans confiance » car elles n'ajoutent pas de nouvelles hypothèses de confiance (en plus des blockchains). Par conséquent, les ponts sans confiance sont considérés comme plus sûrs que les ponts avec confiance.
+- **De confiance –** Les ponts de confiance sont vérifiés de manière externe. Ils utilisent un ensemble externe de vérificateurs (fédérations avec multi-sig, systèmes de calcul multi-parties, réseau d'oracles) pour envoyer des données à travers les chaînes. Par conséquent, ils peuvent offrir une grande connectivité et permettre un passage de messages entièrement généralisé à travers les chaînes. Ils ont également tendance à être performants en termes de rapidité et de rentabilité. Cela se fait au détriment de la sécurité, car les utilisateurs doivent s'en remettre à la sécurité du pont.
+- **Sans confiance –** Ces ponts s'appuient sur les blockchains qu'ils connectent et leurs validateurs pour transférer des messages et des jetons. Elles sont « sans confiance » car elles n'ajoutent pas de nouvelles hypothèses de confiance (en plus des blockchains). Par conséquent, les ponts sans confiance sont considérés comme plus sûrs que les ponts avec confiance.
 
 Pour évaluer les ponts sans confiance en fonction d'autres facteurs, nous devons les décomposer en ponts de passage de messages généralisés et en réseaux de liquidité.
 
-- **Ponts généralisés de passage de messages -** Ces ponts excellent en matière de sécurité et de capacité à transférer des données plus complexes à travers les chaînes. En général, ils sont également bons en termes de rentabilité. Cependant, ces points forts se font généralement au détriment de la connectivité pour les ponts de clients légers (ex : IBC) et des inconvénients de vitesse pour les ponts optimistes (ex : Nomad) qui utilisent des preuves de fraude.
-- **Réseaux de liquidité -** Ces ponts utilisent des swaps atomiques pour transférer les actifs et sont des systèmes vérifiés localement (c'est-à-dire qu'ils utilisent les validateurs des blockchains sous-jacentes pour vérifier les transactions). Par conséquent, ils excellent en matière de sécurité et de rapidité. En outre, ils sont considérés comme comparativement rentables et offrent une bonne connectivité. Toutefois, le principal inconvénient est leur incapacité à transmettre des données plus complexes, car ils ne prennent pas en charge le passage de messages inter-chaînes.
+- **Ponts généralisés de transmission de messages –** Ces ponts excellent en matière de sécurité et par leur capacité à transférer des données plus complexes entre les chaînes. En général, ils sont également bons en termes de rentabilité. Cependant, ces points forts se font généralement au détriment de la connectivité pour les ponts de clients légers (ex : IBC) et des inconvénients de vitesse pour les ponts optimistes (ex : Nomad) qui utilisent des preuves de fraude.
+- **Réseaux de liquidités –** Ces ponts utilisent des échanges atomiques pour transférer des actifs et sont des systèmes vérifiés localement (c'est-à-dire qu'ils utilisent les validateurs des blockchains sous-jacentes pour vérifier les transactions). Par conséquent, ils excellent en matière de sécurité et de rapidité. En outre, ils sont considérés comme comparativement rentables et offrent une bonne connectivité. Toutefois, le principal inconvénient est leur incapacité à transmettre des données plus complexes, car ils ne prennent pas en charge le passage de messages inter-chaînes.
 
-## Risque avec les ponts {#risk-with-bridges}
+## Risques liés aux ponts {#risk-with-bridges}
 
-Les ponts représentent les trois premiers [plus gros hacks de DeFi](https://rekt.news/leaderboard/) et en sont encore aux premiers stades de développement. L'utilisation de tout pont comporte les risques suivants :
+Les ponts sont à l'origine des trois plus [grands piratages de la DeFi](https://rekt.news/leaderboard/) et sont encore à un stade précoce de leur développement. L'utilisation de tout pont comporte les risques suivants :
 
-- **Risque lié aux contrats intelligents -** Alors que de nombreux ponts ont passé avec succès les audits, il suffit d'une faille dans un contrat intelligent pour que les actifs soient exposés à des piratages (ex : [Pont Wormhole de Solana](https://rekt.news/wormhole-rekt/)).
-- **Risques financiers systémiques** - De nombreux ponts utilisent des actifs enveloppés pour frapper des versions canoniques de l'actif original sur une nouvelle chaîne. Cela expose l'écosystème à un risque systémique, car nous avons vu des versions enveloppées de jetons exploités.
-- **Risque de contrepartie -** Certains ponts utilisent une conception de confiance qui exige que les utilisateurs se fient à l'hypothèse selon laquelle les validateurs ne s'entendront pas pour voler les fonds des utilisateurs. La nécessité pour les utilisateurs de faire confiance à ces acteurs tiers les expose à des risques tels que les rabattements, la censure et d'autres activités malveillantes.
-- **Problèmes en suspens -** Étant donné que les ponts en sont aux premiers stades de leur développement, de nombreuses questions restent sans réponse quant à la manière dont les ponts se comporteront dans différentes conditions de marché, comme les périodes de congestion du réseau et lors d'événements imprévus tels que des attaques au niveau du réseau ou des reculs de l'état. Cette incertitude présente certains risques, dont le degré est encore inconnu.
+- **Risque lié aux contrats intelligents –** Bien que de nombreux ponts aient passé avec succès des audits, il suffit d'une seule faille dans un contrat intelligent pour que les actifs soient exposés à des piratages (ex. : [le pont Wormhole de Solana](https://rekt.news/wormhole-rekt/)).
+- **Risques financiers systémiques –** De nombreux ponts utilisent des actifs enveloppés pour frapper des versions canoniques de l'actif original sur une nouvelle chaîne. Cela expose l'écosystème à un risque systémique, car nous avons vu des versions enveloppées de jetons exploités.
+- **Risque de contrepartie –** Certains ponts utilisent une conception de confiance qui exige des utilisateurs qu'ils partent du principe que les validateurs ne s'entendront pas pour voler leurs fonds. La nécessité pour les utilisateurs de faire confiance à ces acteurs tiers les expose à des risques tels que les rabattements, la censure et d'autres activités malveillantes.
+- **Questions ouvertes –** Étant donné que les ponts n'en sont qu'aux premiers stades de leur développement, de nombreuses questions restent sans réponse quant à la manière dont ils se comporteront dans différentes conditions de marché, comme les périodes de congestion du réseau et lors d'événements imprévus tels que des attaques au niveau du réseau ou des retours en arrière de l'état. Cette incertitude présente certains risques, dont le degré est encore inconnu.
 
 ## Comment les dApps peuvent utiliser les ponts ? {#how-can-dapps-use-bridges}
 
@@ -82,56 +82,57 @@ Voici quelques applications pratiques que les développeurs peuvent envisager à
 
 Pour les développeurs, il existe de nombreuses façons d'ajouter la prise en charge des ponts :
 
-1. **Construire son propre pont -** Construire un pont sécurisé et fiable n'est pas chose aisée, surtout si l'on emprunte une voie qui minimise la confiance. En outre, elle exige des années d'expérience et d'expertise technique liées aux études d'évolutivité et d'interopérabilité. En outre, il faudrait une équipe expérimentée pour maintenir un pont et attirer suffisamment de liquidités pour le rendre réalisable.
+1. **Construire votre propre pont –** Construire un pont sécurisé et fiable n'est pas chose aisée, surtout si vous empruntez une voie qui minimise la confiance. En outre, elle exige des années d'expérience et d'expertise technique liées aux études d'évolutivité et d'interopérabilité. En outre, il faudrait une équipe expérimentée pour maintenir un pont et attirer suffisamment de liquidités pour le rendre réalisable.
 
-2. **Afficher pour les utilisateurs plusieurs options de pont -** De nombreuses [dApps](/developers/docs/dapps/) exigent que les utilisateurs disposent de leur jeton natif pour interagir avec elles. Pour permettre aux utilisateurs d'accéder à leurs jetons, ils proposent différentes options de pont sur leur site web. Cependant, cette méthode est une solution rapide au problème car elle éloigne l'utilisateur de l'interface de la dApp et l'oblige à interagir avec d'autres dApps et ponts. Il s'agit d'une expérience d'intégration lourde, avec un risque accru de faire des erreurs.
+2. **Présenter plusieurs options de pont aux utilisateurs –** De nombreuses [dapps](/developers/docs/dapps/) exigent que les utilisateurs disposent de leur jeton natif pour interagir avec elles. Pour permettre aux utilisateurs d'accéder à leurs jetons, ils proposent différentes options de pont sur leur site web. Cependant, cette méthode est une solution rapide au problème car elle éloigne l'utilisateur de l'interface de la dApp et l'oblige à interagir avec d'autres dApps et ponts. Il s'agit d'une expérience d'intégration lourde, avec un risque accru de faire des erreurs.
 
-3. **Intégration d'un pont -** Cette solution ne nécessite pas que la dApp envoie les utilisateurs vers le pont externe et les interfaces des DEX. Il permet aux dApps d'améliorer l'expérience d'intégration des utilisateurs. Toutefois, cette approche a ses limites :
+3. **Intégrer un pont –** Cette solution ne nécessite pas que la dapp envoie les utilisateurs vers le pont externe et les interfaces des DEX. Il permet aux dApps d'améliorer l'expérience d'intégration des utilisateurs. Toutefois, cette approche a ses limites :
 
    - L'évaluation et l'entretien des ponts sont difficiles et prennent beaucoup de temps.
    - La sélection d'un seul pont crée un point unique de défaillance et de dépendance.
    - La dApp est limitée par les capacités du pont.
    - Les ponts seuls pourraient ne pas suffire. Les dApps pourraient avoir besoin des DEX pour offrir plus de fonctionnalités telles que les échanges inter-chaînes.
 
-4. **Intégration de plusieurs ponts -** Cette solution résout de nombreux problèmes liés à l'intégration d'un seul pont. Cependant, elle présente également des limites, car l'intégration de plusieurs ponts consomme des ressources et crée des frais généraux techniques et de communication pour les développeurs - la ressource la plus rare dans le domaine de la cryptographie.
+4. **Intégrer plusieurs ponts –** Cette solution résout de nombreux problèmes liés à l'intégration d'un seul pont. Cependant, elle présente également des limites, car l'intégration de plusieurs ponts consomme des ressources et crée des frais généraux techniques et de communication pour les développeurs - la ressource la plus rare dans le domaine de la cryptographie.
 
-5. **Intégrer un agrégateur de ponts -** Une autre option pour les dApps consiste à intégrer une solution d'agrégation de ponts qui leur donne accès à plusieurs ponts. Les agrégateurs de ponts héritent des forces de tous les ponts et ne sont donc pas limités par les capacités d'un seul pont. En particulier, les agrégateurs de ponts assurent généralement la maintenance des intégrations de ponts, ce qui évite à la dApp d'avoir à se préoccuper des aspects techniques et opérationnels d'une intégration de pont.
+5. **Intégrer un agrégateur de ponts –** Une autre option pour les dapps consiste à intégrer une solution d'agrégation de ponts qui leur donne accès à plusieurs ponts. Les agrégateurs de ponts héritent des forces de tous les ponts et ne sont donc pas limités par les capacités d'un seul pont. En particulier, les agrégateurs de ponts assurent généralement la maintenance des intégrations de ponts, ce qui évite à la dApp d'avoir à se préoccuper des aspects techniques et opérationnels d'une intégration de pont.
 
 Cela dit, les agrégateurs de ponts ont aussi leurs limites. Par exemple, s'ils peuvent offrir plus d'options de pont, il existe généralement beaucoup plus de ponts sur le marché que ceux proposés sur la plateforme de l'agrégateur. En outre, tout comme les ponts, les agrégateurs de ponts sont également exposés aux risques liés aux contrats intelligents et à la technologie (plus de contrats intelligents = plus de risques).
 
 Si une dapp emprunte la voie de l'intégration d'un pont ou d'un agrégateur, il existe différentes options en fonction du degré d'intégration souhaité. Par exemple, s'il s'agit uniquement d'une intégration frontale visant à améliorer l'expérience d'accueil des utilisateurs, une dApp intégrera le widget. Toutefois, si l'intégration vise à explorer des stratégies inter-chaînes plus approfondies comme le jalonnement, l'agriculture de rendement, etc., la dApp intègre le SDK ou l'API.
 
-### Déploiement d'une dApp sur plusieurs chaînes {#deploying-a-dapp-on-multiple-chains}
+### Déployer une dapp sur plusieurs chaînes {#deploying-a-dapp-on-multiple-chains}
 
-Pour déployer une dApp sur plusieurs chaînes, les développeurs peuvent utiliser des plateformes de développement telles que [Alchemy](https://www.alchemy.com/), [Hardhat](https://hardhat.org/), [Moralis](https://moralis.io/), etc. En général, ces plateformes sont fournies avec des plugins composables qui permettent aux dApps de passer d'une chaîne à l'autre. Par exemple, les développeurs peuvent utiliser un proxy de déploiement déterministe proposé par le plugin [hardhat-deploy](https://github.com/wighawag/hardhat-deploy).
+Pour déployer une dapp sur plusieurs chaînes, les développeurs peuvent utiliser des plateformes de développement comme [Alchemy](https://www.alchemy.com/), [Hardhat](https://hardhat.org/), [Moralis](https://moralis.io/), etc. En général, ces plateformes sont fournies avec des plugins composables qui permettent aux dApps de passer d'une chaîne à l'autre. Par exemple, les développeurs peuvent utiliser un proxy de déploiement déterministe proposé par le [plugin hardhat-deploy](https://github.com/wighawag/hardhat-deploy).
 
 #### Exemples :
 
-- [Comment construire des dApps inter-chaine](https://moralis.io/how-to-build-cross-chain-dapps/)
-- [Création d'une place de marché NFT inter-chaînes](https://youtu.be/WZWCzsB1xUE)
-- [Moralis : Construire des dApps NFT inter-chaîne](https://www.youtube.com/watch?v=ehv70kE1QYo)
+- [Comment créer des dapps inter-chaînes](https://moralis.io/how-to-build-cross-chain-dapps/)
+- [Créer une place de marché NFT inter-chaînes](https://youtu.be/WZWCzsB1xUE)
+- [Moralis : Créer des dapps NFT inter-chaînes](https://www.youtube.com/watch?v=ehv70kE1QYo)
 
-### Suivi de l'activité contractuelle à travers les chaînes {#monitoring-contract-activity-across-chains}
+### Surveiller l'activité des contrats entre les chaînes {#monitoring-contract-activity-across-chains}
 
-Pour surveiller l'activité des contrats dans les chaînes, les développeurs peuvent utiliser des sous-graphes et des plateformes de développement comme Tenderly pour observer les contrats intelligents en temps réel. Ces plates-formes disposent également d'outils qui offrent une plus grande fonctionnalité de surveillance des données pour les activités inter-chaînes, comme la vérification des [événements émis par les contrats](https://docs.soliditylang.org/en/v0.8.14/contracts.html?highlight=events#events), etc.
+Pour surveiller l'activité des contrats dans les chaînes, les développeurs peuvent utiliser des sous-graphes et des plateformes de développement comme Tenderly pour observer les contrats intelligents en temps réel. Ces plateformes disposent également d'outils qui offrent une plus grande fonctionnalité de surveillance des données pour les activités inter-chaînes, comme la vérification des [événements émis par les contrats](https://docs.soliditylang.org/en/v0.8.14/contracts.html?highlight=events#events), etc.
 
 #### Outils
 
-- [Le réseau Graph](https://thegraph.com/en/)
+- [The Graph](https://thegraph.com/en/)
 - [Tenderly](https://tenderly.co/)
 
-## Complément d'information {#further-reading}
-- [Blockchain Bridges](/bridges/) – ethereum.org
-- [Cadre d’évaluation des risques des ponts de L2Beat](https://l2beat.com/bridges/summary)
-- [Ponts Blockchain : Construire des réseaux de crypto-réseaux](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) - 8 septembre 2021– Dmitriy Berenzon
-- [Le Trilemme d'interopérabilité](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) - 1er octobre 2021 – Arjun Bhuptani
-- [Clusters : comment les ponts de confiance et les ponts à confiance minimisée façonnent le paysage multi-chaîne](https://blog.celestia.org/clusters/) – 4 octobre 2021 – Mustafa Al-Bassam
-- [LI.FI : Avec les ponts, la confiance est un spectre](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) – 28 avril 2022 – Arjun Chand
+## En savoir plus {#further-reading}
+
+- [Ponts de blockchain](/bridges/) – ethereum.org
+- [Cadre de risque des ponts de L2Beat](https://l2beat.com/bridges/summary)
+- [Ponts de blockchain : construire des réseaux de cryptoréseaux](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) - 8 septembre 2021 – Dmitriy Berenzon
+- [Le trilemme de l'interopérabilité](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) - 1er octobre 2021 – Arjun Bhuptani
+- [Clusters : Comment les ponts de confiance et à confiance minimisée façonnent le paysage multichaîne](https://blog.celestia.org/clusters/) - 4 octobre 2021 – Mustafa Al-Bassam
+- [LI.FI : Avec les ponts, la confiance est un spectre](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) - 28 avril 2022 – Arjun Chand
 - [L'état des solutions d'interopérabilité des rollups](https://web.archive.org/web/20250428015516/https://research.2077.xyz/the-state-of-rollup-interoperability) - 20 juin 2024 – Alex Hook
-- [Exploiter la sécurité partagée pour une interopérabilité cross-chain sécurisée : comités d'état Lagrange et au-delà](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - 12 juin 2024 – Emmanuel Awosika
+- [Exploiter la sécurité partagée pour une interopérabilité inter-chaînes sécurisée : les comités d'état de Lagrange et au-delà](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - 12 juin 2024 – Emmanuel Awosika
 
-En outre, voici quelques présentations perspicaces de [James Prestwich](https://twitter.com/_prestwich) qui peuvent aider à développer une compréhension plus approfondie des ponts :
+De plus, voici quelques présentations pertinentes de [James Prestwich](https://twitter.com/_prestwich) qui peuvent aider à développer une compréhension plus approfondie des ponts :
 
 - [Construire des ponts, pas des jardins clos](https://youtu.be/ZQJWMiX4hT0)
-- [Faire tomber les ponts](https://youtu.be/b0mC-ZqN8Oo)
-- [Pourquoi les ponts brûlent-ils ?](https://youtu.be/c7cm2kd20j8)
+- [Analyse des ponts](https://youtu.be/b0mC-ZqN8Oo)
+- [Pourquoi les ponts brûlent-ils](https://youtu.be/c7cm2kd20j8)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/index.md
index 827efdffaa6..1d840a3502e 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/index.md
@@ -1,20 +1,20 @@
 ---
-title: Mécanismes de consensus
-description: Explication des protocoles de consensus dans les systèmes distribués et du rôle qu'ils jouent dans Ethereum.
+title: "Mécanismes de consensus"
+description: "Explication des protocoles de consensus dans les systèmes distribués et du rôle qu'ils jouent dans Ethereum."
 lang: fr
 ---
 
-Le terme « mécanisme de consensus » est souvent utilisé familièrement pour désigner les protocoles de preuve d'enjeu, de preuve de travail ou de preuve d'autorité. Néanmoins, ceux-ci ne sont que des composantes du mécanisme de consensus qui protègent de façon préventive contre les [attaques de type 'Sybil](/glossary/#sybil-attack). Les mécanismes de consensus désignent la pile complète des idées, protocoles et incitations qui permettent à un ensemble de nœuds distribués de se mettre d'accord sur l'état d'une blockchain.
+Le terme « mécanisme de consensus » est souvent utilisé familièrement pour désigner les protocoles de preuve d'enjeu, de preuve de travail ou de preuve d'autorité. Cependant, ce ne sont que des composantes des mécanismes de consensus qui protègent contre les [attaques Sybil](/glossary/#sybil-attack). Les mécanismes de consensus désignent la pile complète des idées, protocoles et incitations qui permettent à un ensemble de nœuds distribués de se mettre d'accord sur l'état d'une blockchain.
 
 ## Prérequis {#prerequisites}
 
-Pour mieux comprendre cette page, nous vous recommandons de commencer par lire cette [introduction à Ethereum](/developers/docs/intro-to-ethereum/).
+Pour mieux comprendre cette page, nous vous recommandons de lire d'abord notre [introduction à Ethereum](/developers/docs/intro-to-ethereum/).
 
 ## Qu'est-ce que le consensus ? {#what-is-consensus}
 
 Par consensus, nous voulons dire qu'un accord général a été trouvé. Prenons le cas d'un groupe de personnes qui vont au cinéma. S'il n'existe pas de désaccord sur le choix du film, alors un consensus se dégage. En cas de désaccord, le groupe doit avoir les moyens de décider du film à voir. Dans un cas extrême, le groupe finira par se séparer.
 
-En ce qui concerne la blockchain Ethereum, parvenir à un consensus signifie qu'au moins 66 % des nœuds du réseau sont d'accord sur l'état global du réseau.
+En ce qui concerne la blockchain Ethereum, le processus est formalisé, et parvenir à un consensus signifie qu'au moins 66 % des nœuds du réseau s'accordent sur l'état global du réseau.
 
 ## Qu'est-ce qu'un mécanisme de consensus ? {#what-is-a-consensus-mechanism}
 
@@ -32,7 +32,7 @@ Ces composantes forment ensemble le mécanisme de consensus.
 
 ### Basé sur la preuve de travail {#proof-of-work}
 
-Tout comme Bitcoin, Ethereum a utilisé un protocole de consensus basé sur la **preuve de travail (PoW)**.
+Tout comme Bitcoin, Ethereum utilisait autrefois un protocole de consensus basé sur la **preuve de travail (PoW)**.
 
 #### Création de blocs {#pow-block-creation}
 
@@ -56,7 +56,7 @@ Les validateurs créent des blocs. Un validateur est sélectionné aléatoiremen
 
 Un système de preuve d'enjeu est sécurisé économiquement dans la mesure où un attaquant qui tente de prendre le contrôle de la chaîne doit détruire une quantité massive d'ETH. Un système de récompenses encourage les validateurs individuels à se comporter honnêtement et les pénalités dissuadent les validateurs d’agir de manière malveillante.
 
-En savoir plus sur la [preuve de travail](/developers/docs/consensus-mechanisms/pos/)
+En savoir plus sur la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
 
 ### Un guide visuel {#types-of-consensus-video}
 
@@ -64,27 +64,27 @@ En savoir plus sur les différents types de mécanismes de consensus utilisés s
 
 <YouTube id="ojxfbN78WFQ" />
 
-### Résistance à l'attaque Sybil et sélection en chaîne {#sybil-chain}
+### Résistance Sybil & sélection de chaîne {#sybil-chain}
 
 La preuve de travail et la preuve d’enjeu ne sont pas des protocoles de consensus, mais on les appelle souvent ainsi par souci de simplicité. Ce sont en fait des mécanismes de résistance à l'attaque Sybil et des sélecteurs d'auteurs de bloc ; ils permettent de décider qui est l'auteur du dernier bloc. Un autre composant important est l'algorithme de sélection de chaînes (alias choix de fourche) qui permet aux nœuds de choisir un unique bloc correct en tête de chaîne dans des scénarios où plusieurs blocs se trouveraient dans la même position.
 
-La **Résistance à l'attaque Sybil** mesure l'efficacité d'un protocole face à une attaque Sybil. La résistance à ce type d'attaque est essentielle pour une blockchain décentralisée et permet aux mineurs et validateurs d'être récompensés de manière égale en fonction des ressources mises à disposition. La preuve de travail et la preuve de mise en jeu protègent de ce risque en obligeant les utilisateurs à dépenser beaucoup d'énergie ou à mettre beaucoup de collatérales. Ces protections sont un moyen de dissuasion économique contre les attaques Sybil.
+La **résistance Sybil** mesure la capacité d'un protocole à se défendre contre une attaque Sybil. La résistance à ce type d'attaque est essentielle pour une blockchain décentralisée et permet aux mineurs et validateurs d'être récompensés de manière égale en fonction des ressources mises à disposition. La preuve de travail et la preuve de mise en jeu protègent de ce risque en obligeant les utilisateurs à dépenser beaucoup d'énergie ou à mettre beaucoup de collatérales. Ces protections sont un moyen de dissuasion économique contre les attaques Sybil.
 
-**Une règle de sélection de la chaîne** est utilisée pour décider quelle chaîne est la chaîne « correcte ». Bitcoin utilise actuellement la règle de la « plus longue chaîne », ce qui signifie que quelle que soit la chaîne de blocs la plus longue, elle sera celle que les autres nœuds acceptent comme valide et avec laquelle ils travailleront. Pour les chaînes de preuve de travail, la chaîne la plus longue est déterminée par la difficulté cumulative totale de preuve de travail. Ethereum avait également l'habitude d'utiliser la règle de la chaîne la plus longue ; cependant, maintenant qu'Ethereum fonctionne avec la preuve d'enjeu, il a adopté un algorithme de choix de fourche mis à jour qui mesure le « poids » de la chaîne. Le poids est la somme cumulée des votes de validateur, pondérée par les soldes en Ether misés par les validateurs.
+Une **règle de sélection de chaîne** est utilisée pour décider quelle chaîne est la chaîne "correcte". Bitcoin utilise actuellement la règle de la « plus longue chaîne », ce qui signifie que quelle que soit la chaîne de blocs la plus longue, elle sera celle que les autres nœuds acceptent comme valide et avec laquelle ils travailleront. Pour les chaînes de preuve de travail, la chaîne la plus longue est déterminée par la difficulté cumulative totale de preuve de travail. Ethereum avait également l'habitude d'utiliser la règle de la plus longue chaîne ; Cependant, maintenant qu'Ethereum fonctionne avec la preuve d'enjeu, il a adopté un algorithme de choix de fourche mis à jour qui mesure le 'poids' de la chaîne. Le poids est la somme cumulée des votes de validateur, pondérée par les soldes en Ether misés par les validateurs.
 
-Ethereum utilise un mécanisme de consensus connu sous le nom de [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) qui combine la preuve d'enjeu [Casper FFG](https://arxiv.org/abs/1710.09437) avec la [règle de choix de fourche GHOST](https://arxiv.org/abs/2003.03052).
+Ethereum utilise un mécanisme de consensus connu sous le nom de [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) qui combine la [preuve d'enjeu Casper FFG](https://arxiv.org/abs/1710.09437) avec la [règle de choix de fourche GHOST](https://arxiv.org/abs/2003.03052).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Qu'est-ce qu'un algorithme de consensus de la blockchain ?](https://academy.binance.com/en/articles/what-is-a-blockchain-consensus-algorithm)
-- [Qu'est-ce que le Consensus de Nakamoto ? Guide complet du débutant](https://blockonomi.com/nakamoto-consensus/)
+- [Qu'est-ce qu'un algorithme de consensus de blockchain ?](https://academy.binance.com/en/articles/what-is-a-blockchain-consensus-algorithm)
+- [Qu'est-ce que le Consensus Nakamoto ?  Guide complet pour débutant](https://blockonomi.com/nakamoto-consensus/)
 - [Comment fonctionne Casper ?](https://medium.com/unitychain/intro-to-casper-ffg-9ed944d98b2d)
-- [À propos de la sécurité et les performances des blockchains de la preuve de travail](https://eprint.iacr.org/2016/555.pdf)
-- [Panne Byzantine](https://en.wikipedia.org/wiki/Byzantine_fault)
+- [Sur la sécurité et les performances des blockchains à preuve de travail](https://eprint.iacr.org/2016/555.pdf)
+- [Panne byzantine](https://en.wikipedia.org/wiki/Byzantine_fault)
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
-## Thèmes connexes {#related-topics}
+## Sujets connexes {#related-topics}
 
 - [Preuve de travail](/developers/docs/consensus-mechanisms/pow/)
 - [Minage](/developers/docs/consensus-mechanisms/pow/mining/)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/poa/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/poa/index.md
index b0a5269d00e..52d07205ece 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/poa/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/poa/index.md
@@ -1,10 +1,10 @@
 ---
-title: Preuve d'autorité (PoA)
-description: Explication du protocole de consensus « preuve d'autorité » et de son rôle dans l'écosystème blockchain.
+title: "Preuve d'autorité (PoA)"
+description: "Explication du protocole de consensus « preuve d'autorité » et de son rôle dans l'écosystème blockchain."
 lang: fr
 ---
 
-La **Preuve d'autorité (PoA)** est un algorithme de consensus basé sur la réputation qui est une version modifiée de la [preuve d'enjeu] (/developers/docs/consensus-mechanisms/pos/). Il est principalement utilisé par des chaînes privées, des réseaux de test et des réseaux de développement locaux. Le PoA est un algorithme de consensus basé sur la réputation qui nécessite de faire confiance à un ensemble de signataires autorisés pour produire des blocs, plutôt que de se baser sur un mécanisme d'enjeu comme le PoS.
+La **Preuve d'autorité (PoA)** est un algorithme de consensus basé sur la réputation qui est une version modifiée de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Il est principalement utilisé par des chaînes privées, des réseaux de test et des réseaux de développement locaux. Le PoA est un algorithme de consensus basé sur la réputation qui nécessite de faire confiance à un ensemble de signataires autorisés pour produire des blocs, plutôt que de se baser sur un mécanisme d'enjeu comme le PoS.
 
 ## Prérequis {#prerequisites}
 
@@ -12,9 +12,9 @@ Pour mieux comprendre cette page, nous vous recommandons d'abord d'en lire plus
 
 ## Qu'est-ce que la Preuve d'autorité (PoA) ? {#what-is-poa}
 
-La Preuve d'autorité est une version modifiée de la **[Preuve d'enjeu] (/developers/docs/consensus-mechanisms/pos/) (PoS)** qui est un algorithme de consensus basé sur la réputation plutôt que sur un mécanisme basé sur l'enjeu avec le PoS. Le terme a été introduit pour la première fois en 2017 par Gavin Wood, et cet algorithme de consensus est principalement utilisé par des chaînes privées, des réseaux de test et des réseaux de développement locaux, car il surmonte le besoin de ressources de haute qualité comme le PoW, et résout les problèmes de scalabilité avec le PoS en ayant un petit sous-ensemble de nœuds stockant la blockchain et produisant des blocs.
+La Preuve d'autorité est une version modifiée de la **[Preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/) (PoS)** qui est un algorithme de consensus basé sur la réputation plutôt que sur un mécanisme basé sur l'enjeu avec le PoS. Le terme a été introduit pour la première fois en 2017 par Gavin Wood, et cet algorithme de consensus est principalement utilisé par des chaînes privées, des réseaux de test et des réseaux de développement locaux, car il surmonte le besoin de ressources de haute qualité comme le PoW, et résout les problèmes de scalabilité avec le PoS en ayant un petit sous-ensemble de nœuds stockant la blockchain et produisant des blocs.
 
-La Preuve d'autorité nécessite de faire confiance à un ensemble de signataires autorisés qui sont définis dans le [bloc de genèse] (/glossary/#genesis-block). Dans la plupart des implémentations actuelles, tous les signataires autorisés conservent un pouvoir et des privilèges égaux lorsqu'il s'agit de déterminer le consensus de la chaîne. L'idée derrière l'enjeu sur la réputation est que chaque validateur autorisé est bien connu de tous grâce à des éléments tels que la vérification de l'identité des clients (KYC) ou parce qu'il fait partie d'une organisation bien connue qui est le seul validateur. Ainsi, si un validateur commet une erreur, son identité est connue.
+La Preuve d'autorité nécessite de faire confiance à un ensemble de signataires autorisés qui sont définis dans le [bloc de genèse](/glossary/#genesis-block). Dans la plupart des implémentations actuelles, tous les signataires autorisés conservent un pouvoir et des privilèges égaux lorsqu'il s'agit de déterminer le consensus de la chaîne. L'idée derrière l'enjeu sur la réputation est que chaque validateur autorisé est bien connu de tous grâce à des éléments tels que la vérification de l'identité des clients (KYC) ou parce qu'il fait partie d'une organisation bien connue qui est le seul validateur. Ainsi, si un validateur commet une erreur, son identité est connue.
 
 Il existe plusieurs implémentations de PoA, mais l'implémentation standard d'Ethereum est **clique**, qui implémente [EIP-225](https://eips.ethereum.org/EIPS/eip-225). Clique est agréable à utiliser par les développeurs et facilite l'implémentation de normes, prenant en charge tous les types de synchronisation de clients. D'autres implémentations incluent [IBFT 2.0](https://besu.hyperledger.org/private-networks/concepts/poa) and [Aura](https://openethereum.github.io/Chain-specification).
 
@@ -77,3 +77,4 @@ Regardez une explication en vidéo de la preuve d'autorité :
 
 - [Preuve de travail](/developers/docs/consensus-mechanisms/pow/)
 - [Preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
+
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
index e6d5e53c873..898a503c224 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
@@ -1,6 +1,6 @@
 ---
-title: Attaques visant la preuve d'enjeu Ethereum et modes de défense
-description: Découvrez les vecteurs d'attaques connus sur la preuve d'enjeu Ethereum et ses modes de défense.
+title: "Attaques visant la preuve d'enjeu Ethereum et modes de défense"
+description: "Découvrez les vecteurs d'attaques connus sur la preuve d'enjeu Ethereum et ses modes de défense."
 lang: fr
 ---
 
@@ -120,7 +120,7 @@ Avec plus de 50 % de la mise totale, l'attaquant pourrait dominer l'algorithme d
 
 ### Attaquants utilisant plus de 66 % du total des mises {#attackers-with-66-stake}
 
-Un attaquant disposant de 66 % ou plus de l'ether total misé peut finaliser sa chaîne préférée sans avoir à contraindre aucun validateur honnête. L'attaquant peut simplement voter pour sa fourche préférée puis la finaliser, simplement parce qu'il peut voter avec une super-majorité malhonnête. En tant que détenteur de la super-majorité des enjeux, l'attaquant contrôlerait toujours le contenu des blocs finalisés, avec le pouvoir de dépenser, rembobiner et dépenser à nouveau, censurer certaines transactions et réorganiser la chaîne à volonté. En achetant de l'ether supplémentaire pour contrôler 66 % plutôt que 51 %, l'attaquant achète effectivement la capacité d'effectuer des réarrangements ex post et des réversions de finalité (c'est-à-dire de changer le passé ainsi que de contrôler l'avenir). Les seules véritables défenses ici sont l'énorme coût de 66 % de l'ether total misé, et la possibilité de se replier sur la couche sociale pour coordonner l'adoption d'une fourche alternative. Nous verrons cela plus en détail dans la section suivante.
+Un attaquant disposant de 66 % ou plus de l'ether total misé peut finaliser sa chaîne préférée sans avoir à contraindre aucun validateur honnête. L'attaquant peut simplement voter pour sa fourche préférée puis la finaliser, simplement parce qu'il peut voter avec une super-majorité malhonnête. En tant que détenteur de la super-majorité des enjeux, l'attaquant contrôlerait toujours le contenu des blocs finalisés, avec le pouvoir de dépenser, rembobiner et dépenser à nouveau, censurer certaines transactions et réorganiser la chaîne à volonté. En achetant de l'ether supplémentaire pour contrôler 66 % plutôt que 51 %, l'attaquant achète effectivement la capacité d'effectuer des reorgs ex post et des réversions de finalité (c'est-à-dire de changer le passé ainsi que de contrôler l'avenir). Les seules véritables défenses ici sont l'énorme coût de 66 % de l'ether total misé, et la possibilité de se replier sur la couche sociale pour coordonner l'adoption d'une fourche alternative. Nous verrons cela plus en détail dans la section suivante.
 
 ## Les personnes : la dernière ligne de défense {#people-the-last-line-of-defense}
 
@@ -130,7 +130,7 @@ L'une des forces du consensus de la preuve d'enjeu d'Ethereum est qu'il existe t
 
 Quelle que soit la pénalité imposée à l'attaquant, la communauté doit également décider ensemble si la chaîne malhonnête, bien que favorisée par l'algorithme de choix de fourche codé dans les clients Ethereum, est en réalité invalide et que la communauté devrait plutôt construire sur la chaîne honnête. Les validateurs honnêtes pourraient collectivement accepter de construire sur une fourche acceptée par la communauté de la blockchain Ethereum qui aurait, par exemple, bifurqué de la chaîne canonique avant le début de l'attaque ou dont les validateurs attaquants seraient supprimés de force. Les validateurs honnêtes seraient incités à construire sur cette chaîne car ils éviteraient les pénalités qui leur seraient infligées pour ne pas avoir attesté (à juste titre) de la chaîne de l'attaquant. Les échanges, les points d'entrée et les applications construites sur Ethereum préféreraient probablement être sur la chaîne honnête et suivraient les validateurs honnêtes vers la blockchain honnête.
 
-Cependant, il s'agirait d'un défi important en matière de gouvernance. Certains utilisateurs et validateurs subiraient inévitablement des pertes à la suite du retour à la chaîne honnête, les transactions dans les blocs validés après l'attaque pourraient potentiellement être annulées, perturbant la couche d'application, et cela remettrait tout simplement en question l'éthique de certains utilisateurs qui ont tendance à croire que « le code est la loi ». Les échanges et les applications auront très probablement établi un lien entre des actions hors chaîne et des transactions en chaîne qui pourraient maintenant être annulées, déclenchant une cascade de rétractations et de révisions qui seraient difficiles à démêler équitablement, surtout si les gains mal acquis ont été mélangés, déposés dans la DeFi ou d'autres dérivés ayant des effets secondaires pour les utilisateurs honnêtes. Certains utilisateurs, peut-être même institutionnels, auraient certainement déjà bénéficié de la chaîne malhonnête, soit par habileté, soit par hasard, et pourraient s'opposer à une fourche pour protéger leurs gains. Il y a eu des appels à répéter la réponse de la communauté face aux attaques à plus de 51 % afin qu'une réaction coordonnée et raisonnable puisse être exécutée rapidement. Vitalik a mené des discussions utiles sur ethresear.ch [ici](https://ethresear.ch/t/timeliness-detectors-and-51-attack-recovery-in-blockchains/6925) et [ici](https://ethresear.ch/t/responding-to-51-attacks-in-casper-ffg/6363) et sur Twitter ici. L'objectif d'une réponse sociale coordonnée devrait être de punir très précisément l'attaquant et de minimiser les effets sur les autres utilisateurs.
+Cependant, il s'agirait d'un défi important en matière de gouvernance. Certains utilisateurs et validateurs subiraient inévitablement des pertes à la suite du retour à la chaîne honnête, les transactions dans les blocs validés après l'attaque pourraient potentiellement être annulées, perturbant la couche d'application, et cela remettrait tout simplement en question l'éthique de certains utilisateurs qui ont tendance à croire que « le code est la loi ». Les échanges et les applications auront très probablement établi un lien entre des actions hors chaîne et des transactions en chaîne qui pourraient maintenant être annulées, déclenchant une cascade de rétractations et de révisions qui seraient difficiles à démêler équitablement, surtout si les gains mal acquis ont été mélangés, déposés dans la DeFi ou d'autres dérivés ayant des effets secondaires pour les utilisateurs honnêtes. Certains utilisateurs, peut-être même institutionnels, auraient certainement déjà bénéficié de la chaîne malhonnête, soit par habileté, soit par hasard, et pourraient s'opposer à une fourche pour protéger leurs gains. Il y a eu des appels à répéter la réponse de la communauté face aux attaques à plus de 51 % afin qu'une réaction coordonnée et raisonnable puisse être exécutée rapidement. Vitalik a mené des discussions utiles sur ethresear.ch [ici](https://ethresear.ch/t/timeliness-detectors-and-51-attack-recovery-in-blockchains/6925) et [ici](https://ethresear.ch/t/responding-to-51-attacks-in-casper-ffg/6363) et sur Twitter [ici](https://twitter.com/skylar_eth/status/1551798684727508992?s=20&t=oHZ1xv8QZdOgAXhxZKtHEw). L'objectif d'une réponse sociale coordonnée devrait être de punir très précisément l'attaquant et de minimiser les effets sur les autres utilisateurs.
 
 La gouvernance est déjà un sujet complexe. Gérer une réponse d'urgence de la couche 0 à une chaîne finalisée malhonnête serait sans aucun doute un défi pour la communauté Ethereum, mais [cela s'est produit](/ethereum-forks/#dao-fork-summary) - [deux fois](/ethereum-forks/#tangerine-whistle) - dans l'histoire d'Ethereum).
 
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attestations/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attestations/index.md
index 80891b750b7..4504d06faa5 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attestations/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/attestations/index.md
@@ -8,35 +8,35 @@ Un validateur doit créer, signer et diffuser une attestation à chaque période
 
 ## Qu'est-ce qu'une attestation ? {#what-is-an-attestation}
 
-Chaque [période](/glossary/#epoch) (6,4 minutes) au cours de laquelle un validateur propose une attestation au réseau. L'attestation est destinée à un créneau spécifique dans la période. Le but de l'attestation est de voter en faveur de l'approche du validateur sur la chaîne, en particulier le bloc justifié le plus récent et le premier bloc de la période actuelle (connu sous le nom de points de contrôle `source` et `cible`). Cette information est combinée pour tous les validateurs participants, permettant au réseau de parvenir à un consensus sur l'état de la blockchain.
+À chaque [période](/glossary/#epoch) (6,4 minutes), un validateur propose une attestation au réseau. L'attestation est destinée à un créneau spécifique dans la période. L'objectif de l'attestation est de voter en faveur de la vision qu'a le validateur de la chaîne, en particulier le bloc justifié le plus récent et le premier bloc de la période actuelle (connus sous le nom de points de contrôle `source` et `target`). Cette information est combinée pour tous les validateurs participants, permettant au réseau de parvenir à un consensus sur l'état de la blockchain.
 
 L'attestation contient les composants suivants :
 
-- `aggregation_bits` : une liste de validateurs bits, où la position est mappée à l'index du validateur dans leur comité ; la valeur (0/1) indique si le validateur a signé la `data` (c'est-à-dire - s’ils sont actifs et sont d’accord avec l’auteur du bloc)
+- `aggregation_bits` : une liste de bits de validateurs où la position correspond à l'index du validateur dans son comité ; la valeur (0/1) indique si le validateur a signé les `data` (c'est-à-dire, s'il est actif et d'accord avec le proposeur de bloc).
 - `data` : détails relatifs à l'attestation, tels que définis ci-dessous
 - `signature` : une signature BLS qui regroupe les signatures des validateurs individuels
 
-La première tâche pour un validateur attestant est de construire les `data`. Les `data` contiennent les informations suivantes :
+La première tâche d'un validateur attestant est de construire les `data`. Les `data` contiennent les informations suivantes :
 
 - `slot` : Le numéro de créneau auquel l'attestation fait référence
 - `index` : Un nombre qui identifie à quel comité appartient le validateur dans un créneau donné
-- `beacon_block_root` : Hachage racine du bloc que le validateur voit à la tête de la chaîne (le résultat de l'application de l'algorithme de choix de fourche)
-- `source` : Partie du vote de finalité indiquant ce que les validateurs voient comme le bloc justifié le plus récent
+- `beacon_block_root` : hachage racine du bloc que le validateur voit en tête de chaîne (le résultat de l'application de l'algorithme de choix de fourche)
+- `source` : partie du vote de finalité indiquant ce que les validateurs voient comme le bloc justifié le plus récent
 - `target` : partie du vote de finalité indiquant ce que les validateurs voient comme le premier bloc de la période actuelle
 
-Une fois que les `data` sont construites, le validateur peut retourner le bit en `aggregation_bits` correspondant à leur propre index de validateur de 0 à 1 pour montrer qu'ils ont participé.
+Une fois les `data` construites, le validateur peut faire passer le bit de 0 à 1 dans `aggregation_bits`, correspondant à son propre index de validateur, pour montrer qu'il a participé.
 
 Enfin, le validateur signe l'attestation et la diffuse sur le réseau.
 
 ### Attestation agrégée {#aggregated-attestation}
 
-Les frais additionnels associés au transfert de données pour chaque validateur sur le réseau sont très élevés. Ainsi, les attestations des validateurs individuels sont regroupées au sein de sous-réseaux avant d’être diffusées plus largement. Cela inclut l'agrégation des signatures afin qu'une attestation diffusée comprenne les `data` de consensus et une signature unique formée en combinant les signatures de tous les validateurs qui sont d'accord avec ces `data`. Ceci peut être vérifié en utilisant `aggregation_bits` parce que ce champ fournit l'index de chaque validateur dans leur comité (dont l'ID est fournit dans `data`) qui peut être utilisé pour faire une requête sur les signatures individuelles.
+Les frais additionnels associés au transfert de données pour chaque validateur sur le réseau sont très élevés. Ainsi, les attestations des validateurs individuels sont regroupées au sein de sous-réseaux avant d’être diffusées plus largement. Cela inclut l'agrégation des signatures afin qu'une attestation diffusée comprenne les `data` de consensus et une signature unique formée en combinant les signatures de tous les validateurs qui sont d'accord avec ces `data`. Cela peut être vérifié à l'aide d'`aggregation_bits`, car ce champ fournit l'index de chaque validateur dans son comité (dont l'ID est fourni dans les `data`), qui peut être utilisé pour interroger les signatures individuelles.
 
-À chaque période, 16 validateurs de chaque sous-réseau sont sélectionnés pour être les `agrégateurs`. Les agrégateurs collectent toutes les attestations dont ils entendent parler sur le réseau gossip disposant de `données` équivalentes aux leurs. L'expéditeur de chaque attestation correspondante est enregistré dans les `aggregation_bits`. Les agrégateurs diffusent ensuite l'agrégat d'attestation sur le réseau plus large.
+À chaque période, 16 validateurs de chaque sous-réseau sont sélectionnés pour être les `agrégateurs`. Les agrégateurs collectent toutes les attestations dont ils entendent parler sur le réseau gossip qui ont des `data` équivalentes aux leurs. L'expéditeur de chaque attestation correspondante est enregistré dans les `aggregation_bits`. Les agrégateurs diffusent ensuite l'agrégat d'attestation sur le réseau plus large.
 
 Lorsqu'un validateur est sélectionné pour proposer un bloc, il regroupe les attestations globales des sous-réseaux jusqu'au dernier emplacement du nouveau bloc.
 
-### Cycle de vie de l'inclusion de l'attestation {#attestation-inclusion-lifecycle}
+### Cycle de vie de l'inclusion d'attestation {#attestation-inclusion-lifecycle}
 
 1. Génération
 2. Propagation
@@ -46,7 +46,7 @@ Lorsqu'un validateur est sélectionné pour proposer un bloc, il regroupe les at
 
 Le cycle de vie de l'attestation est décrit dans le schéma ci-dessous :
 
-![cycle de vie des transactions](./attestation_schematic.png)
+![Cycle de vie de l'attestation](./attestation_schematic.png)
 
 ## Récompenses {#rewards}
 
@@ -64,29 +64,29 @@ Le taux d'attestation de l'indicateur est mesuré en utilisant la somme des sold
 
 La récompense de base est calculée en fonction du nombre de validateurs présentant une attestation et de leurs soldes d'éther effectivement misés :
 
-`base reward = validator effective balance x 2^6 / SQRT(Effective balance of all active validators)`
+`récompense de base = solde effectif du validateur x 2^6 / SQRT(solde effectif de tous les validateurs actifs)`
 
 #### Délai d'inclusion {#inclusion-delay}
 
-Au moment où les validateurs votaient pour la tête de chaîne (`block n`), le `block n+1` n'était pas encore proposé. Par conséquent, les attestations naturellement incluses **un bloc plus tard** donc toutes les attestations qui ont voté sur `block n` étant la tête de chaîne ont été incluses dans `block n+1` et, le **délai d'inclusion** est 1. Si le délai d'inclusion double et atteint deux créneaux, la récompense de l'attestation sera réduite de moitié, parce que pour calculer la récompense de l'attestation, la récompense de base est multipliée par la réciproque du délai d'inclusion.
+Au moment où les validateurs ont voté pour la tête de la chaîne (`bloc n`), le `bloc n+1` n'avait pas encore été proposé. Par conséquent, les attestations sont naturellement incluses **un bloc plus tard**. Ainsi, toutes les attestations qui ont voté pour que le `bloc n` soit la tête de la chaîne sont incluses dans le `bloc n+1`, et le **délai d'inclusion** est de 1. Si le délai d'inclusion double et atteint deux créneaux, la récompense de l'attestation sera réduite de moitié, parce que pour calculer la récompense de l'attestation, la récompense de base est multipliée par la réciproque du délai d'inclusion.
 
 ### Scénarios d'attestation {#attestation-scenarios}
 
-#### Validateur de vote manquant {#missing-voting-validator}
+#### Validateur votant manquant {#missing-voting-validator}
 
 Les validateurs ont un maximum de 1 période pour soumettre leur attestation. Si l'attestation a été manquée à la période 0, ils peuvent la soumettre avec un délai d'inclusion à la période 1.
 
 #### Agrégateur manquant {#missing-aggregator}
 
-Il y a 16 agrégateurs par période au total. De plus, les validateurs aléatoires s'abonnent à **deux sous-réseaux pour 256 périodes** et servent de sauvegarde au cas où des agrégateurs seraient manquants.
+Il y a 16 agrégateurs par période au total. De plus, des validateurs aléatoires s'abonnent à **deux sous-réseaux pendant 256 périodes** et servent de sauvegarde au cas où des agrégateurs seraient manquants.
 
-#### Proposant de bloc manquant {#missing-block-proposer}
+#### Proposeur de bloc manquant {#missing-block-proposer}
 
 Notez que, dans certains cas, un agrégateur chanceux peut aussi devenir le proposeur de blocs. Si l'attestation n'a pas été incluse parce que le proposant du bloc a disparu, le proposant du bloc suivant récupérerait l'attestation agrégée et l'inclurait dans le bloc suivant. Cependant, le **délai d'inclusion** augmentera de un.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Attestations dans la spécification du consensus annoté de Vitalik](https://github.com/ethereum/annotated-spec/blob/master/phase0/beacon-chain.md#attestationdata)
+- [Attestations dans la spécification du consensus annotée de Vitalik](https://github.com/ethereum/annotated-spec/blob/master/phase0/beacon-chain.md#attestationdata)
 - [Attestations dans eth2book.info](https://eth2book.info/capella/part3/containers/dependencies/#attestationdata)
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/block-proposal/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
index 02cfb2eedbd..b78054ed69d 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/block-proposal/index.md
@@ -1,6 +1,6 @@
 ---
 title: Proposition de bloc
-description: Comment les blocs sont proposés en preuve d'enjeu sur Ethereum.
+description: "Comment les blocs sont proposés en preuve d'enjeu sur Ethereum."
 lang: fr
 ---
 
@@ -8,7 +8,7 @@ Les blocs sont les unités de base de la blockchain. Ce sont des paquets d'infor
 
 ## Prérequis {#prerequisites}
 
-La proposition de blocs fait partie du protocole de preuve d'enjeu. Pour mieux comprendre cette page, nous vous recommandons de lire celle sur la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/) et [l'architecture des blocs](/developers/docs/blocks/).
+La proposition de blocs fait partie du protocole de preuve d'enjeu. Pour vous aider à comprendre cette page, nous vous recommandons de lire les articles sur la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/) et [l'architecture des blocs](/developers/docs/blocks/).
 
 ## Qui produit les blocs ? {#who-produces-blocks}
 
@@ -16,9 +16,9 @@ Les comptes de validateurs proposent les blocs. Les validateurs sont gérés par
 
 ### Sélection aléatoire {#random-selection}
 
-Un seul validateur est choisi de manière pseudo-aléatoire pour proposer un bloc à chaque créneau. Il n'existe pas de véritable aléa dans une blockchain, car si chaque nœud générait des nombres véritablement aléatoires, ils ne pourraient pas parvenir à atteindre un consensus. Au lieu de cela, l'objectif est de rendre le processus de sélection des validateurs imprévisible. Le pseudo-aléa est réalisé sur Ethereum à l'aide d'un algorithme appelé RANDAO, qui mélange un hachage du validateur qui propose le bloc avec une graine qui est mise à jour à chaque bloc. Cette valeur est utilisée pour sélectionner un validateur spécifique parmi l'ensemble des validateurs. La sélection des validateurs est fixée deux périodes à l'avance afin de se protéger contre certains types de manipulation de la graine utilisée.
+Un seul validateur est choisi de manière pseudo-aléatoire pour proposer un bloc à chaque créneau. Il n'existe pas de véritable aléa dans une blockchain, car si chaque nœud générait des nombres véritablement aléatoires, ils ne pourraient pas parvenir à atteindre un consensus. Au lieu de cela, l'objectif est de rendre le processus de sélection des validateurs imprévisible. Le pseudo-aléa est réalisé sur Ethereum à l'aide d'un algorithme appelé RANDAO, qui mélange un hachage du validateur qui propose le bloc avec une graine qui est mise à jour à chaque bloc. Cette valeur est utilisée pour sélectionner un validateur spécifique parmi l'ensemble total des validateurs. La sélection des validateurs est fixée deux périodes à l'avance afin de se protéger contre certains types de manipulation de la graine utilisée.
 
-Bien que les validateurs ajoutent des données à RANDAO à chaque créneau, la valeur globale de RANDAO est mise à jour une seule fois par période. Pour calculer l'indice du prochain validateur choisi, la valeur de RANDAO est mélangée avec le numéro du créneau pour donner une valeur unique à chaque créneau. La probabilité qu'un validateur individuel soit sélectionné n'est pas simplement de `1/N` (où `N` = total des validateurs actifs). Elle est plutôt pondérée par le solde effectif d'ETH de chaque validateur. Le solde ETH effectif maximal est de 32 ETH (cela signifie que le `solde < 32 ETH` conduit à un poids inférieur par rapport à un `solde == 32 ETH`, mais un `solde > 32 ETH` ne conduit pas à un poids supérieur au `solde == 32 ETH`).
+Bien que les validateurs ajoutent des données à RANDAO à chaque créneau, la valeur globale de RANDAO est mise à jour une seule fois par période. Pour calculer l'indice du prochain validateur choisi, la valeur de RANDAO est mélangée avec le numéro du créneau pour donner une valeur unique à chaque créneau. La probabilité qu'un validateur individuel soit sélectionné n'est pas simplement de `1/N` (où `N` = le nombre total de validateurs actifs). Elle est plutôt pondérée par le solde effectif d'ETH de chaque validateur. Le solde effectif maximal est de 32 ETH (cela signifie qu'un `balance < 32 ETH` conduit à une pondération inférieure à `balance == 32 ETH`, mais `balance > 32 ETH` ne conduit pas à une pondération supérieure à `balance == 32 ETH`).
 
 Un seul validateur est sélectionné à chaque créneau pour proposer un bloc. Dans des conditions normales, un seul producteur de bloc crée et publie un unique bloc dans son créneau dédié. Créer deux blocs pour le même créneau est une infraction passible de sanction, souvent appelée « équivoque ».
 
@@ -42,9 +42,9 @@ class BeaconBlockBody(Container):
     execution_payload: ExecutionPayload
 ```
 
-Le champ `randao_reveal` prend une valeur aléatoire vérifiable que le validateur de bloc crée en signant le numéro de la période actuelle. `eth1_data` est un vote du point de vue du proposeur du bloc sur l'état du contrat de dépôt, incluant la racine de l'arbre Merkle des dépôts et le nombre total de dépôts, permettant ainsi de vérifier de nouveaux dépôts. `graffiti` est un champ facultatif qui peut être utilisé pour ajouter un message au bloc. `proposer_slashings` et `attester_slashings` sont des champs qui contiennent la preuve que certains validateurs ont commis des infractions pouvant être sanctionnées selon la vue du proposeur sur l'état de la chaîne. `deposits` est une liste de nouveaux dépôts de validateurs dont le proposeur de ce bloc a connaissance, et `voluntary_exits` est une liste de validateurs souhaitant quitter le réseau, dont le proposeur de bloc a reçu le message via le réseau de diffusion de la couche de consensus. Le `sync_aggregate` est un vecteur montrant quels validateurs ont été précédemment affectés à un comité de synchronisation (un sous-ensemble de validateurs servant à fournir des données aux clients légers) et ont participé à la signature de données.
+Le champ `randao_reveal` prend une valeur aléatoire vérifiable que le proposeur de bloc crée en signant le numéro de l'époque actuelle. `eth1_data` est un vote du point de vue du proposeur du bloc sur le contrat de dépôt, incluant la racine de l'arbre de Merkle des dépôts et le nombre total de dépôts, permettant ainsi de vérifier les nouveaux dépôts. `graffiti` est un champ facultatif qui peut être utilisé pour ajouter un message au bloc. `proposer_slashings` et `attester_slashings` sont des champs qui contiennent la preuve que certains validateurs ont commis des infractions passibles de slashing selon la vue du proposeur sur l'état de la chaîne. `deposits` est une liste de nouveaux dépôts de validateurs dont le proposeur de bloc a connaissance, et `voluntary_exits` est une liste de validateurs souhaitant quitter le réseau, dont le proposeur de bloc a entendu parler sur le réseau de diffusion (gossip network) de la couche de consensus. `sync_aggregate` est un vecteur montrant quels validateurs ont été précédemment affectés à un comité de synchronisation (un sous-ensemble de validateurs servant des données aux clients légers) et ont participé à la signature de données.
 
-L'`exécution_payload` permet aux informations des transactions d'être transmises entre les clients d'exécution et de consensus. L'`execution_payload` est un bloc de données d'exécution qui est imbriqué à l'intérieur d'un bloc phare. Les champs à l'intérieur de l'`execution_payload` reflètent la structure du bloc telle qu'indiquée dans le Livre jaune d'Ethereum, à l'exception qu'il n'y a pas de blocs oncles et que `prev_randao` remplace `difficulty`. Le client d'exécution a accès à un pool local de transactions qu'il a reçues sur son propre réseau de diffusion d'informations. Ces transactions sont exécutées localement pour générer un état mis à jour connu sous le nom d'état final. Les transactions sont incluses dans l'`execution_payload` en tant que liste appelée `transactions` et l'état final est inscrit dans le champ `state-root`.
+La `execution_payload` permet aux informations des transactions d'être transmises entre les clients d'exécution et les clients de consensus. La `execution_payload` est un bloc de données d'exécution qui est imbriqué à l'intérieur d'un bloc balise. Les champs à l'intérieur de la `execution_payload` reflètent la structure de bloc décrite dans le livre jaune d'Ethereum, à l'exception qu'il n'y a pas d'ommers (blocs oncles) et que `prev_randao` existe à la place de `difficulty`. Le client d'exécution a accès à un pool local de transactions qu'il a reçues sur son propre réseau de diffusion d'informations. Ces transactions sont exécutées localement pour générer un état mis à jour connu sous le nom d'état final. Les transactions sont incluses dans la `execution_payload` sous forme de liste appelée `transactions` et l'état final est fourni dans le champ `state-root`.
 
 Toutes ces données sont collectées dans un bloc phare, signées, puis diffusées aux pairs du proposeur de bloc, qui les propagent à leurs propres pairs, et ainsi de suite.
 
@@ -52,18 +52,18 @@ En savoir plus sur [l'anatomie des blocs](/developers/docs/blocks).
 
 ## Qu'arrive-t-il au block ? {#what-happens-to-blocks}
 
-Le bloc est ajouté à la base de données locale du proposeur de bloc puis diffusé aux pairs via le réseau de communication de la couche de consensus. Lorsqu'un validateur reçoit le bloc, il vérifie les données qu'il contient, notamment en vérifiant que le bloc a le bon bloc parent, correspond au créneau actuel, que l'index du proposeur est bien celui attendu, que RANDAO est valide et enfin que le proposeur n'a pas été sanctionné. L'`exécution_payload` est décompressé, et le client d'exécution du validateur exécute à nouveau toutes les transactions de la liste pour vérifier le changement d'état proposé. Si le bloc passe toutes ces vérifications, chaque validateur ajoute le bloc à sa propre chaîne canonique. Le processus recommence ensuite lors du créneau suivant.
+Le bloc est ajouté à la base de données locale du proposeur de bloc puis diffusé aux pairs via le réseau de communication de la couche de consensus. Lorsqu'un validateur reçoit le bloc, il vérifie les données qu'il contient, notamment en vérifiant que le bloc a le bon bloc parent, correspond au créneau actuel, que l'index du proposeur est bien celui attendu, que RANDAO est valide et enfin que le proposeur n'a pas été sanctionné. La `execution_payload` est dégroupée et le client d'exécution du validateur ré-exécute les transactions de la liste pour vérifier le changement d'état proposé. Si le bloc passe toutes ces vérifications, chaque validateur ajoute le bloc à sa propre chaîne canonique. Le processus recommence ensuite lors du créneau suivant.
 
-## Récompenses du bloc {#block-rewards}
+## Récompenses de bloc {#block-rewards}
 
-Le proposeur de bloc reçoit une rémunération pour son travail. Il y a `base_reward`, une récompense de base calculée en fonction du nombre de validateurs actifs et de leurs soldes effectifs. Ensuite, le validateur reçoit une fraction de la récompense de base (`base_reward`) pour chaque attestation valide incluse dans le bloc ; plus il y a de validateurs qui attestent le bloc, plus grande est la récompense pour le proposeur de bloc. Il y a également une récompense pour les validateurs signalant des infractions passibles de sanction, égale à `1/512 * effective balance` pour chaque validateur sanctionné.
+Le proposeur de bloc reçoit une rémunération pour son travail. Il existe une `base_reward` (récompense de base) calculée en fonction du nombre de validateurs actifs et de leurs soldes effectifs. Le proposeur de bloc reçoit alors une fraction de la `base_reward` pour chaque attestation valide incluse dans le bloc ; plus il y a de validateurs qui attestent du bloc, plus la récompense du proposeur de bloc est importante. Il existe également une récompense pour le signalement des validateurs qui devraient être slashés, égale à `1/512 * effective balance` pour chaque validateur slashé.
 
-[Plus d'informations sur les récompenses et sanctions](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties)
+[En savoir plus sur les récompenses et les pénalités](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [Introduction aux blocs](/developers/docs/blocks/)
-- [Introduction à la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
-- [Spécifications de consensus Ethereum](https://github.com/ethereum/consensus-specs)
-- [Introduction à Gasper](/developers/docs/consensus-mechanisms/pos/)
-- [Mise à jour d'Ethereum](https://eth2book.info/)
+- Introduction à la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
+- [Spécifications du consensus Ethereum](https://github.com/ethereum/consensus-specs)
+- [Introduction à Gasper](/developers/docs/consensus-mechanisms/pos/gasper/)
+- [Mise à niveau d'Ethereum](https://eth2book.info/)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/faqs/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/faqs/index.md
index 764d530a6ea..8e1d0053b8d 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/faqs/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/faqs/index.md
@@ -1,14 +1,14 @@
 ---
 title: Foire aux questions
-description: Foire aux questions à propos de la preuve d'enjeu Ethereum.
+description: "Foire aux questions à propos de la preuve d'enjeu Ethereum."
 lang: fr
 ---
 
-## Qu'est-ce que la preuve d'enjeu ? {#what-is-proof-of-stake}
+## Qu'est-ce que la preuve d'enjeu {#what-is-proof-of-stake}
 
 La preuve d'enjeu est une classe d'algorithme qui assure la sécurité des blockchains en garantissant que les actifs de valeur sont perdus par les attaquants qui agissent de manière malhonnête. Les systèmes de preuve d'enjeu nécessitent qu'un ensemble de validateurs mette à disposition un actif qui peut être détruit si le validateur se livre à un comportement manifestement malhonnête. Ethereum utilise un mécanisme de preuve d'enjeu pour sécuriser sa blockchain.
 
-## Comment la preuve d'enjeu se compare-t-elle à la preuve de travail ? {#comparison-to-proof-of-work}
+## Comment la preuve d'enjeu se compare-t-elle à la preuve de travail ? Comparaison avec la preuve de travail {#comparison-to-proof-of-work}
 
 La preuve de travail et la preuve d'enjeu sont toutes deux des mécanismes qui dissuadent économiquement les acteurs malveillants de ralentir ou de frauder le réseau. Dans les deux cas, les nœuds qui participent activement au consensus mettent un actif « dans le réseau » qu'ils perdront s'ils se comportent mal.
 
@@ -18,7 +18,7 @@ La preuve d'enjeu nécessite que les nœuds, appelés validateurs, soumettent ex
 
 La preuve de travail est beaucoup plus gourmande en énergie car de l'électricité est consommée lors du processus de minage. La preuve d'enjeu, en revanche, ne nécessite qu'une très faible quantité d'énergie - les validateurs Ethereum peuvent même fonctionner sur un appareil à faible puissance tel qu'un Raspberry Pi. Le mécanisme de preuve d'enjeu d'Ethereum est considéré comme plus sûr que la preuve de travail car le coût d'une attaque est plus élevé et les conséquences pour un attaquant sont plus graves.
 
-La comparaison entre la preuve de travail et la preuve d'enjeu est un sujet controversé. Le blog de [Vitalik Buterin](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-are-the-benefits-of-proof-of-stake-as-opposed-to-proof-of-work) et le débat entre Justin Drake et Lyn Alden offrent un bon résumé des arguments.
+La comparaison entre la preuve de travail et la preuve d'enjeu est un sujet controversé. Le [blog de Vitalik Buterin](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-are-the-benefits-of-proof-of-stake-as-opposed-to-proof-of-work) et le débat entre Justin Drake et Lyn Alden donnent un bon résumé des arguments.
 
 <YouTube id="1m12zgJ42dI" />
 
@@ -26,27 +26,27 @@ La comparaison entre la preuve de travail et la preuve d'enjeu est un sujet cont
 
 Oui. Les nœuds sur un réseau en preuve d'enjeu utilisent une quantité infime d'énergie. Une étude tierce a conclu que l'ensemble du réseau Ethereum basé sur la preuve d'enjeu consomme environ 0,0026 TWh/an - soit environ 13 000 fois moins que les jeux vidéo aux États-Unis uniquement.
 
-[Plus d'infos sur la consommation d'énergie d'Ethereum](/energy-consumption/).
+[En savoir plus sur la consommation d'énergie d'Ethereum](/energy-consumption/).
 
 ## La preuve d'enjeu est-elle sécurisée ? {#is-pos-secure}
 
 La preuve d'enjeu d'Ethereum est très sécurisée. Le mécanisme a été recherché, développé et testé rigoureusement pendant huit ans avant d'être mis en service. Les garanties de sécurité sont différentes des blockchains basées sur la preuve de travail. Dans la preuve d'enjeu, les validateurs malveillants peuvent être activement sanctionnés (« évincés ») et expulsés de l'ensemble des validateurs, ce qui coûte une somme importante d'ETH. Sous le régime de la preuve de travail, un attaquant peut continuer à répéter son attaque tant qu'il dispose d'une puissance de hachage suffisante. Il est également plus coûteux de lancer des attaques équivalentes sur Ethereum en preuve d'enjeu qu'en preuve de travail. Pour affecter la validation de la chaîne, au moins 33 % de l'ether total misé sur le réseau sont nécessaires (sauf dans les cas d'attaques très sophistiquées avec une probabilité de succès extrêmement faible). Pour contrôler le contenu des blocs futurs, au moins 51 % de l'ETH total misé est nécessaire, et pour réécrire l'histoire, plus de 66 % de la mise totale est nécessaire. Le protocole Ethereum détruirait ces actifs dans les scénarios d'attaque de 33 % ou 51 % et par consensus social dans le scénario d'attaque de 66 %.
 
-- [Plus d'informations sur la défense contre les attaquants d'Ethereum en preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/attack-and-defense)
+- [En savoir plus sur la défense de la preuve d'enjeu d'Ethereum contre les attaquants](/developers/docs/consensus-mechanisms/pos/attack-and-defense)
 - [En savoir plus sur la conception de la preuve d'enjeu](https://medium.com/@VitalikButerin/a-proof-of-stake-design-philosophy-506585978d51)
 
 ## Est-ce que la preuve d'enjeu rend Ethereum moins cher à utiliser ? {#does-pos-make-ethereum-cheaper}
 
 Non. Le coût d'envoi d'une transaction (frais de gaz) est déterminé par un marché dynamique des frais qui augmente avec la demande sur le réseau. Le mécanisme de consensus n'influence pas directement cela.
 
-[Plus d'information sur le gaz](/developers/docs/gas).
+[En savoir plus sur le gaz](/developers/docs/gas).
 
 ## Que sont les nœuds, les clients et les validateurs ? {#what-are-nodes-clients-and-validators}
 
 Les nœuds sont des ordinateurs connectés au réseau Ethereum. Les clients sont les logiciels qu'ils exécutent et qui transforment l'ordinateur en un nœud. Il existe deux types de clients : les clients d'exécution et les clients de consensus. Les deux sont nécessaires pour créer un nœud. Un validateur est un complément optionnel à un client de consensus qui permet au nœud de participer à un consensus à preuve d'enjeu. Cela signifie créer et proposer des blocs lorsqu'ils sont sélectionnés et attester des blocs dont ils entendent parler sur le réseau. Pour faire fonctionner un validateur, l'opérateur du nœud doit déposer 32 ETH dans le contrat de dépôt.
 
 - [En savoir plus sur les nœuds et les clients](/developers/docs/nodes-and-clients)
-- [Plus d'infos sur la mise en jeu](/staking)
+- [En savoir plus sur la mise en jeu](/staking)
 
 ## Est-ce que la preuve d'enjeu est une nouvelle idée ? {#is-pos-new}
 
@@ -66,7 +66,7 @@ La combinaison de Casper et LMD_GHOST est connue sous le nom de Gasper.
 
 La « pénalisation » est le terme donné à la destruction d'une partie de la mise d'un validateur et à l'expulsion du validateur du réseau. La quantité d'ETH perdue lors d'une sanction augmente proportionnellement avec le nombre de validateurs sanctionnés - cela signifie que les validateurs regroupés sont punis plus sévèrement que les individus.
 
-[En savoir plus sur les sanctions](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties#slashing)
+[En savoir plus sur le délestage](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties#slashing)
 
 ## Pourquoi les validateurs ont-ils besoin de 32 ETH ? {#why-32-eth}
 
@@ -82,26 +82,26 @@ Un seul validateur est choisi de manière pseudo-aléatoire pour proposer un blo
 
 La « manipulation d'enjeu » est une catégorie d'attaque sur les réseaux de preuve d'enjeu où l'attaquant tente de biaiser l'algorithme de sélection des validateurs en faveur de ses propres validateurs. Les attaques de « manipulation » sur RANDAO nécessitent environ la moitié du total d'ETH mis en jeu.
 
-[En savoir plus sur la manipulation de la mise en jeu](https://eth2book.info/altair/part2/building_blocks/randomness/#randao-biasability)
+[En savoir plus sur le stake grinding](https://eth2book.info/altair/part2/building_blocks/randomness/#randao-biasability)
 
 ## Qu'est-ce qu'une sanction communautaire ? {#what-is-social-slashing}
 
 Le « sanction communautaire » est la capacité de la communauté à coordonner une fourche de la blockchain en réponse à une attaque. Elle permet à la communauté de se remettre d'une attaque ayant finalisé une chaîne malhonnête. La répression sociale peut également être utilisée contre les attaques de censure.
 
-- [En savoir plus sur la sanction communautaire](https://ercwl.medium.com/the-case-for-social-slashing-59277ff4d9c7)
-- [Vitalik Buterin à propos des sanctions communautaires](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-is-proof-of-stake)
+- [En savoir plus sur le délestage social](https://ercwl.medium.com/the-case-for-social-slashing-59277ff4d9c7)
+- [Vitalik Buterin sur le délestage social](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-is-proof-of-stake)
 
 ## Vais-je être sanctionné ? {#will-i-get-slashed}
 
 En tant que validateur, il est très difficile d'être sanctionné à moins de vous engager délibérément dans un comportement malveillant. La sanction n'est mise en œuvre que dans des scénarios très spécifiques où les validateurs proposent plusieurs blocs pour le même créneau ou se contredisent avec leurs attestations - ces situations sont très peu susceptibles de survenir accidentellement.
 
-[En savoir plus sur les conditions entrainant une sanction](https://eth2book.info/altair/part2/incentives/slashing)
+[En savoir plus sur les conditions de délestage](https://eth2book.info/altair/part2/incentives/slashing)
 
 ## Qu'est-ce que le problème dit de l'absence d'enjeu ? {#what-is-nothing-at-stake-problem}
 
 Le problème de l'absence d'enjeu est un problème conceptuel avec certains mécanismes de preuve d'enjeu où il n'y a que des récompenses et aucune pénalité. Si rien n'est en jeu, un validateur pragmatique est tout aussi heureux d'attester de n'importe quelle fourche, voire de plusieurs fourches, de la blockchain, car cela augmente ses récompenses. Ethereum contourne ce problème en utilisant des conditions de finalité et des sanctions pour garantir une chaîne canonique unique.
 
-[En savoir plus le problème dit de l'absence d'enjeu](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed)
+[En savoir plus sur le problème du rien en jeu](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed)
 
 ## Qu'est-ce que l'algorithme de choix de fourche ? {#what-is-a-fork-choice-algorithm}
 
@@ -121,13 +121,13 @@ La finalité dans la preuve d'enjeu est la garantie qu'un bloc donné fait parti
 
 La subjectivité faible ou weak subjectivity est une caractéristique des réseaux de preuve d'enjeu où l'information sociale est utilisée pour confirmer l'état actuel de la blockchain. Les nouveaux nœuds ou les nœuds rejoignant le réseau après avoir été hors ligne pendant une longue période peuvent recevoir un état récent afin que le nœud puisse voir immédiatement s'ils sont sur la bonne chaîne. Ces états sont connus sous le nom de « points de contrôle de la faible subjectivité » et peuvent être obtenus auprès d'autres opérateurs de nœuds éloignés, ou auprès d'explorateurs de blocs, ou de plusieurs points de terminaison publics.
 
-[En savoir plus sur la « faible subjectivité »](/developers/docs/consensus-mechanisms/pos/weak-subjectivity)
+[En savoir plus sur la subjectivité faible](/developers/docs/consensus-mechanisms/pos/weak-subjectivity)
 
 ## Est-ce que la preuve d'enjeu peut résister à la censure ? {#is-pos-censorship-resistant}
 
 La résistance à la censure est actuellement difficile à prouver. Cependant, contrairement à la preuve de travail, la preuve d'enjeu offre la possibilité de coordonner les sanctions pour punir les validateurs pratiquant la censure. Il y a des changements à venir dans le protocole qui séparent les constructeurs de blocs des proposeurs de blocs et mettent en œuvre des listes de transactions que les constructeurs doivent inclure dans chaque bloc. Cette proposition est connue sous le nom de séparation des constructeurs et des proposeurs appropriés et aide à empêcher les validateurs de censurer les transactions.
 
-[En savoir plus sur la séparation des rôles de constructeur et de proposeur](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Original-basic-scheme)
+[En savoir plus sur la séparation proposant-constructeur](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Original-basic-scheme)
 
 ## Est-ce qu'Ethereum en système de preuve d'enjeu peut subir une attaque 51% ? {#pos-51-attack}
 
@@ -139,7 +139,7 @@ Oui. La preuve d'enjeu est vulnérable aux attaques à 51%, tout comme la preuve
 
 La coordination sociale est la dernière ligne de défense pour Ethereum qui permettrait de récupérer une chaîne honnête à la suite d'une attaque ayant finalisé des blocs malhonnêtes. Dans ce cas, la communauté Ethereum devrait se coordonner « hors chaine » et s'accorder pour utiliser une fourche minoritaire honnête, tout en sanctionnant les validateurs de l'attaquant dans le processus. Cela nécessiterait également que les applications et les plateformes d'échange reconnaissent la fourche honnête.
 
-[En savoir plus sur la coordination communautaire](/developers/docs/consensus-mechanisms/pos/attack-and-defense#people-the-last-line-of-defense)
+[En savoir plus sur la coordination sociale](/developers/docs/consensus-mechanisms/pos/attack-and-defense#people-the-last-line-of-defense)
 
 ## Est-ce que les riches deviennent plus riches grâce à la preuve d'enjeu ? {#do-rich-get-richer}
 
@@ -147,9 +147,9 @@ Plus une personne doit miser d’ETH, plus elle peut exécuter de validateurs et
 
 ## Est-ce que la preuve d'enjeu est plus centralisée que la preuve de travail ? {#is-pos-decentralized}
 
-Non, la preuve de travail tend vers la centralisation car les coûts d'exploitation minière augmentent et évincent les individus, puis évincent les petites entreprises, et ainsi de suite. Le problème actuel avec la preuve d'enjeu est l'influence des produits dérivés de mise en jeu (DSL). Ce sont des jetons représentant de l'ETH mis en jeu par un fournisseur que n'importe qui peut échanger sur les marchés secondaires sans que l'ETH réel ne soit retiré de la mise. Les LSD permettent aux utilisateurs de mettre en jeu moins de 32 ETH, mais ils créent également un risque de centralisation où quelques grandes organisations peuvent finir par contrôler une grande partie de la mise. C'est pourquoi [mettre en jeu ses propres Eth](/staking/solo) est le mieux pour le réseau.
+Non, la preuve de travail tend vers la centralisation car les coûts d'exploitation minière augmentent et évincent les individus, puis évincent les petites entreprises, et ainsi de suite. Le problème actuel avec la preuve d'enjeu est l'influence des produits dérivés de mise en jeu (DSL). Ce sont des jetons représentant de l'ETH mis en jeu par un fournisseur que n'importe qui peut échanger sur les marchés secondaires sans que l'ETH réel ne soit retiré de la mise. Les LSD permettent aux utilisateurs de mettre en jeu moins de 32 ETH, mais ils créent également un risque de centralisation où quelques grandes organisations peuvent finir par contrôler une grande partie de la mise. C'est pourquoi la [mise en jeu en solo](/staking/solo) est la meilleure option pour Ethereum.
 
-[En savoir plus sur la centralisation des LSD](https://notes.ethereum.org/@djrtwo/risks-of-lsd)
+[En savoir plus sur la centralisation de la mise en jeu dans les LSD](https://notes.ethereum.org/@djrtwo/risks-of-lsd)
 
 ## Pourquoi je ne peux mettre en jeu que des ETH ? {#why-can-i-only-stake-eth}
 
@@ -163,10 +163,10 @@ Non, il existe plusieurs blockchains basées sur la preuve d'enjeu. Aucun n'est
 
 La fusion a été le moment où Ethereum a désactivé son mécanisme de consensus basé sur la preuve de travail et a activé son mécanisme de consensus basé sur la preuve d'enjeu. La Fusion a eu lieu le 15 septembre 2022.
 
-[Plus d'infos sur la fusion](/roadmap/merge)
+[En savoir plus sur La Fusion](/roadmap/merge)
 
 ## Qu'est-ce que la disponibilité et la sécurité ? {#what-are-liveness-and-safety}
 
-La disponibilité et la sécurité sont les deux préoccupations fondamentales en matière de sécurité pour une blockchain. La disponibilité est l'accessibilité à une chaîne finalisée. Si la chaîne cesse de se finaliser ou si les utilisateurs ne peuvent pas y accéder facilement, ce sont des échecs de disponibilité. Un coût d'accès extrêmement élevé pourrait également être considéré comme un échec de disponibilité. La sécurité fait référence à la difficulté d'attaquer la chaîne - c'est-à-dire de finaliser des points de contrôle conflictuels.
+La disponibilité et la sécurité sont les deux préoccupations fondamentales en matière de sécurité pour une blockchain. La disponibilité est l'accessibilité à une chaîne finalisée. Si la chaîne cesse de se finaliser ou si les utilisateurs ne peuvent pas y accéder facilement, ce sont des échecs de disponibilité. Un coût d'accès extrêmement élevé pourrait également être considéré comme un échec de disponibilité. La sécurité fait référence à la difficulté d'attaquer la chaîne, c'est-à-dire de finaliser des points de contrôle conflictuels.
 
-[En savoir plus sur Casper](https://arxiv.org/pdf/1710.09437.pdf)
+[En savoir plus dans l'article Casper](https://arxiv.org/pdf/1710.09437.pdf)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/gasper/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/gasper/index.md
index b145eabab45..17d4d744bf1 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/gasper/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/gasper/index.md
@@ -1,16 +1,16 @@
 ---
 title: Gasper
-description: Explication du mécanisme de preuve d'enjeu Gasper.
+description: "Explication du mécanisme de preuve d'enjeu Gasper."
 lang: fr
 ---
 
 Gasper est une combinaison de Casper the Friendly Finality Gadget (Casper-FFG) et de l'algorithme de choix de fourche LMD-GHOST. Ensemble, ces composants forment le mécanisme de consensus qui garantit la preuve d'enjeu d'Ethereum. Casper est le mécanisme qui met à niveau certains blocs vers le statut « finalized » afin que les nouveaux entrants sur le réseau puissent être sûrs qu'ils se synchronisent à la chaîne canonique. L'algorithme de choix de fourche utilise des votes cumulés pour s'assurer que les nœuds peuvent facilement sélectionner le bon lorsque des fourches apparaissent dans la blockchain.
 
-**Remarquez** que la définition originale de Casper-FFG a été légèrement mise à jour pour l'inclusion dans Gasper. Sur cette page, nous considérerons la version mise à jour.
+**Remarque :** la définition originale de Casper-FFG a été légèrement mise à jour pour son inclusion dans Gasper. Sur cette page, nous considérerons la version mise à jour.
 
-## Prérequis
+## Les prérequis
 
-Pour comprendre ce mécanisme, il est nécessaire de lire la page d'introduction sur la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/).
+Pour comprendre ce sujet, il est nécessaire de lire la page d'introduction sur la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/).
 
 ## Le rôle de Gasper {#role-of-gasper}
 
@@ -23,7 +23,7 @@ La finalité est une propriété de certains blocs qui signifie qu'ils ne peuven
 1. Deux tiers du total des éthers mis en jeu doivent avoir voté en faveur de l'inclusion de ce bloc dans la chaîne canonique. Cette condition fait passer le bloc à « justifié ». Les blocs justifiés ont peu de chances d'être annulés, mais ils peuvent l'être sous certaines conditions.
 2. Lorsqu'un autre bloc est justifié au-dessus d'un bloc justifié, il passe à « finalisé ». La finalisation d'un bloc est un engagement à inclure le bloc dans la chaîne canonique. Il ne peut pas être inversé à moins qu'un attaquant ne détruise des millions d'éther (des milliards de $USD).
 
-Ces améliorations de blocs ne se produisent pas dans tous les emplacements. Au lieu de cela, seuls les blocs à la limite de la période peuvent être justifiés et finalisés. Ces blocs sont appelés « points de contrôle ». La mise à niveau considère des paires de points de contrôle. Un « lien de supermajorité » doit exister entre deux points de contrôle successifs (c'est-à-dire que deux tiers du total de l'éther misé votent que le point de contrôle B est le descendant correct du point de contrôle A) pour faire passer le point de contrôle le moins récent à finalisé et le bloc le plus récent à justifié.
+Ces améliorations de blocs ne se produisent pas dans tous les emplacements. Au lieu de cela, seuls les blocs à la limite de la période peuvent être justifiés et finalisés. Ces blocs sont appelés « points de contrôle ». La mise à niveau considère des paires de points de contrôle. Un « lien de supermajorité » doit exister entre deux points de contrôle successifs (c.-à-d. que deux tiers du total de l'ether misé votent que le point de contrôle B est le descendant correct du point de contrôle A) pour faire passer le point de contrôle le moins récent à l'état finalisé et le bloc le plus récent à l'état justifié.
 
 Étant donné que la finalité exige un accord des deux tiers sur le caractère canonique d'un bloc, un attaquant ne peut pas créer une autre chaîne finalisée sans ce qui suit :
 
@@ -32,21 +32,21 @@ Ces améliorations de blocs ne se produisent pas dans tous les emplacements. Au
 
 La première condition découle du fait que les deux tiers de l'éther mis en jeu sont nécessaires pour finaliser une chaîne. La deuxième condition se pose car si deux tiers de la participation totale ont voté en faveur des deux bifurcations, alors un tiers doit avoir voté sur les deux. Le double vote est une condition sournoise qui serait punie au maximum, et un tiers de l'enjeu total serait détruit. En mai 2022, un attaquant devait ainsi brûler environ 10 milliards de dollars d'éther. L'algorithme qui justifie et finalise les blocs dans Gasper est une forme légèrement modifiée de [Casper the Friendly Finality Gadget (Casper-FFG)](https://arxiv.org/pdf/1710.09437.pdf).
 
-### Incitations et Pénalités {#incentives-and-slashing}
+### Incitatifs et délestage {#incentives-and-slashing}
 
 Les validateurs sont récompensés pour avoir proposé et validé honnêtement des blocs. L'éther est récompensé et ajouté à leur mise en jeu. Par contre, les validateurs qui sont absents et qui n'agissent pas lorsqu'ils sont appelés à manquer ces récompenses et perdent parfois une petite partie de leur participation existante. Cependant, les pénalités pour être hors ligne sont modestes et, dans la plupart des cas, s'élèvent au coût d'opportunité des récompenses manquantes. Cependant, certaines actions de validateur sont très difficiles à faire accidentellement et signifient une intention malveillante, comme proposer plusieurs blocs pour le même emplacement, attester plusieurs blocs pour le même emplacement, ou contredire les votes précédents de point de contrôle. Il s'agit de comportements « slashables » qui sont pénalisés de manière plus sévère : le slashing entraîne la destruction d'une partie de l'enjeu du validateur et le validateur est retiré du réseau des validateurs. Ce processus prend 36 jours. Le premier jour, la pénalité initiale peut atteindre 1 ETH. Puis l'éther coupé du validateur s'égoutte lentement sur la période de sortie, mais le jour 18, ils reçoivent une « pénalité de corrélation », qui est plus grande quand plus de validateurs sont coupés à la même heure. La pénalité maximale est l'enjeu entier. Ces récompenses et ces pénalités sont conçues pour encourager les validateurs honnêtes et décourager les attaques sur le réseau.
 
-### Fuite d’inactivité {#inactivity-leak}
+### Fuite d'inactivité {#inactivity-leak}
 
 En plus de la sécurité, Gasper offre également une « preuve de vie plausible ». C'est la condition que tant que les deux tiers de l'éther total misé votent honnêtement et suivent le protocole, la chaîne sera en mesure de finaliser indépendamment de toute autre activité (comme les attaques, les problèmes de latence ou les slashings). Autrement dit, un tiers du total de l'éther misé doit être compromis d'une manière ou d'une autre pour empêcher la finalisation de la chaîne. En Gasper, il y a une ligne de défense supplémentaire contre une défaillance de la vie, connue sous le nom de « fuite d'inactivité ». Ce mécanisme s'active lorsque la chaîne n'a pas pu être finalisée pour plus de quatre périodes. Les validateurs qui ne témoignent pas activement de la chaîne majoritaire se voient égoutter progressivement leur participation jusqu'à ce que la majorité récupère les deux tiers de l'enjeu total, veiller à ce que les échecs de la vivacité ne soient que temporaires.
 
-### Choix de fourche {#fork-choice}
+### Choix de la fourche {#fork-choice}
 
-La définition originale de Casper-FFG incluait un algorithme de choix de fourche qui imposait la règle : `follow the chain containing the justified checkpoint that pas the gréâtes height` où la hauteur est définie comme la plus grande distance par rapport au bloc de genèse. En Gasper, la règle de choix de fourche originale est dépréciée en faveur d'un algorithme plus sophistiqué appelé LMD-GHOST. Il est important de réaliser que dans des conditions normales, une règle de choix de fourche (fork) est inutile - il y a un seul proposeur de bloc pour chaque créneau, et les validateurs honnêtes l'attestent. Ce n'est que dans les cas d'asynchronie du réseau ou quand un auteur de bloc malhonnête a mis en doute la nécessité d'un algorithme de choix de fourche. Cependant, lorsque ces cas se produisent, l'algorithme de choix de fourche est une défense critique qui sécurise la chaîne correcte.
+La définition originale de Casper-FFG comprenait un algorithme de choix de fourche qui imposait la règle suivante : `suivre la chaîne contenant le point de contrôle justifié qui a la plus grande hauteur`, où la hauteur est définie comme la plus grande distance par rapport au bloc de genèse. En Gasper, la règle de choix de fourche originale est dépréciée en faveur d'un algorithme plus sophistiqué appelé LMD-GHOST. Il est important de réaliser que dans des conditions normales, une règle de choix de fourche (fork) est inutile - il y a un seul proposeur de bloc pour chaque créneau, et les validateurs honnêtes l'attestent. Ce n'est que dans les cas d'asynchronie du réseau ou quand un auteur de bloc malhonnête a mis en doute la nécessité d'un algorithme de choix de fourche. Cependant, lorsque ces cas se produisent, l'algorithme de choix de fourche est une défense critique qui sécurise la chaîne correcte.
 
 LMD-GHOST signifie « le dernier sous-arbre observé le plus gourmand, alimenté par des messages de messages ». C'est une façon lourde de jargon de définir un algorithme qui sélectionne la bifurcation avec le plus grand poids accumulé d'attestations comme le canonique (sous-arbre le plus gourmand) et que si plusieurs messages sont reçus d'un validateur, seule la dernière est prise en compte (dernière génération de messages). Avant d'ajouter le bloc le plus lourd à sa chaîne canonique, chaque validateur évalue chaque bloc à l'aide de cette règle.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Gasper : Combiner GHOST et Casper](https://arxiv.org/pdf/2003.03052.pdf)
-- [Casper the Friendly Finality Gadget (Casper-FFG)](https://arxiv.org/pdf/1710.09437.pdf)
+- [Gasper: Combining GHOST and Casper](https://arxiv.org/pdf/2003.03052.pdf)
+- [Casper the Friendly Finality Gadget](https://arxiv.org/pdf/1710.09437.pdf)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/index.md
index ae174b24267..8bd85058b6b 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/index.md
@@ -1,14 +1,14 @@
 ---
 title: Preuve d'enjeu (PoS)
-description: Explication du protocole de consensus « Preuve d'enjeu » et de son rôle dans Ethereum.
+description: "Explication du protocole de consensus « Preuve d'enjeu » et de son rôle dans Ethereum."
 lang: fr
 ---
 
-La preuve d'enjeu (PoS) sous-tend le [mécanisme de consensus](/developers/docs/consensus-mechanisms/) Ethereum. Ethereum est passé au mécanisme de preuve d'enjeu en 2022 parce que celui-ci est plus sécurisé, moins énergivore, et parfait pour l'implémentation de nouvelles solutions de mise à l'échelle par rapport à la précédente architecture de [preuve de travail](/developers/docs/consensus-mechanisms/pow).
+La preuve d'enjeu (PoS) est à la base du [mécanisme de consensus](/developers/docs/consensus-mechanisms/) d'Ethereum. Ethereum est passé à son mécanisme de preuve d'enjeu en 2022, car il est plus sécurisé, moins énergivore et mieux adapté à la mise en œuvre de nouvelles solutions de mise à l'échelle par rapport à l'architecture précédente de [preuve de travail](/developers/docs/consensus-mechanisms/pow).
 
 ## Prérequis {#prerequisites}
 
-Pour mieux comprendre cette page, nous vous recommandons d'abord de lire la page [Mécanismes de consensus](/developers/docs/consensus-mechanisms/).
+Pour mieux comprendre cette page, nous vous recommandons de vous informer d'abord sur les [mécanismes de consensus](/developers/docs/consensus-mechanisms/).
 
 ## Qu'est-ce que la preuve d'enjeu (PoS) ? {#what-is-pos}
 
@@ -20,38 +20,38 @@ Pour participer en tant que validateur, un utilisateur doit déposer 32 ETH dans
 
 Alors qu'avec le consensus de preuve de travail, la fréquence des blocs est déterminée par la difficulté minière, avec la preuve d'enjeu, cette fréquence reste fixe. Dans le consensus de mise en jeu d'Ethereum, le temps est divisé en créneaux (12 secondes) et périodes (32 créneaux). Un validateur est sélectionné aléatoirement pour proposer un bloc dans chaque créneau. Ce validateur est responsable de la création d'un nouveau bloc et de son envoi aux autres nœuds du réseau. De même, dans chaque créneau, un comité de validateurs est choisi au hasard, et leurs votes servent à déterminer la validité du bloc proposé. Il est important de diviser le validateur mis en place en comités pour maintenir la charge du réseau gérable. Les validateurs sont répartis en comités de telle façon que chaque validateur actif atteste à chaque période, mais pas à chaque créneau.
 
-## Comment une transaction est exécutée sur Ethereum PoS {#transaction-execution-ethereum-pos}
+## Comment une transaction est exécutée sur l'Ethereum PoS {#transaction-execution-ethereum-pos}
 
 Ce qui suit fournit une explication de bout en bout de la façon dont une transaction est exécutée avec la preuve d'enjeu Ethereum (PoS).
 
-1. Un utilisateur crée et signe une [transaction](/developers/docs/transactions/) avec sa clé privée. Ceci est généralement géré par un portefeuille ou une bibliothèque telle que [ethers.js](https://docs.ethers.org/v6/), [web3js](https://docs.web3js.org/), [web3py](https://web3py.readthedocs.io/en/v5/) etc. mais sous le capot l'utilisateur fait une requête à un nœud en utilisant l'API [JSON-RPC](/developers/docs/apis/json-rpc/) d'Ethereum. L'utilisateur définit la quantité de gaz qu'il est prêt à payer comme un pourboire au validateur pour l'encourager à inclure la transaction dans un bloc. Les [pourboires](/developers/docs/gas/#priority-fee) sont payés au validateur alors que les [frais de base](/developers/docs/gas/#base-fee) sont brûlés.
-2. La transaction est soumise à un client d'exécution [Ethereum](/developers/docs/nodes-and-clients/#execution-client) qui vérifie sa validité. Cela signifie s'assurer que l'expéditeur a suffisamment d'ETH pour remplir la transaction et qu'il l'a signée avec la bonne clé.
+1. Un utilisateur crée et signe une [transaction](/developers/docs/transactions/) avec sa clé privée. Ceci est généralement géré par un portefeuille ou une bibliothèque telle que [ethers.js](https://docs.ethers.org/v6/), [web3js](https://docs.web3js.org/), [web3py](https://web3py.readthedocs.io/en/v5/), etc., mais en arrière-plan, l'utilisateur fait une requête à un nœud en utilisant l'[API JSON-RPC](/developers/docs/apis/json-rpc/) d'Ethereum. L'utilisateur définit la quantité de gaz qu'il est prêt à payer comme un pourboire au validateur pour l'encourager à inclure la transaction dans un bloc. Les [pourboires](/developers/docs/gas/#priority-fee) sont payés au validateur tandis que les [frais de base](/developers/docs/gas/#base-fee) sont brûlés.
+2. La transaction est soumise à un [client d'exécution](/developers/docs/nodes-and-clients/#execution-client) Ethereum qui en vérifie la validité. Cela signifie s'assurer que l'expéditeur a suffisamment d'ETH pour remplir la transaction et qu'il l'a signée avec la bonne clé.
 3. Si la transaction est valide, le client d'exécution l'ajoute à son mempool local (liste des transactions en attente) et le transmet également à d'autres nœuds sur le réseau d'informations de la couche d'exécution. Quand d'autres nœuds reçoivent la transaction, ils l'ajoutent également à leur mempool local. Les utilisateurs avancés peuvent s'abstenir de diffuser leur transaction et la transmettre à des créateurs de blocs spécialisés tels que [Flashbots Auction](https://docs.flashbots.net/flashbots-auction/overview). Cela leur permet d'organiser les transactions dans les blocs à venir pour un profit maximal ([MEV](/developers/docs/mev/#mev-extraction)).
-4. Un des nœuds de validation sur le réseau est le bloc proposé pour le créneau actuel, après avoir été précédemment sélectionné aléatoirement en utilisant la fonction RANDAO. Ce noeud est responsable de la construction et de la diffusion du prochain bloc à ajouter à la blockchain Ethereum et de la mise à jour de l'état global. Le noeud est composé de trois parties : un client d'exécution, un client de consensus et un client validateur. Le client d'exécution relie les transactions depuis le mempool local à une « charge utile d'exécution » et les exécute localement pour générer un changement d'état. Ces informations sont transmises au client de consensus où la charge utile d'exécution est enveloppée dans un « bloc balise » qui contient également des informations sur les récompenses, les pénalités, les réductions, les attestations, etc. qui permettent au réseau de se mettre d'accord sur la séquence de blocs en tête de la chaîne. La communication entre l'exécution et les clients de consensus est décrite plus en détail dans [Connecting the Consensus and Execution Clients](/developers/docs/networking-layer/#connecting-clients).
-5. Les autres nœuds reçoivent le nouveau bloc phare sur le réseau d'informations de la couche de consensus. Ils le transmettent à leur client d'exécution où les transactions sont réexécutées localement pour s'assurer que le changement d'état proposé est valide. Le client de validateur atteste ensuite que le bloc est valide et qu'il est le bloc suivant logique dans leur vue de la chaîne (ce qui signifie qu'il se construit sur la chaîne avec le plus grand poids d'attestations tel que défini dans les [règles de choix de fourche](/developers/docs/consensus-mechanisms/pos/#fork-choice)). Le bloc est ajouté à la base de données locale de chaque noeud qui l'atteste.
+4. Un des nœuds de validation sur le réseau est le bloc proposé pour le créneau actuel, après avoir été précédemment sélectionné aléatoirement en utilisant la fonction RANDAO. Ce noeud est responsable de la construction et de la diffusion du prochain bloc à ajouter à la blockchain Ethereum et de la mise à jour de l'état global. Le noeud est composé de trois parties : un client d'exécution, un client de consensus et un client validateur. Le client d'exécution relie les transactions depuis le mempool local à une « charge utile d'exécution » et les exécute localement pour générer un changement d'état. Ces informations sont transmises au client de consensus où la charge utile d'exécution est enveloppée dans un « bloc balise » qui contient également des informations sur les récompenses, les pénalités, les réductions, les attestations, etc. qui permettent au réseau de se mettre d'accord sur la séquence de blocs en tête de la chaîne. La communication entre les clients d'exécution et de consensus est décrite plus en détail dans [Connexion des clients de consensus et d'exécution](/developers/docs/networking-layer/#connecting-clients).
+5. Les autres nœuds reçoivent le nouveau bloc phare sur le réseau d'informations de la couche de consensus. Ils le transmettent à leur client d'exécution où les transactions sont réexécutées localement pour s'assurer que le changement d'état proposé est valide. Le client validateur atteste alors que le bloc est valide et qu'il s'agit du bloc logique suivant dans sa vision de la chaîne (ce qui signifie qu'il se construit sur la chaîne avec le plus grand poids d'attestations, comme défini dans les [règles de choix de fourche](/developers/docs/consensus-mechanisms/pos/#fork-choice)). Le bloc est ajouté à la base de données locale de chaque noeud qui l'atteste.
 6. La transaction peut être considérée comme « finalisée » si elle fait partie d’une chaîne avec un « lien de majorité qualifiée » entre deux points de contrôle. Les points de contrôle ont lieu au début de chaque période. Ils existent pour tenir compte du fait que parmi les validateurs actifs, seul un sous-ensemble atteste à chaque créneau alors que tous attestent au cours de chaque période. Par conséquent, ce n’est qu’entre les périodes qu’un « lien de majorité qualifié » peut être démontré (durant lequel 66 % de tous les ETH misés sur le réseau s’accordent sur deux points de contrôle).
 
 Vous trouverez plus de détails sur la finalité ci-dessous.
 
-## Finalisation {#finality}
+## Finalité {#finality}
 
-Une transaction atteint la « finalité » dans les réseaux distribués lorsqu’elle fait partie d’un bloc ne pouvant être modifié sans qu'une grande quantité d’ETH ne soit brûlée. Avec la preuve d'enjeu d'Ethereum, cela est géré via des blocs dits « checkpoint » ou « points de contrôle ». Le premier bloc de chaque période est un point de contrôle. Les validateurs votent pour des paires de blocs « points de contrôle » qu'ils considèrent comme étant valides. Si une paire de points de contrôle regroupe des votes représentant au moins les deux tiers de l'ETH total misé, les points de contrôle sont mis à niveau. La plus récente des deux (cible) devient « justifiée ». La plus ancienne des deux est déjà justifiée en ce qu'elle était la « cible » de la période précédente. Elle est ensuite mise à niveau vers le statut « finalisée ».
+Une transaction atteint la « finalité » dans les réseaux distribués lorsqu’elle fait partie d’un bloc ne pouvant être modifié sans qu'une grande quantité d’ETH ne soit brûlée. Avec la preuve d'enjeu d'Ethereum, cela est géré via des blocs dits « checkpoint » ou « points de contrôle ». Le premier bloc de chaque période est un point de contrôle. Les validateurs votent pour des paires de blocs « points de contrôle » qu'ils considèrent comme étant valides. Si une paire de points de contrôle regroupe des votes représentant au moins les deux tiers de l'ETH total misé, les points de contrôle sont mis à niveau. La plus récente des deux (cible) devient « justifiée ». La plus ancienne des deux est déjà justifiée en ce qu'elle était la « cible » de la période précédente. Elle est ensuite mise à niveau vers le statut « finalisée ». Ce processus de mise à niveau des points de contrôle est géré par **[Casper the Friendly Finality Gadget (Casper-FFG)](https://arxiv.org/pdf/1710.09437)**. Casper-FFG est un outil de finalité de bloc pour le consensus. Une fois qu'un bloc est finalisé, il ne peut être ni annulé ni modifié sans une sanction de la majorité des validateurs, ce qui le rend économiquement non viable.
 
-Pour annuler un bloc finalisé, un attaquant devrait s'engager à perdre au moins un tiers de l'ETH total mis en jeu. La raison exacte de ce phénomène est expliquée [dans ce post de blog de l'Ethereum Foundation](https://blog.ethereum.org/2016/05/09/on-settlement-finality). Puisque la finalisation requiert une majorité des deux tiers, un attaquant pourrait empêcher le réseau d'atteindre la finalité en votant avec un tiers de la mise totale. Il existe un mécanisme visant à se défendre contre ce type d'attaque : la [fuite d'inactivité](https://eth2book.info/bellatrix/part2/incentives/inactivity). Ce mécanisme s'active lorsque la chaîne échoue à finaliser plus de quatre périodes. La fuite d'inactivité détruit progressivement les ETH mis en jeu par les validateurs qui votent contre la majorité, permettant à celle -ci de retrouver une majorité des deux tiers et de finaliser la chaîne.
+Pour annuler un bloc finalisé, un attaquant devrait s'engager à perdre au moins un tiers de l'ETH total mis en jeu. La raison exacte de ce phénomène est expliquée dans cet [article de blog de la Fondation Ethereum](https://blog.ethereum.org/2016/05/09/on-settlement-finality/). Puisque la finalisation requiert une majorité des deux tiers, un attaquant pourrait empêcher le réseau d'atteindre la finalité en votant avec un tiers de la mise totale. Il existe un mécanisme pour se défendre contre cela : la [fuite d'inactivité](https://eth2book.info/bellatrix/part2/incentives/inactivity). Ce mécanisme s'active lorsque la chaîne échoue à finaliser plus de quatre périodes. La fuite d'inactivité détruit progressivement les ETH mis en jeu par les validateurs qui votent contre la majorité, permettant à celle -ci de retrouver une majorité des deux tiers et de finaliser la chaîne.
 
-## Sécurité Crypto-économique {#crypto-economic-security}
+## Sécurité crypto-économique {#crypto-economic-security}
 
 Faire fonctionner un validateur est un engagement. Il est attendu du validateur qu'il maintienne un matériel et une connectivité suffisants pour participer à la validation et à la proposition de blocs. En retour, le validateur est payé en ETH (le solde misé augmente). D'autre part, la participation en tant que validateur ouvre également de nouvelles possibilités pour les utilisateurs d'attaquer le réseau en vue de réaliser un gain personnel ou un sabotage. Pour éviter cela, les validateurs ratent les récompenses en ETH s'ils ne participent pas quand ils sont appelés, et leur mise actuelle peut être détruite s'ils se comportent de manière malhonnête. Deux principaux comportements peuvent être considérés comme malhonnêtes : proposer plusieurs blocs pour un même créneau (équivoque) et soumettre des attestations contradictoires.
 
-La quantité d'ETH détruite dépend du nombre de validateurs qui sont sanctionnés en même temps. Ce mécanisme est connu sous le nom de [« pénalité de corrélation »](https://eth2book.info/bellatrix/part2/incentives/slashing#the-correlation-penalty) ; il peut être mineur (~1 % de la mise en jeu pour un seul validateur sanctionné) ou entraîner la destruction de 100 % de la mise en jeu du validateur (échec massif). Elle est imposée à mi-chemin d’une période de sortie forcée qui commence par une pénalité immédiate (jusqu’à 1 ETH) le jour 1, la pénalité de corrélation le jour 18 et enfin l’expulsion du réseau le jour 36. Les validateurs reçoivent chaque jour des pénalités d'attestation mineures parce qu'ils sont présents sur le réseau mais ne soumettent pas de votes. Tout cela signifie qu’une attaque coordonnée serait très coûteuse pour l’attaquant.
+La quantité d'ETH détruite dépend du nombre de validateurs qui sont sanctionnés en même temps. Ce phénomène est connu sous le nom de [« pénalité de corrélation »](https://eth2book.info/bellatrix/part2/incentives/slashing#the-correlation-penalty), et il peut être mineur (~1 % de la mise pour un seul validateur sanctionné) ou peut entraîner la destruction de 100 % de la mise du validateur (événement de sanction de masse). Elle est imposée à mi-chemin d’une période de sortie forcée qui commence par une pénalité immédiate (jusqu’à 1 ETH) le jour 1, la pénalité de corrélation le jour 18 et enfin l’expulsion du réseau le jour 36. Les validateurs reçoivent chaque jour des pénalités d'attestation mineures parce qu'ils sont présents sur le réseau mais ne soumettent pas de votes. Tout cela signifie qu’une attaque coordonnée serait très coûteuse pour l’attaquant.
 
 ## Choix de la fourche {#fork-choice}
 
-Lorsque le réseau fonctionne de manière optimale et honnête, il n'y a jamais qu'un nouveau bloc en tête de chaîne, et tous les validateurs l'attestent. Cependant, il est possible pour les validateurs d'avoir des points de vue différents sur le bloc en tête de la chaîne, en raison de la latence du réseau ou parce qu'un validateur a émis des données contradictoires. Par conséquent, les clients de consensus ont besoin d'un algorithme pour décider lequel favoriser. L'algorithme utilisé dans la preuve d'enjeu Ethereum est appelé [LMD-GHOST](https://arxiv.org/pdf/2003.03052.pdf), et il travaille en identifiant la fourche qui a le plus grand poids d'attestations dans son histoire.
+Lorsque le réseau fonctionne de manière optimale et honnête, il n'y a jamais qu'un nouveau bloc en tête de chaîne, et tous les validateurs l'attestent. Cependant, il est possible pour les validateurs d'avoir des points de vue différents sur le bloc en tête de la chaîne, en raison de la latence du réseau ou parce qu'un validateur a émis des données contradictoires. Par conséquent, les clients de consensus ont besoin d'un algorithme pour décider lequel favoriser. L'algorithme utilisé dans la preuve d'enjeu d'Ethereum s'appelle [LMD-GHOST](https://arxiv.org/pdf/2003.03052.pdf) et il fonctionne en identifiant la fourche qui a le plus grand poids d'attestations dans son historique.
 
 ## Preuve d'enjeu et sécurité {#pos-and-security}
 
-Avec un consensus de preuve d'enjeu (comme avec la preuve de travail), la menace d'une attaque de [51 %](https://www.investopedia.com/terms/1/51-attack.asp) existe toujours, mais elle est encore plus risquée pour les attaquants. Un attaquant aurait besoin de 51 % de l'ETH mis en jeu. Ils pourraient alors utiliser leurs propres attestations pour s'assurer que leur fourche préférée est celle qui possède le plus d'attestations. Les clients de consensus utilisent le « poids » des attestations cumulées pour déterminer la chaîne correcte, de sorte que cet attaquant serait en mesure de faire de sa fourche la fourche canonique. Toutefois, l'intérêt de la preuve d'enjeu comparé à la preuve de travail est que la communauté a la possibilité de monter une contre-attaque. Par exemple, les validateurs honnêtes pourraient décider de continuer de construire sur la chaîne minoritaire et ignorer totalement la fourche de l'attaquant tout en encourageant les applications, les échanges et les pools à faire de même. Ils pourraient également décider de sortir l'attaquant de force du réseau et de détruire l'ETH misé. Ces possibilités constituent des défenses fortes contre une attaque de type 51 %.
+La menace d'une [attaque des 51 %](https://www.investopedia.com/terms/1/51-attack.asp) existe toujours avec la preuve d'enjeu, tout comme avec la preuve de travail, mais elle est encore plus risquée pour les attaquants. Un attaquant aurait besoin de 51 % de l'ETH mis en jeu. Ils pourraient alors utiliser leurs propres attestations pour s'assurer que leur fourche préférée est celle qui possède le plus d'attestations. Les clients de consensus utilisent le « poids » des attestations cumulées pour déterminer la chaîne correcte, de sorte que cet attaquant serait en mesure de faire de sa fourche la fourche canonique. Toutefois, l'intérêt de la preuve d'enjeu comparé à la preuve de travail est que la communauté a la possibilité de monter une contre-attaque. Par exemple, les validateurs honnêtes pourraient décider de continuer de construire sur la chaîne minoritaire et ignorer totalement la fourche de l'attaquant tout en encourageant les applications, les échanges et les pools à faire de même. Ils pourraient également décider de sortir l'attaquant de force du réseau et de détruire l'ETH misé. Ces possibilités constituent des défenses fortes contre une attaque de type 51 %.
 
 Au-delà des attaques à 51 %, les acteurs mal intentionnés pourraient également tenter d'autres types d'activités malveillantes, telles que :
 
@@ -64,12 +64,12 @@ Dans l'ensemble, il a été démontré que la preuve d'enjeu, telle qu'elle est
 
 ## Avantages et inconvénients {#pros-and-cons}
 
-| Avantages                                                                                                                                                                                                                                                                                                            | Inconvénients                                                                                                                                  |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| Avantages                                                                                                                                                                                                                                                                                                                                                            | Inconvénients                                                                                                                                  |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
 | La mise en jeu rend plus accessible la participation du grand public à la sécurisation du réseau, promouvant ainsi la décentralisation. Un nœud de validateur peut être mis en place sur un ordinateur portable basique. Les pools de staking permettent aux utilisateurs de miser sans pour autant posséder 32 ETH. | La preuve d'enjeu est plus jeune et il existe moins de données concernant sa résilience en cas d'attaque que le consensus de preuve de travail |
-| Le système de mise est plus décentralisé. Les économies d’échelle ne s’appliquent pas de la même manière que pour le minage effectué sous un consensus de preuve de travail.                                                                                                                                         | La preuve d'enjeu est plus complexe à mettre en place que la preuve de travail                                                                 |
-| La preuve d'enjeu offre une plus grande sécurité crypto-économique que la preuve de travail                                                                                                                                                                                                                          | Les utilisateurs doivent utiliser trois logiciels pour participer à la preuve d'enjeu d'Ethereum.                                              |
-| Une émission moindre de nouveaux ETH est nécessaire pour inciter la participation au réseau                                                                                                                                                                                                                          |                                                                                                                                                |
+| Le système de mise est plus décentralisé. Les économies d’échelle ne s’appliquent pas de la même manière que pour le minage effectué sous un consensus de preuve de travail.                                                                                                                                                         | La preuve d'enjeu est plus complexe à mettre en place que la preuve de travail                                                                 |
+| La preuve d'enjeu offre une plus grande sécurité crypto-économique que la preuve de travail                                                                                                                                                                                                                                                                          | Les utilisateurs doivent utiliser trois logiciels pour participer à la preuve d'enjeu d'Ethereum.                              |
+| Une émission moindre de nouveaux ETH est nécessaire pour inciter la participation au réseau                                                                                                                                                                                                                                                                          |                                                                                                                                                |
 
 ### Comparaison avec la preuve de travail {#comparison-to-proof-of-work}
 
@@ -82,16 +82,16 @@ Initialement, Ethereum utilisait la preuve de travail, mais est passé à la pre
 - les sanctions économiques en cas de fraude rendent les attaques de type 51% plus onéreuses pour un attaquant que la preuve de travail
 - La communauté peut, en dernier recours, voter pour la récupération d'une chaîne viable dans le cas où surviendrait une attaque de type 51% malgré les barrières économiques évoquées ci-dessus.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [FAQ pour la preuve d'enjeu](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html)_Vitalik Buterin_
-- [Qu'est-ce qu'une Preuve d'enjeu ?](https://consensys.net/blog/blockchain-explained/what-is-proof-of-stake/) _ConsenSys_
-- [Qu'est-ce qu'une preuve d'enjeu et pourquoi c'est important ?](https://bitcoinmagazine.com/culture/what-proof-of-stake-is-and-why-it-matters-1377531463) _Vitalik Buterin_
-- [Pourquoi la preuve d'enjeu (Nov 2020)](https://vitalik.eth.limo/general/2020/11/06/pos2020.html) _Vitalik Buterin_
-- [Preuve d'enjeu : comment j'ai appris à aimer la subjectivité faible ?](https://blog.ethereum.org/2014/11/25/proof-stake-learned-love-weak-subjectivity) _Vitalik Buterin_
-- [Attaque et défense des preuves d'enjeu pour Ethereum](https://mirror.xyz/jmcook.eth/YqHargbVWVNRQqQpVpzrqEQ8IqwNUJDIpwRP7SS5FXs)
-- [Une philosophie de design pour la Preuve d'enjeu](https://medium.com/@VitalikButerin/a-proof-of-stake-design-philosophy-506585978d51) _Vitalik Buterin_
-- [Vidéo : Vitalik Buterin explique la preuve d'enjeu à Lex Fridman](https://www.youtube.com/watch?v=3yrqBG-7EVE)
+- [FAQ sur la preuve d'enjeu](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html) _Vitalik Buterin_
+- [Qu'est-ce que la preuve d'enjeu](https://consensys.net/blog/blockchain-explained/what-is-proof-of-stake/) _ConsenSys_
+- [Qu'est-ce que la preuve d'enjeu et pourquoi c'est important](https://bitcoinmagazine.com/culture/what-proof-of-stake-is-and-why-it-matters-1377531463) _Vitalik Buterin_
+- [Pourquoi la preuve d'enjeu (nov. 2020)](https://vitalik.eth.limo/general/2020/11/06/pos2020.html) _Vitalik Buterin_
+- [Preuve d'enjeu : Comment j'ai appris à aimer la faible subjectivité](https://blog.ethereum.org/2014/11/25/proof-stake-learned-love-weak-subjectivity/) _Vitalik Buterin_
+- [Attaque et défense de l'Ethereum en preuve d'enjeu](https://mirror.xyz/jmcook.eth/YqHargbVWVNRQqQpVpzrqEQ8IqwNUJDIpwRP7SS5FXs)
+- [Une philosophie de conception de la preuve d'enjeu](https://medium.com/@VitalikButerin/a-proof-of-stake-design-philosophy-506585978d51) _Vitalik Buterin_
+- [Vidéo : Vitalik Buterin explique la preuve d'enjeu à Lex Fridman](https://www.youtube.com/watch?v=3yrqBG-7EVE)
 
 ## Sujets connexes {#related-topics}
 
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/keys/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/keys/index.md
index 17944a9bd55..9b5395a5b14 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/keys/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/keys/index.md
@@ -1,31 +1,31 @@
 ---
-title: Les clés dans la preuve d'enjeu d'Ethereum
-description: Explications des clés utilisées dans le mécanisme de consensus de preuve d'enjeu d'Ethereum
+title: "Les clés dans la preuve d'enjeu d'Ethereum"
+description: "Explications des clés utilisées dans le mécanisme de consensus de preuve d'enjeu d'Ethereum"
 lang: fr
 ---
 
 Ethereum sécurise les actifs des utilisateurs au moyen de la cryptographie à clé publique-privée. La clé publique sert de base à une adresse Ethereum, c'est-à-dire qu'elle est visible par le grand public et utilisée comme identifiant unique. La clé privée (ou secrète) ne doit être accessible qu'à un propriétaire de compte. La clé privée est utilisée pour signer les transactions et les données, afin que la cryptographie puisse prouver que le propriétaire approuve une action d'une clé privée spécifique.
 
-Les clés Ethereum sont générées à l'aide de la cryptographie à [courbe elliptique](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography).
+Les clés d'Ethereum sont générées à l'aide de la [cryptographie sur les courbes elliptiques](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography).
 
-Cependant, quand Ethereum est passé de la [preuve de travail](/developers/docs/consensus-mechanisms/pow) à la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos), un nouveau type de clé a été ajouté à Ethereum. Les clés d'origine fonctionnent toujours exactement comme avant — il n'y a eu aucune modification aux clés basées sur des courbes elliptiques qui sécurisent les comptes. Toutefois, les utilisateurs avaient besoin d'un nouveau type de clé pour participer à la preuve d'enjeu en stakant l'ETH et en exécutant les validateurs. Ce besoin est né des problèmes d'évolutivité associés aux nombreux messages passant entre un grand nombre de validateurs, qui nécessitaient une méthode cryptographique pouvant être facilement agrégée afin de réduire la quantité de communication nécessaire à l'obtention d'un consensus dans le réseau.
+Cependant, lorsque Ethereum est passé de la [preuve de travail](/developers/docs/consensus-mechanisms/pow) à la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos), un nouveau type de clé a été ajouté à Ethereum. Les clés d'origine fonctionnent toujours exactement comme avant — il n'y a eu aucune modification aux clés basées sur des courbes elliptiques qui sécurisent les comptes. Toutefois, les utilisateurs avaient besoin d'un nouveau type de clé pour participer à la preuve d'enjeu en stakant l'ETH et en exécutant les validateurs. Ce besoin est né des problèmes d'évolutivité associés aux nombreux messages passant entre un grand nombre de validateurs, qui nécessitaient une méthode cryptographique pouvant être facilement agrégée afin de réduire la quantité de communication nécessaire à l'obtention d'un consensus dans le réseau.
 
-Ce nouveau type de clés utilise le [schéma de signature **Boneh-Lynn-Shacham (BLS)**](https://wikipedia.org/wiki/BLS_digital_signature). BLS permet une agrégation très efficace des signatures mais permet également l'ingénierie inverse des clés individuelles des validateurs agrégées et est idéal pour gérer les actions entre validateurs.
+Ce nouveau type de clé utilise le [schéma de signature **Boneh-Lynn-Shacham (BLS)**](https://wikipedia.org/wiki/BLS_digital_signature). BLS permet une agrégation très efficace des signatures mais permet également l'ingénierie inverse des clés individuelles des validateurs agrégées et est idéal pour gérer les actions entre validateurs.
 
 ## Les deux types de clés de validateur {#two-types-of-keys}
 
-Avant le passage à la preuve d'enjeu, les utilisateurs d'Ethereum ne disposaient que d'une seule clé privée basée sur la courbe elliptique pour accéder à leurs fonds. Avec l'introduction de la preuve d'enjeu, les utilisateurs qui souhaitaient être des stakers individuels avaient également besoin d'une **clé de validateur** et d'une **clé de retrait**.
+Avant le passage à la preuve d'enjeu, les utilisateurs d'Ethereum ne disposaient que d'une seule clé privée basée sur la courbe elliptique pour accéder à leurs fonds. Avec l'introduction de la preuve d'enjeu, les utilisateurs qui souhaitaient être des validateurs individuels avaient également besoin d'une **clé de validateur** et d'une **clé de retrait**.
 
 ### La clé de validateur {#validator-key}
 
 La clé de signature du validateur est constituée de deux éléments :
 
-- La **clé privée** du validateur
-- La **clé publique ** du validateur
+- Clé **privée** de validateur
+- Clé **publique** de validateur
 
 L'objectif de la clé privée du validateur est de signer des opérations sur la blockchain telles que les propositions de bloc et les attestations. Pour cette raison, ces clés doivent être conservées dans un portefeuille chaud.
 
-Cette flexibilité a l'avantage de déplacer très rapidement les clés de signature du validateur d'un appareil à un autre. Cependant, si elles se sont perdues ou sont volées, le voleur peut **agir malicieusement** de plusieurs façons :
+Cette flexibilité a l'avantage de déplacer très rapidement les clés de signature du validateur d'un appareil à un autre. Cependant, si elles se sont perdues ou sont volées, le voleur peut agir malicieusement de plusieurs façons :
 
 - Slasher le validateur en :
   - Être proposant et signer deux blocs phares différents pour le même emplacement
@@ -33,13 +33,13 @@ Cette flexibilité a l'avantage de déplacer très rapidement les clés de signa
   - Être un attesteur et signer deux attestations différentes ayant la même cible
 - Forcer une sortie volontaire, qui empêche le validateur de staker et accorde l'accès à son solde ETH au propriétaire de la clé de retrait
 
-La **clé publique de validation** est incluse dans les données de transaction lorsqu'un utilisateur dépose l'ETH dans le contrat de dépôt du staking. Ceci est connu sous le nom de _données de dépôt_, et il permet à Ethereum d'identifier le validateur.
+La **clé publique du validateur** est incluse dans les données de la transaction lorsqu'un utilisateur dépose des ETH sur le contrat de dépôt de staking. Ces informations sont appelées _données de dépôt_ et permettent à Ethereum d'identifier le validateur.
 
 ### Identifiants de retrait {#withdrawal-credentials}
 
-Chaque validateur possède une propriété appelée _identifiants de retrait_. Ce champ de 32 octets commence soit par un `0x00`, représentant les identifiants de retrait BLS, soit par un `0x01`, représentant des identifiants qui pointent vers une adresse d'exécution.
+Chaque validateur possède une propriété connue sous le nom d'_identifiants de retrait_. Ce champ de 32 octets commence soit par un `0x00`, représentant les identifiants de retrait BLS, soit par un `0x01`, représentant les identifiants qui pointent vers une adresse d'exécution.
 
-Les validateurs avec des clés BLS commençant par `0x00` doivent mettre à jour ces identifiants pour les diriger vers une adresse d'exécution afin d'activer les paiements de solde excédentaire ou le retrait complet de la mise. Cela peut être fait en fournissant une adresse d'exécution dans les données de dépôt lors de la génération initiale de la clé, _OU_ en utilisant ultérieurement la clé de retrait pour signer et diffuser un message `BLSToExecutionChange`.
+Les validateurs avec des clés BLS `0x00` doivent mettre à jour ces identifiants pour qu'ils pointent vers une adresse d'exécution afin d'activer les paiements de solde excédentaire ou le retrait complet du staking. Cela peut être fait en fournissant une adresse d'exécution dans les données de dépôt lors de la génération de clé initiale, _OU_ en utilisant la clé de retrait ultérieurement pour signer et diffuser un message `BLSToExecutionChange`.
 
 ### La clé de retrait {#withdrawal-key}
 
@@ -47,20 +47,22 @@ La clé de retrait sera nécessaire pour mettre à jour les justificatifs de ret
 
 Tout comme les clés de validation, les clés de retrait sont également composées de deux éléments :
 
-- La **clé privée** de retrait
-- La **clé publique** de retrait
+- Clé **privée** de retrait
+- Clé **publique** de retrait
 
-Perdre cette clé avant de mettre à jour les justificatifs de retrait au type `0x01` signifie perdre l'accès au solde du validateur. Le validateur peut toujours signer des attestations et des blocs, car ces actions ne nécessitent pas sa clé privée. Cependant, il existe peu ou pas d'avantage à continuer si les clés de retrait sont perdues.
+Perdre cette clé avant de mettre à jour les identifiants de retrait vers le type `0x01` signifie perdre l'accès au solde du validateur. Le validateur peut toujours signer des attestations et des blocs, car ces actions ne nécessitent pas sa clé privée. Cependant, il existe peu ou pas d'avantage à continuer si les clés de retrait sont perdues.
 
 La séparation des clés de validateur des clés de comptes Ethereum permet à plusieurs validateurs d'être exécutés par un seul utilisateur.
 
-![schéma de la clé de validateur](validator-key-schematic.png)
+![schéma de clé du validateur](validator-key-schematic.png)
 
-## Dérivation des clés à partir d'une phrase de récupération {#deriving-keys-from-seed}
+**Remarque** : Pour se retirer des fonctions de staking et retirer le solde d'un validateur, il faut actuellement signer un [message de sortie volontaire (VEM)](https://mirror.xyz/ladislaus.eth/wmoBbUBes2Wp1_6DvP6slPabkyujSU7MZOFOC3QpErs&1) avec la clé du validateur. Cependant, l'[EIP-7002](https://eips.ethereum.org/EIPS/eip-7002) est une proposition qui permettra à un utilisateur de déclencher la sortie d'un validateur et de retirer son solde en signant des messages de sortie avec la clé de retrait à l'avenir. Cela réduira les hypothèses de confiance en permettant aux stakers qui délèguent des ETH à des [fournisseurs de staking en tant que service](/staking/saas/#what-is-staking-as-a-service) de garder le contrôle de leurs fonds.
+
+## Dérivation de clés à partir d'une phrase de récupération {#deriving-keys-from-seed}
 
 Si chaque mise en jeu de 32 ETH nécessitait un nouvel ensemble de 2 clés complètement indépendantes, la gestion des clés deviendrait rapidement ingérable, en particulier pour les utilisateurs gérant plusieurs validateurs. Au lieu de cela, plusieurs clés de validateur peuvent être dérivées d'un seul secret commun et le stockage de ce seul secret permet d'accéder à plusieurs clés de validateur.
 
-Les [mnémoniques](https://en.bitcoinwiki.org/wiki/Mnemonic_phrase) et les chemins sont des éléments importants que les utilisateurs rencontrent souvent lorsqu'[ils accèdent](https://ethereum.stackexchange.com/questions/19055/what-is-the-difference-between-m-44-60-0-0-and-m-44-60-0) à leurs portefeuilles. Le mnémonique est une séquence de mots qui agit comme une graine initiale pour une clé privée. Lorsqu'il est combiné avec des données supplémentaires, le mnémonique génère un hash connu sous le nom de clé maîtresse. Cela peut être considéré comme la racine d'un arbre. Des branches à partir de cette racine peuvent ensuite être dérivées en utilisant un chemin hiérarchique, de sorte que les nœuds enfants peuvent exister comme des combinaisons du hachage de leur nœud parent et de leur indice dans l'arbre. Lisez les normes [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) et [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) à propos de la génération de clés basée sur des mnémoniques.
+Les [mnémoniques](https://en.bitcoinwiki.org/wiki/Mnemonic_phrase) et les chemins de dérivation sont des caractéristiques importantes que les utilisateurs rencontrent souvent lorsqu'[ils accèdent](https://ethereum.stackexchange.com/questions/19055/what-is-the-difference-between-m-44-60-0-0-and-m-44-60-0) à leurs portefeuilles. Le mnémonique est une séquence de mots qui agit comme une graine initiale pour une clé privée. Lorsqu'il est combiné avec des données supplémentaires, le mnémonique génère un hash connu sous le nom de clé maîtresse. Cela peut être considéré comme la racine d'un arbre. Des branches à partir de cette racine peuvent ensuite être dérivées en utilisant un chemin hiérarchique, de sorte que les nœuds enfants peuvent exister comme des combinaisons du hachage de leur nœud parent et de leur indice dans l'arbre. En savoir plus sur les normes [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) et [BIP-19](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) pour la génération de clés à partir de mnémoniques.
 
 Ces chemins ont la structure suivante, qui sera familière aux utilisateurs qui ont interagi avec des portefeuilles matériels :
 
@@ -74,7 +76,7 @@ Les barres obliques dans ce chemin séparent les composants de la clé privée c
 master_key / purpose / coin_type / account / change / address_index
 ```
 
-Cette logique permet aux utilisateurs d'attacher autant de validateurs que possible à une seule **phrase mnémotechnique** car la racine de l'arbre peut être commune, et la différenciation se produit au niveau des branches. L'utilisateur peut **dériver un nombre quelconque de clés** à partir d'une phrase mnémotechnique.
+Cette logique permet aux utilisateurs d'associer autant de validateurs que possible à une seule **phrase mnémonique**, car la racine de l'arbre peut être commune et la différenciation peut se faire au niveau des branches. L'utilisateur peut **dériver un nombre quelconque de clés** à partir de la phrase mnémonique.
 
 ```
       [m / 0]
@@ -88,9 +90,11 @@ Cette logique permet aux utilisateurs d'attacher autant de validateurs que possi
 
 Chaque branche est séparée par un `/`, donc `m/2` signifie commencer avec la clé maîtresse et suivre la branche 2. Dans le schéma ci-dessus, une seule phrase mnémonique est utilisée pour stocker trois clés de retrait, chacune associée à deux validateurs.
 
-![logique de la clé de validateur](multiple-keys.png)
+![logique des clés de validateur](multiple-keys.png)
 
 ## En savoir plus {#further-reading}
 
-- [Article de blog de l'Ethereum Foundation par Carl Beekhuizen](https://blog.ethereum.org/2020/05/21/keys)
-- [EIP-2333 BLS12-381 génération de clé](https://eips.ethereum.org/EIPS/eip-2333)
+- [Article de blog de la Fondation Ethereum par Carl Beekhuizen](https://blog.ethereum.org/2020/05/21/keys/)
+- [EIP-2333 Génération de clé BLS12-381](https://eips.ethereum.org/EIPS/eip-2333)
+- [EIP-7002 : Sorties déclenchées par la couche d'exécution](https://web.archive.org/web/20250125035123/https://research.2077.xyz/eip-7002-unpacking-improvements-to-staking-ux-post-merge)
+- [Gestion des clés à grande échelle](https://docs.ethstaker.cc/ethstaker-knowledge-base/scaled-node-operators/key-management-at-scale)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/pos-vs-pow/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/pos-vs-pow/index.md
index f1b7ce8eb22..e274c4b3e7d 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/pos-vs-pow/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/pos-vs-pow/index.md
@@ -1,6 +1,6 @@
 ---
 title: Preuve d'enjeu contre preuve de travail
-description: Une comparaison entre le mécanisme de consensus basé sur la preuve d'enjeu et la preuve de travail d'Ethereum
+description: "Une comparaison entre le mécanisme de consensus basé sur la preuve d'enjeu et la preuve de travail d'Ethereum"
 lang: fr
 ---
 
@@ -12,19 +12,19 @@ Cette page décrit les raisons pour lesquelles Ethereum est passé de la preuve
 
 Les chercheurs d'Ethereum considèrent que la preuve d'enjeu est plus sûre que la preuve de travail. Cependant, elle n'a été mise en œuvre que récemment pour le réseau principal Ethereum et elle est moins éprouvée que la preuve de travail. Les sections suivantes présentent les avantages et les inconvénients du modèle de sécurité de la preuve d'enjeu par rapport à celui de la preuve de travail.
 
-### Coût de l'attaque {#cost-to-attack}
+### Coût d'une attaque {#cost-to-attack}
 
-Dans la preuve d'enjeu, les validateurs sont tenus de mettre en dépôt (« mise ») au moins 32 ETH dans un contrat intelligent. Ethereum peut détruire l'éther mis en jeu pour punir les validateurs qui se comportent mal. Pour parvenir à un consensus, il faut qu'au moins 66 % du total d'éthers mis en jeu votent en faveur d'un ensemble particulier de blocs. Les blocs approuvés par >=66 % des participants deviennent « finalisés », ce qui signifie qu'ils ne peuvent pas être supprimés ou réorganisés.
+Dans la preuve d'enjeu, les validateurs sont tenus de mettre en dépôt (« mise ») au moins 32 ETH dans un contrat intelligent. Ethereum peut détruire l'éther mis en jeu pour punir les validateurs qui se comportent mal. Pour parvenir à un consensus, il faut qu'au moins 66 % du total d'éthers mis en jeu votent en faveur d'un ensemble particulier de blocs. Les blocs approuvés par >= 66 % de la mise deviennent « finalisés », ce qui signifie qu'ils ne peuvent être ni supprimés ni réorganisés.
 
 Attaquer le réseau peut signifier empêcher la chaîne de se finaliser ou garantir une certaine organisation des blocs dans la chaîne canonique qui profite d'une manière ou d'une autre à l'attaquant. Pour ce faire, l'attaquant doit détourner la voie d'un consensus honnête, soit en accumulant une grande quantité d'éther et en votant directement avec, soit en trompant les validateurs honnêtes pour qu'ils votent d'une manière particulière. Hormis les attaques sophistiquées et peu probables qui trompent les validateurs honnêtes, le coût d'une attaque contre Ethereum est le coût de l'enjeu qu'un attaquant doit accumuler pour influencer le consensus en sa faveur.
 
-Le coût d'attaque le plus bas est >33 % de l'enjeu total. Un attaquant détenant >33 % de l'enjeu total peut provoquer un retard de finalité simplement en se déconnectant. Il s'agit d'un problème relativement mineur pour le réseau, car il existe un mécanisme connu sous le nom de « fuite d'inactivité » qui fait fuir les enjeux des validateurs hors ligne jusqu'à ce que la majorité en ligne représente 66 % des enjeux et puisse à nouveau finaliser la chaîne. Il est également théoriquement possible pour un attaquant de provoquer une double finalité avec un peu plus de 33 % de l'enjeu total en créant deux blocs au lieu d'un lorsqu'on lui demande d'être producteur de blocs, puis en procédant à un double vote avec tous ses validateurs. Chaque fourche ne nécessite que 50 % des validateurs honnêtes restants pour voir chaque bloc en premier, donc s'ils parviennent à synchroniser correctement leurs messages, ils pourront peut-être finaliser les deux fourches. Cela a peu de chances de réussir, mais si un attaquant parvenait à causer une double-finalité, la communauté Ethereum devrait décider de suivre une des fourches, auquel cas les validateurs de l'attaquant seraient nécessairement sanctionnés sur l'autre.
+Le coût d'attaque le plus bas est supérieur à 33 % de la mise totale. Un attaquant détenant plus de 33 % de la mise totale peut entraîner un retard de finalité simplement en se déconnectant. Il s'agit d'un problème relativement mineur pour le réseau, car il existe un mécanisme connu sous le nom de « fuite d'inactivité » qui fait fuir les enjeux des validateurs hors ligne jusqu'à ce que la majorité en ligne représente 66 % des enjeux et puisse à nouveau finaliser la chaîne. Il est également théoriquement possible pour un attaquant de provoquer une double finalité avec un peu plus de 33 % de l'enjeu total en créant deux blocs au lieu d'un lorsqu'on lui demande d'être producteur de blocs, puis en procédant à un double vote avec tous ses validateurs. Chaque fourche ne nécessite que 50 % des validateurs honnêtes restants pour voir chaque bloc en premier, donc s'ils parviennent à synchroniser correctement leurs messages, ils pourront peut-être finaliser les deux fourches. Cela a peu de chances de réussir, mais si un attaquant parvenait à causer une double-finalité, la communauté Ethereum devrait décider de suivre une des fourches, auquel cas les validateurs de l'attaquant seraient nécessairement sanctionnés sur l'autre.
 
-Avec >33% de la mise totale, un attaquant a une chance d'avoir un effet mineur (retard de finalité) ou plus grave (double finalité) sur le réseau Ethereum. Avec plus de 14 000 000 ETH bloqués sur le réseau et un prix représentatif de 1 000 $/ETH, le coût minimum pour faire ces attaques est de `1000 x 14 000 000 x 0,33 = 4 620 000 000 $`. L'attaquant perdrait son argent à cause des pénalités et serait expulsé du réseau. Pour attaquer à nouveau, ils devraient accumuler >33 % de la mise (encore une fois) et la brûler (encore une fois). Chaque tentative d'attaque du réseau coûterait > 4,6 milliards de dollars (à 1 000 $/ETH et 14M ETH misés). L'attaquant est également expulsé du réseau lorsqu'il est sanctionné, et il doit donc rejoindre la file d'attente d'activation pour revenir. Cela signifie que la fréquence d'une attaque répétée est limitée non seulement par la vitesse à laquelle l'attaquant peut accumuler >33 % de la mise totale, mais aussi par le temps nécessaire pour intégrer tous leurs validateurs sur le réseau. Chaque fois que l'attaquant lance une attaque, il devient beaucoup plus pauvre, et le reste de la communauté s'enrichit, grâce au choc d'offre qui en résulte.
+Avec plus de 33 % de la mise totale, un attaquant a une chance d'avoir un effet mineur (retard de finalité) ou plus grave (double finalité) sur le réseau Ethereum. Avec plus de 14 000 000 d'ETH mis en jeu sur le réseau et un prix représentatif de 1 000 $/ETH, le coût minimum pour monter ces attaques est de `1000 x 14 000 000 x 0,33 = 4 620 000 000 $`. L'attaquant perdrait son argent à cause des pénalités et serait expulsé du réseau. Pour attaquer à nouveau, ils devraient accumuler plus de 33 % de la mise (encore) et la brûler (encore). Chaque tentative d'attaque du réseau coûterait plus de 4,6 milliards de dollars (à 1 000 $/ETH et 14M d'ETH misés). L'attaquant est également expulsé du réseau lorsqu'il est sanctionné, et il doit donc rejoindre la file d'attente d'activation pour revenir. Cela signifie que la fréquence d'une attaque répétée est limitée non seulement par la vitesse à laquelle l'attaquant peut accumuler plus de 33 % de la mise totale, mais aussi par le temps nécessaire pour intégrer tous ses validateurs sur le réseau. Chaque fois que l'attaquant lance une attaque, il devient beaucoup plus pauvre, et le reste de la communauté s'enrichit, grâce au choc d'offre qui en résulte.
 
 D'autres attaques, telles que les attaques 51 % ou la réversion de la finalité avec 66 % de la mise totale, nécessitent beaucoup plus d'ETH et coûtent beaucoup plus cher à l'attaquant.
 
-Comparons cela avec le mécanisme de preuve de travail. Le coût du lancement d’une attaque contre la preuve de travail Ethereum était le coût de la possession constante de >50 % du taux de hachage total du réseau. Cela équivalait au coût du matériel et aux frais de fonctionnement nécessaires pour disposer d'une puissance de calcul suffisante pour surpasser régulièrement les autres mineurs dans le calcul des solutions de preuve de travail. Ethereum était principalement exploité à l'aide de GPU plutôt que d'ASIC, ce qui permettait de réduire les coûts (même si Ethereum était resté sur une preuve de travail, l'exploitation minière ASIC serait peut-être devenue plus populaire). Un attaquant devrait acheter beaucoup de matériel et payer pour l'électricité nécessaire afin d'attaquer un réseau Ethereum basé sur la preuve de travail, mais le coût total serait inférieur au coût nécessaire pour accumuler suffisamment d'ETH pour lancer une attaque. Une attaque à 51 % est ~[20 fois](https://youtu.be/1m12zgJ42dI?t=1562) moins chère sur la preuve de travail que sur la preuve d'enjeu. Si l'attaque était détectée et que la chaîne effectuait une séparation pour supprimer leurs altérations, l'attaquant pourrait utiliser à nouveau le même matériel pour attaquer la nouvelle fourche.
+Comparons cela avec le mécanisme de preuve de travail. Le coût du lancement d’une attaque sur l'Ethereum à preuve de travail était le coût de la possession constante de plus de 50 % du taux de hachage total du réseau. Cela équivalait au coût du matériel et aux frais de fonctionnement nécessaires pour disposer d'une puissance de calcul suffisante pour surpasser régulièrement les autres mineurs dans le calcul des solutions de preuve de travail. Ethereum était principalement exploité à l'aide de GPU plutôt que d'ASIC, ce qui permettait de réduire les coûts (même si Ethereum était resté sur une preuve de travail, l'exploitation minière ASIC serait peut-être devenue plus populaire). Un attaquant devrait acheter beaucoup de matériel et payer pour l'électricité nécessaire afin d'attaquer un réseau Ethereum basé sur la preuve de travail, mais le coût total serait inférieur au coût nécessaire pour accumuler suffisamment d'ETH pour lancer une attaque. Une attaque à 51 % est environ [20 fois moins](https://youtu.be/1m12zgJ42dI?t=1562) coûteuse en preuve de travail qu'en preuve d'enjeu. Si l'attaque était détectée et que la chaîne effectuait une séparation pour supprimer leurs altérations, l'attaquant pourrait utiliser à nouveau le même matériel pour attaquer la nouvelle fourche.
 
 ### Complexité {#complexity}
 
@@ -36,7 +36,7 @@ Pour développer et tester en toute sécurité la logique de consensus de la pre
 
 La preuve d'enjeu est plus complexe que la preuve de travail, ce qui signifie qu'il y a davantage de vecteurs d'attaque potentiels à gérer. Au lieu d'un réseau pair-à-pair reliant les clients, il y en a deux, chacun mettant en œuvre un protocole distinct. Le fait qu'un validateur spécifique soit présélectionné pour proposer un bloc dans chaque créneau crée un risque de déni de service lorsque de grandes quantités de trafic réseau mettent ce validateur spécifique hors ligne.
 
-Les attaquants peuvent également programmer avec soin la publication de leurs blocs ou attestations de manière à ce qu'ils soient reçus par une certaine proportion du réseau honnête, l'incitant ainsi à voter d'une certaine manière. Finalement, un attaquant peut simplement accumuler suffisamment d'ETH en vue de le mettre en jeu et de dominer le mécanisme de consensus. Chacun de ces [vecteurs d'attaque a des défenses associées](/developers/docs/consensus-mechanisms/pos/attack-and-defense), mais ils n'existent pas pour être défendus sous preuve de travail.
+Les attaquants peuvent également programmer avec soin la publication de leurs blocs ou attestations de manière à ce qu'ils soient reçus par une certaine proportion du réseau honnête, l'incitant ainsi à voter d'une certaine manière. Finalement, un attaquant peut simplement accumuler suffisamment d'ETH en vue de le mettre en jeu et de dominer le mécanisme de consensus. Chacun de ces [vecteurs d'attaque a des défenses associées](/developers/docs/consensus-mechanisms/pos/attack-and-defense), mais ils n'existent pas pour être défendus dans le cadre de la preuve de travail.
 
 ## Décentralisation {#decentralization}
 
@@ -46,7 +46,7 @@ D'un autre côté, l'invention des produits dérivés de mise en jeu liquide a c
 
 Pour Ethereum, la meilleure option consiste à faire fonctionner les validateurs localement, sur des ordinateurs personnels, afin de maximiser la décentralisation. Cela explique pourquoi Ethereum résiste aux changements qui augmentent les exigences matérielles pour le fonctionnement d'un nœud/validateur.
 
-## Développement durable {#sustainability}
+## Durabilité {#sustainability}
 
 La preuve d'enjeu est une manière peu gourmande en carbone de sécuriser la blockchain. Dans le cadre de la preuve de travail, les mineurs sont en concurrence pour obtenir le droit de miner un bloc. Les mineurs sont plus performants lorsqu'ils peuvent effectuer des calculs plus rapidement, ce qui incite à investir dans le matériel et la consommation d'énergie. C'est ce qui a été observé pour Ethereum avant de passer à la preuve d'enjeu. Peu avant le passage à la preuve d'enjeu, Ethereum consommait environ 78 TWh/an, soit autant qu'un petit pays. Cependant, le passage à la preuve d'enjeu a permis de réduire cette dépense énergétique de ~99,98 %. La preuve d'enjeu a fait d'Ethereum une plateforme économe en énergie et à faible émission de carbone.
 
@@ -62,8 +62,8 @@ Regardez Justin Drake expliquer les avantages de la preuve d'enjeu par rapport 
 
 <YouTube id="1m12zgJ42dI" />
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [La philosophie de conception de la preuve d'enjeu par Vitalik](https://medium.com/@VitalikButerin/a-proof-of-stake-design-philosophy-506585978d51)
-- [Les FAQ de Vitalik sur la preuve d'enjeu](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-is-proof-of-stake)
-- [Vidéo de « Simply Explained » sur pas vs pow](https://www.youtube.com/watch?v=M3EFi_POhps)
+- [FAQ sur la preuve d'enjeu par Vitalik](https://vitalik.eth.limo/general/2017/12/31/pos_faq.html#what-is-proof-of-stake)
+- [Vidéo « Simplement expliqué » sur PoS contre PoW](https://www.youtube.com/watch?v=M3EFi_POhps)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md
index e219853a392..1d6c6898ad6 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md
@@ -1,10 +1,10 @@
 ---
-title: Récompenses et pénalités de preuve d'enjeu
-description: Découvrez les incitations intégrées au protocole dans la preuve de mise en jeu d'Ethereum.
+title: "Récompenses et pénalités de preuve d'enjeu"
+description: "Découvrez les incitations intégrées au protocole dans la preuve de mise en jeu d'Ethereum."
 lang: fr
 ---
 
-Ethereum est sécurisé à l'aide de sa cryptomonnaie native, l'ether (ETH). Les opérateurs de nœuds qui souhaitent participer à la validation de blocs et identifier la tête de la chaîne déposent de l'éther dans le [contrat de dépôt](/staking/deposit-contract/) sur Ethereum. Ils sont ensuite payés en ether pour exécuter un logiciel de validateur qui vérifie la validité des nouveaux blocs reçus sur le réseau peer-to-peer et applique l'algorithme de choix de fourche pour identifier la tête de la chaîne.
+Ethereum est sécurisé à l'aide de sa cryptomonnaie native, l'ether (ETH). Les opérateurs de nœuds qui souhaitent participer à la validation des blocs et à l'identification de la tête de la chaîne déposent de l'éther dans le [contrat de dépôt](/staking/deposit-contract/) sur Ethereum. Ils sont ensuite payés en ether pour exécuter un logiciel de validateur qui vérifie la validité des nouveaux blocs reçus sur le réseau peer-to-peer et applique l'algorithme de choix de fourche pour identifier la tête de la chaîne.
 
 Il y a deux rôles principaux pour un validateur : 1) vérifier les nouveaux blocs et les « attester » s'ils sont valides, 2) proposer de nouveaux blocs lorsqu'il est sélectionné au hasard dans la réserve de validateur totale. Si le validateur ne parvient pas à faire l'une de ces tâches quand il lui est demandé de ne pas recevoir un paiement par éther. Les validateurs sont aussi parfois chargés d'agréger les signatures et de participer à des comités de synchronisation.
 
@@ -18,51 +18,51 @@ Continuez pour plus de détails...
 
 ### Récompenses {#rewards}
 
-Les validateurs reçoivent des récompenses lorsqu'ils effectuent des votes cohérents avec la majorité des autres validateurs, lorsqu'ils proposent des blocs et lorsqu'ils participent à des comités de synchronisation. La valeur des récompenses à chaque époque est calculée à partir d'une `base_reward`. Il s'agit de l'unité de base à partir de laquelle les autres récompenses sont calculées. La `base_reward` représente la récompense moyenne reçue par un validateur dans des conditions optimales par période. Ceci est calculé à partir du solde effectif du validateur et du nombre total de validateurs actifs comme suit :
+Les validateurs reçoivent des récompenses lorsqu'ils effectuent des votes cohérents avec la majorité des autres validateurs, lorsqu'ils proposent des blocs et lorsqu'ils participent à des comités de synchronisation. La valeur des récompenses à chaque époque est calculée à partir d'une `base_reward`. Il s'agit de l'unité de base à partir de laquelle les autres récompenses sont calculées. La `base_reward` représente la récompense moyenne reçue par un validateur dans des conditions optimales par époque. Ceci est calculé à partir du solde effectif du validateur et du nombre total de validateurs actifs comme suit :
 
 ```
 base_reward = effective_balance * (base_reward_factor / (base_rewards_per_epoch * sqrt(sum(active_balance))))
 ```
 
-où `base_reward_factor` est 64, `base_rewards_per_epoch` est 4 et `sum(active balance)` représente le montant total d'Ether mis en jeu par l'ensemble des validateurs actifs.
+où `base_reward_factor` est 64, `base_rewards_per_epoch` est 4 et `sum(active balance)` est le total d'ether mis en jeu par l'ensemble des validateurs actifs.
 
-Cela signifie que la récompense de base est proportionnelle au solde effectif du validateur et inversement proportionnelle au nombre de validateurs sur le réseau. Plus il y a de validateurs, plus l'émission globale est importante (selon la formule `sqrt(N))`, mais plus la `base_reward` par validateur est petite (selon la formule `1/sqrt(N)`). Ces facteurs influencent le Taux de Rendement Annuel (APR) pour un nœud de mise en jeu. Lisez la justification de cela dans [les notes de Vitalik](https://notes.ethereum.org/@vbuterin/rkhCgQteN?type=view#Base-rewards).
+Cela signifie que la récompense de base est proportionnelle au solde effectif du validateur et inversement proportionnelle au nombre de validateurs sur le réseau. Plus il y a de validateurs, plus l'émission globale est importante (en tant que `sqrt(N)`), mais plus la `base_reward` par validateur est petite (en tant que `1/sqrt(N)`). Ces facteurs influencent le Taux de Rendement Annuel (APR) pour un nœud de mise en jeu. Lisez la justification de ceci dans les [notes de Vitalik](https://notes.ethereum.org/@vbuterin/serenity_design_rationale?type=view#Base-rewards).
 
 La récompense totale est ensuite calculée comme la somme de cinq composants, chacun ayant un poids qui détermine la contribution de chaque composant à la récompense totale. Les composants sont :
 
 ```
-1. source vote: the validator has made a timely vote for the correct source checkpoint
-2. target vote: the validator has made a timely vote for the correct target checkpoint
-3. head vote: the validator has made a timely vote for the correct head block
-4. sync committee reward: the validator has participated in a sync committee
-5. proposer reward: the validator has proposed a block in the correct slot
+1. vote de source : le validateur a voté à temps pour le point de contrôle de source correct
+2. vote de cible : le validateur a voté à temps pour le point de contrôle de cible correct
+3. vote de tête : le validateur a voté à temps pour le bloc de tête correct
+4. récompense du comité de synchronisation : le validateur a participé à un comité de synchronisation
+5. récompense du proposant : le validateur a proposé un bloc dans le créneau correct
 ```
 
 Les pondérations pour chaque composant sont les suivantes :
 
 ```
-TIMELY_SOURCE_WEIGHT    uint64(14)
-TIMELY_TARGET_WEIGHT    uint64(26)
-TIMELY_HEAD_WEIGHT  uint64(14)
-SYNC_REWARD_WEIGHT  uint64(2)
-PROPOSER_WEIGHT uint64(8)
+TIMELY_SOURCE_WEIGHT	uint64(14)
+TIMELY_TARGET_WEIGHT	uint64(26)
+TIMELY_HEAD_WEIGHT	uint64(14)
+SYNC_REWARD_WEIGHT	uint64(2)
+PROPOSER_WEIGHT	uint64(8)
 ```
 
-Ces poids s'additionnent pour atteindre 64. La récompense est calculée comme la somme des poids applicables divisée par 64. Un validateur ayant effectué des votes de source, de cible et de tête en temps opportun, proposé un bloc et participé à un comité de synchronisation pourrait recevoir `64/64 * base_reward == base_reward`. Cependant, un validateur n'est généralement pas un proposeur de bloc, donc sa récompense maximale est `64-8 /64 * base_reward == 7/8 * base_reward`. Les validateurs qui ne sont ni des proposeurs de blocs ni figurant dans un comité de synchronisation peuvent recevoir `64-8-2 / 64 * base_reward == 6.75/8 * base_reward`.
+Ces poids s'additionnent pour atteindre 64. La récompense est calculée comme la somme des poids applicables divisée par 64. Un validateur qui a effectué des votes de source, de cible et de tête en temps opportun, proposé un bloc et participé à un comité de synchronisation pourrait recevoir `64/64 * base_reward == base_reward`. Cependant, un validateur n'est généralement pas un proposeur de bloc, donc sa récompense maximale est `64-8 /64 * base_reward == 7/8 * base_reward`. Les validateurs qui ne sont ni des proposeurs de blocs ni dans un comité de synchronisation peuvent recevoir `64-8-2 / 64 * base_reward == 6.75/8 * base_reward`.
 
-Une récompense additionnelle est prévue pour promouvoir les attestations rapides. C'est le `inclusion_delay_reward`. Cela a une valeur égale à la `base_reward` multipliée par `1/delay` où `delay` est le nombre de créneaux séparant la proposition de bloc et son attestation. Par exemple, si l'attestation est soumise dans un créneau de la proposition de bloc, le attestateur reçoit `base_reward * 1/1 == base_reward`. Si l'attestation arrive sur le créneau suivant, l'attestateur reçoit `base_reward * 1/2` et ainsi de suite.
+Une récompense additionnelle est prévue pour promouvoir les attestations rapides. C'est la `inclusion_delay_reward`. Elle a une valeur égale à la `base_reward` multipliée par `1/delay` où `delay` est le nombre de créneaux séparant la proposition de bloc et l'attestation. Par exemple, si l'attestation est soumise dans un délai d'un créneau après la proposition de bloc, l'attestant reçoit `base_reward * 1/1 == base_reward`. Si l'attestation arrive dans le créneau suivant, l'attestant reçoit `base_reward * 1/2` et ainsi de suite.
 
-Les proposeurs de blocs reçoivent `8 / 64 * base_reward` pour **chaque attestation valide** incluse dans le bloc, donc la valeur réelle de la récompense évolue avec le nombre de validateurs attestant. Les proposeurs de blocs peuvent également augmenter leur récompense en incluant des preuves de comportement malhonnête d'autres validateurs dans le bloc qu'ils proposent. Ces récompenses sont les « carottes » qui encouragent l'honnêteté des validateurs. Un proposeur de bloc qui inclut une pénalité sera récompensé par le montant de `slashed_validators_effective_balance / 512`.
+Les proposeurs de blocs reçoivent `8 / 64 * base_reward` pour **chaque attestation valide** incluse dans le bloc, donc la valeur réelle de la récompense évolue avec le nombre de validateurs qui attestent. Les proposeurs de blocs peuvent également augmenter leur récompense en incluant des preuves de comportement malhonnête d'autres validateurs dans le bloc qu'ils proposent. Ces récompenses sont les « carottes » qui encouragent l'honnêteté des validateurs. Un proposeur de bloc qui inclut un délestage sera récompensé avec `slashed_validators_effective_balance / 512`.
 
 ### Pénalités {#penalties}
 
 Jusqu'à présent, nous avons pris en compte les validateurs qui agissent conformément aux règles, mais qu'en est-il des validateurs qui ne votent pas en temps voulu pour la tête, la source et la cible, ou qui le font lentement ?
 
-Les pénalités pour avoir manqué les votes de cible et de source sont égales aux récompenses que l'attestateur aurait reçues s'il les avait soumis. Cela signifie qu'au lieu d'avoir la récompense ajoutée à leur solde, ils voient une valeur égale retirée de leur solde. Il n'y a pas de pénalité pour avoir manqué le vote de tête (les votes de tête sont uniquement récompensés, jamais pénalisés). Aucune pénalité n'est associée au `inclusion_delay` - la récompense ne sera tout simplement pas ajoutée au solde du validateur. Il n'y a également aucune pénalité pour ne pas avoir réussi à proposer un bloc.
+Les pénalités pour avoir manqué les votes de cible et de source sont égales aux récompenses que l'attestateur aurait reçues s'il les avait soumis. Cela signifie qu'au lieu d'avoir la récompense ajoutée à leur solde, ils voient une valeur égale retirée de leur solde. Il n'y a pas de pénalité pour avoir manqué le vote de tête (c.-à-d. que les votes de tête sont seulement récompensés, jamais pénalisés). Aucune pénalité n'est associée au `inclusion_delay` : la récompense ne sera tout simplement pas ajoutée au solde du validateur. Il n'y a également aucune pénalité pour ne pas avoir réussi à proposer un bloc.
 
-Pour en savoir plus sur les récompenses et les pénalités, consultez les [spécifications de consensus](https://github.com/ethereum/consensus-specs/blob/master/specs/altair/beacon-chain.md). Les récompenses et les pénalités ont été ajustées lors de la mise à niveau Bellatrix - regardez Danny Ryan et Vitalik en discuter dans cette vidéo [Peep an EIP](https://www.youtube.com/watch?v=iaAEGs1DMgQ).
+En savoir plus sur les récompenses et les pénalités dans les [spécifications du consensus](https://github.com/ethereum/consensus-specs/blob/master/specs/altair/beacon-chain.md). Les récompenses et les pénalités ont été ajustées dans la mise à niveau Bellatrix : regardez Danny Ryan et Vitalik en discuter dans cette [vidéo Peep an EIP](https://www.youtube.com/watch?v=iaAEGs1DMgQ).
 
-## Sanction {#slashing}
+## Délestage {#slashing}
 
 Le « slashing » est une action plus sévère qui entraîne la suppression forcée d'un validateur du réseau et la perte associée de leur ether mis en jeu. Il existe trois façons dont un validateur peut être « slashé » (sanctionné), toutes impliquant la proposition ou l'attestation malhonnête de blocs :
 
@@ -70,20 +70,21 @@ Le « slashing » est une action plus sévère qui entraîne la suppression forc
 - En attestant un bloc qui « entoure » un autre bloc (modifiant effectivement l'historique)
 - En « votant double » en attestant deux candidats pour le même bloc
 
-Si ces actions sont détectées, le validateur est sanctionné. Cela signifie que 1/32 de leur ether mis en jeu (jusqu'à un maximum d'1 ether) est immédiatement brûlé, puis une période de suppression de 36 jours commence. Pendant cette période de suppression, la mise du validateur diminue progressivement. À mi-parcours (jour 18), une pénalité supplémentaire est appliquée, dont l'ampleur varie en fonction de l'ether mis en jeu total de tous les validateurs sanctionnés au cours des 36 jours précédant l'événement de « slash ». Cela signifie que lorsque davantage de validateurs sont sanctionnés, l'ampleur de la pénalité augmente. Le slash maximum est le solde effectif total de tous les validateurs slashés (c'est-à-dire que s'il y a beaucoup de validateurs slashés, ils pourraient perdre la totalité de leur mise). D'autre part, un seul événement de « slash » isolé ne brûle qu'une petite partie de la mise du validateur. Cette pénalité intermédiaire qui varie en fonction du nombre de validateurs sanctionnés est appelée « pénalité de corrélation ».
+Si ces actions sont détectées, le validateur est sanctionné. Cela signifie que 0,0078125 est immédiatement brûlé pour un validateur de 32 ETH (valeur ajustée de manière linéaire en fonction du solde actif), puis une période de retrait de 36 jours commence. Pendant cette période de suppression, la mise du validateur diminue progressivement. À mi-parcours (jour 18), une pénalité supplémentaire est appliquée, dont l'ampleur varie en fonction de l'ether mis en jeu total de tous les validateurs sanctionnés au cours des 36 jours précédant l'événement de « slash ». Cela signifie que lorsque davantage de validateurs sont sanctionnés, l'ampleur de la pénalité augmente. Le délestage maximum est le solde effectif total de tous les validateurs délestés (c.-à-d. que si de nombreux validateurs sont délestés, ils pourraient perdre la totalité de leur mise). D'autre part, un seul événement de « slash » isolé ne brûle qu'une petite partie de la mise du validateur. Cette pénalité intermédiaire qui varie en fonction du nombre de validateurs sanctionnés est appelée « pénalité de corrélation ».
 
-## Fuite d’inactivité {#inactivity-leak}
+## Fuite d'inactivité {#inactivity-leak}
 
 Si la couche de consensus a passé plus de quatre périodes sans se finaliser, un protocole d'urgence appelé « fuite d'inactivité » est activé. Le but ultime de la fuite d'inactivité est de créer les conditions nécessaires pour que la chaîne retrouve sa finalité. Comme expliqué précédemment, la finalité nécessite une majorité de 2/3 de l'ether mis en jeu total pour s'entendre sur les points de contrôle source et cible. Si les validateurs représentant plus d'1/3 du total des validateurs se déconnectent ou ne soumettent pas les attestations correctes, il n'est pas possible pour une supermajorité des 2/3 de finaliser les points de contrôle. La fuite d'inactivité permet à la mise participant aux validateurs inactifs de s'épuiser progressivement jusqu'à ce qu'ils contrôlent moins d'un tiers de la mise totale, permettant ainsi aux validateurs actifs restants de finaliser la chaîne. Cependant, quelle que soit la taille du groupe de validateurs inactifs, les validateurs actifs restants finiront par contrôler plus de 2/3 des ETH en jeu. La perte d'ETH est une forte incitation pour les validateurs inactifs à se réactiver dès que possible ! Un scénario de fuite d'inactivité a été rencontré sur le réseau de test Medalla lorsque moins de 66 % des validateurs actifs ont pu parvenir à un consensus sur la tête actuelle de la blockchain. La fuite d'inactivité a été activée et la finalité a finalement été retrouvée !
 
 La récompense, la pénalité et le mécanisme de sanction du mécanisme de consensus encouragent les validateurs individuels à se comporter correctement. Cependant, de ces choix de conception émerge un système qui encourage fortement une répartition égale des validateurs entre plusieurs clients, et devrait fortement décourager la domination d’un seul client.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Améliorer Ethereum : la couche d'incitations](https://eth2book.info/altair/part2/incentives)
-- [Incitations dans le protocole Casper hybride d'Ethereum](https://arxiv.org/pdf/1903.04205.pdf)
+- [Mettre à niveau Ethereum : la couche d'incitation](https://eth2book.info/altair/part2/incentives)
+- [Incitatifs dans le protocole hybride Casper d'Ethereum](https://arxiv.org/pdf/1903.04205.pdf)
 - [Spécifications annotées de Vitalik](https://github.com/ethereum/annotated-spec/blob/master/phase0/beacon-chain.md#rewards-and-penalties-1)
-- [Conseils de prévention de pénalité pour Eth2](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50)
+- [Conseils pour la prévention du délestage sur Eth2](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50)
+- [Analyse des pénalités de délestage dans le cadre de l'EIP-7251](https://ethresear.ch/t/slashing-penalty-analysis-eip-7251/16509)
 
 _Sources_
 
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md
index 4b0aced9a77..a6a07ad4b2c 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pos/weak-subjectivity/index.md
@@ -1,6 +1,6 @@
 ---
 title: Weak subjectivity
-description: Une explication de la « faible subjectivité » et de son rôle dans la PoS d'Ethereum.
+description: "Une explication de la « faible subjectivité » et de son rôle dans la PoS d'Ethereum."
 lang: fr
 ---
 
@@ -8,9 +8,9 @@ La subjectivité dans les blockchains se réfère au recours à l'information so
 
 ## Prérequis {#prerequisites}
 
-Pour comprendre cette page, il faut d'abord comprendre les fondamentaux de [la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/).
+Pour comprendre cette page, il faut d'abord comprendre les fondamentaux de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/).
 
-## Quels problèmes la faible subjectivité résout-elle ? {#problems-ws-solves}
+## Quels problèmes la faible subjectivité résout-elle ? Problèmes résolus par la faible subjectivité {#problems-ws-solves}
 
 La subjectivité est inhérente aux blockchains en preuve d'enjeu puisque la sélection de la bonne chaîne depuis plusieurs forks est réalisée par le comptage des votes historiques. Cela expose la blockchain à plusieurs vecteurs d'attaque, y compris les attaques de longue portée par lesquelles les nœuds qui ont participé très tôt à la chaîne maintiennent un fork alternatif qu'ils libèrent beaucoup plus tard à leur propre avantage. Alternativement, si 33 % des validateurs retirent leur mise mais continuent à attester et à produire des blocs, ils pourraient générer un fork alternatif qui entrerait en conflit avec la chaîne canonique. Les nouveaux nœuds ou ceux qui sont hors connexion depuis longtemps peuvent ne pas être avisés que ces validateurs hostiles ont retiré leurs fonds, afin que les attaquants puissent amener les nœuds à suivre une chaîne incorrecte. Ethereum peut parer à ces vecteurs d'attaque en imposant des contraintes qui réduisent au strict minimum les aspects subjectifs du mécanisme, et ainsi les hypothèses de confiance.
 
@@ -30,10 +30,10 @@ Un point de contrôle de la faible subjectivité peut même faire partie du logi
 
 Enfin, les points de contrôle peuvent être demandés à d'autres nœuds  ; il se peut qu'un autre utilisateur d'Ethereum qui exécute un nœud complet puisse fournir un point de contrôle que les validateurs peuvent ensuite vérifier par rapport aux données d'un explorateur de blocs. Globalement, faire confiance au fournisseur d'un point de contrôle de subjectivité faible peut être considéré comme aussi problématique que de faire confiance aux développeurs du client. La confiance globale requise est faible. Il est important de noter que ces considérations ne deviennent importantes que dans le cas très improbable où une majorité de validateurs conspirent pour produire une autre fourche de la blockchain. Dans toutes les autres circonstances, il n'y a qu'une seule chaîne Ethereum parmi laquelle choisir.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Faible subjectivité dans Eth2](https://notes.ethereum.org/@adiasg/weak-subjectvity-eth2)
-- [Vitalik : comment j'ai appris à aimer la faible subjectivité](https://blog.ethereum.org/2014/11/25/proof-stake-learned-love-weak-subjectivity)
-- [Faible subjectivité (Teku docs)](https://docs.teku.consensys.net/en/latest/Concepts/Weak-Subjectivity/)
-- [Guide de la faible subjectivité Phase-0](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/weak-subjectivity.md)
+- [La faible subjectivité dans Eth2](https://notes.ethereum.org/@adiasg/weak-subjectvity-eth2)
+- [Vitalik : Comment j'ai appris à aimer la faible subjectivité](https://blog.ethereum.org/2014/11/25/proof-stake-learned-love-weak-subjectivity/)
+- [Faible subjectivité (documentation Teku)](https://docs.teku.consensys.io/concepts/weak-subjectivity)
+- [Guide sur la faible subjectivité de la Phase 0](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/weak-subjectivity.md)
 - [Analyse de la faible subjectivité dans Ethereum 2.0](https://github.com/runtimeverification/beacon-chain-verification/blob/master/weak-subjectivity/weak-subjectivity-analysis.pdf)
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md
index d6741554b8f..9e7264b97db 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md
@@ -1,27 +1,27 @@
 ---
 title: Preuve de travail (PoW)
-description: Explication du protocole de consensus « preuve de travail » et de son rôle dans Ethereum.
+description: "Explication du protocole de consensus « preuve de travail » et de son rôle dans Ethereum."
 lang: fr
 ---
 
-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).
+Le réseau Ethereum a commencé par utiliser un mécanisme de consensus qui impliquait 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. Cependant, Ethereum a abandonné la preuve de travail en 2022 et a commencé à utiliser la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) à la place.
 
 <Alert variant="update">
 <AlertEmoji text=":wave:"/>
 <AlertContent>
 <AlertDescription>
-    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](/developers/docs/consensus-mechanisms/pos/) et le [staking](/staking/).
+    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. Read more on [proof-of-stake](/developers/docs/consensus-mechanisms/pos/) and [staking](/staking/).
 </AlertDescription>
 </AlertContent>
 </Alert>
 
 ## 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 [les mécanismes de consensus](/developers/docs/consensus-mechanisms/).
+Pour mieux comprendre cette page, nous vous recommandons d'abord d'en lire plus sur les transactions (/developers/docs/transactions/), les blocs (/developers/docs/blocks/), et les mécanismes de consensus (/developers/docs/consensus-mechanisms/).
 
 ## Qu'est ce que la preuve de travail (PoW) ? {#what-is-pow}
 
-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/).
+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 tous les nœuds s'accordent) sur des points tels 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 qui utilise 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}
 
@@ -34,8 +34,8 @@ La preuve de travail est l'algorithme sous-jacent qui définit la difficulté et
 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`).
+- mixHash – par exemple : `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`
+- nonce – par exemple : `0xd3ee432b4fb3d26b`
 
 Ces données de bloc étaient directement liées à la preuve de travail.
 
@@ -61,27 +61,27 @@ Pour créer de manière constante des blocs malveillants mais valides, un mineur
 
 La preuve de travail était également responsable de l'émission de nouvelles devises dans le système et encourageait les mineurs à y travailler.
 
-Depuis [la mise à jour Constantinople](/ethereum-forks/#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.
+Depuis la [mise à niveau Constantinople](/ethereum-forks/#constantinople), les mineurs qui réussissaient à créer un bloc étaient récompensés par deux ETH fraîchement frappé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}
+## Finalité {#finality}
 
 Une transaction était « finalisée » sur Ethereum lorsqu'elle faisait partie d'un bloc qui ne pouvait pas changer.
 
 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 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.
+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. Avec l'ancienne preuve de travail d'Ethereum, plus on minait de blocs par-dessus un bloc `N` spécifique, plus on pouvait être sûr que les transactions dans `N` étaient réussies et ne seraient pas annulées. 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}
+## Preuve de travail et consommation d'énergie {#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 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](https://digiconomist.net/) le 18 juillet 2022).
+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 [digiconomist](https://digiconomist.net/) le 18 juillet 2022).
 
 ## Avantages et inconvénients {#pros-and-cons}
 
-| Avantages                                                                                                                                                                                                                                                                                       | Inconvénients                                                                                                                                                       |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| La preuve de travail est neutre. Vous n'avez pas besoin d'ETH pour commencer et les récompenses de bloc vous permettent de passer de 0 ETH à un solde positif. Avec la [preuve d'enjeu (PoS)](/developers/docs/consensus-mechanisms/pos/) vous avez besoin de posséder de l'ETH pour commencer. | La preuve de travail consomme tellement d'énergie que c'est mauvais pour l'environnement.                                                                           |
-| La preuve de travail est un mécanisme de consensus éprouvé qui a permis de sécuriser et de décentraliser les Bitcoins et Ethereum depuis de nombreuses années.                                                                                                                                  | Si vous voulez miner, vous avez besoin de tels équipements spécialisés que l'investissement pour commencer est important.                                           |
-| Comparé à la preuve d'enjeu, elle est relativement facile à implémenter.                                                                                                                                                                                                                        | En raison des besoins de calcul croissants, les pools de minage pourraient potentiellement dominer le jeu, entraînant des risques de centralisation et de sécurité. |
+| Avantages                                                                                                                                                                                                                                                                                                                   | Inconvénients                                                                                                                                                                       |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| La preuve de travail est neutre. Vous n'avez pas besoin d'ETH pour commencer et les récompenses de bloc vous permettent de passer de 0 ETH à un solde positif. Avec la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/), vous avez besoin d'ETH pour commencer. | La preuve de travail consomme tellement d'énergie que c'est mauvais pour l'environnement.                                                                           |
+| La preuve de travail est un mécanisme de consensus éprouvé qui a permis de sécuriser et de décentraliser les Bitcoins et Ethereum depuis de nombreuses années.                                                                                                                                              | Si vous voulez miner, vous avez besoin de tels équipements spécialisés que l'investissement pour commencer est important.                                           |
+| Comparé à la preuve d'enjeu, elle est relativement facile à implémenter.                                                                                                                                                                                                                                    | En raison des besoins de calcul croissants, les pools de minage pourraient potentiellement dominer le jeu, entraînant des risques de centralisation et de sécurité. |
 
 ## Comparaison avec la preuve d'enjeu {#compared-to-pos}
 
@@ -94,14 +94,14 @@ Une critique majeure de la preuve de travail est la quantité d'énergie nécess
 
 [En savoir plus sur la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/)
 
-## En savoir plus via un apprenti visuel ? {#visual-learner}
+## Davantage qu'un apprenant visuel ? {#visual-learner}
 
 <YouTube id="3EUAcxhuoU4" />
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Attaque de la majorité](https://en.bitcoin.it/wiki/Majority_attack)
-- [A propos de l'accord de finalisation](https://blog.ethereum.org/2016/05/09/on-settlement-finality)
+- [Attaque majoritaire](https://en.bitcoin.it/wiki/Majority_attack)
+- [Sur la finalité du règlement](https://blog.ethereum.org/2016/05/09/on-settlement-finality/)
 
 ### Vidéos {#videos}
 
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md
index 83748b6953d..3e0c123f7dc 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md
@@ -1,6 +1,6 @@
 ---
-title: Minage
-description: Une explication de la façon dont le minage fonctionnait sur Ethereum.
+title: Le minage
+description: "Une explication de la façon dont le minage fonctionnait sur Ethereum."
 lang: fr
 ---
 
@@ -8,14 +8,14 @@ lang: fr
 <AlertEmoji text=":wave:"/>
 <AlertContent>
 <AlertDescription>
-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 <a href='/roadmap/merge/'>La Fusion</a>, <a href='/developers/docs/consensus-mechanisms/pos/'>la preuve d'enjeu</a> et <a href='/staking/'>la mise en jeu</a>. Cette page n'a qu'un intérêt historique.
+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 dès aujourd'hui. En savoir plus sur <a href='/roadmap/merge/'>La Fusion</a>, <a href='/developers/docs/consensus-mechanisms/pos/'>la preuve d'enjeu</a> et <a href='/staking/'>la mise en jeu</a>. Cette page n'a qu'un intérêt historique.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
 ## 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/).
+Pour mieux comprendre cette page, nous vous recommandons de vous informer au préalable sur 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}
 
@@ -44,30 +44,30 @@ Auparavant, n'importe qui pouvait miner sur le réseau Ethereum à l'aide de son
 
 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 étaient-elles minées ? {#how-ethereum-transactions-were-mined}
+## Comment les transactions Ethereum étaient 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).
+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. Vous trouverez une description analogue de ce processus pour la preuve d'enjeu d'Ethereum [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/).
+2. L'utilisateur diffuse la demande de transaction à l'ensemble du réseau Ethereum à partir d'un [nœud](/developers/docs/nodes-and-clients/).
 3. Dès qu'il a connaissance de la nouvelle demande de transaction, chaque nœud du réseau Ethereum l'ajoute à son « mempool », une zone d'attente de toutes les demandes de transaction dont il a connaissance et qui n'ont pas encore été engagées dans un bloc de la blockchain.
-4. À un moment donné, un nœud de minage regroupe plusieurs dizaines ou centaines de demandes de transaction dans un [bloc](/developers/docs/blocks/) potentiel, de façon à maximiser les [frais de transaction](/developers/docs/gas/) gagnés, tout en restant sous la limite de gaz du bloc. Dès lors, le nœud de minage :
-   1. Vérifie la validité de chaque demande de transaction (c'est-à-dire que personne n'essaie de transférer un ether depuis un compte pour lequel il n'a pas fourni de signature, que la demande n'est pas mal rédigée, etc.), puis exécute le code de la demande, modifiant l'état de sa copie locale de l'EVM, la machine virtuelle d'Ethereum. Le mineur attribue les frais de transaction pour chaque demande de transaction à son propre compte.
+4. À un moment donné, un nœud de minage regroupe plusieurs dizaines ou centaines de demandes de transaction en un [bloc](/developers/docs/blocks/) potentiel, de manière à maximiser les [frais de transaction](/developers/docs/gas/) qu'il perçoit, tout en restant sous la limite de gaz du bloc. Dès lors, le nœud de minage :
+   1. Vérifie la validité de chaque demande de transaction (c'est-à-dire que personne n'essaie de transférer de l'ether depuis un compte pour lequel il n'a pas produit de signature, que la demande n'est pas malformée, etc.), puis exécute le code de la demande, modifiant l'état de sa copie locale de l'EVM. Le mineur attribue les frais de transaction pour chaque demande de transaction à son propre compte.
    2. Commence le processus de production du « certificat de légitimité de preuve de travail » pour le bloc potentiel, une fois que toutes les demandes de transaction du bloc ont été vérifiées et exécutées sur la copie locale de l'EVM.
 5. Enfin, un mineur finira de produire un certificat pour un bloc qui inclut notre demande de transaction spécifique. Le mineur diffuse ensuite le bloc terminé qui comprend le certificat et la somme de contrôle du nouvel état de l'EVM.
 6. D'autres nœuds prennent connaissance du nouveau bloc. Ils vérifient le certificat, exécutent eux-mêmes toutes les transactions sur le bloc (y compris celle initialement diffusée par notre utilisateur), et vérifient que la somme de contrôle du nouvel état de leur EVM après exécution de toutes les transactions correspond à la somme de contrôle de l'état revendiqué par le bloc du mineur. Ce n'est qu'à ce moment-là que ces nœuds ajoutent ce bloc à la queue de leur blockchain, et acceptent le nouvel état de l'EVM comme étant conforme.
 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 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**.
+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. Cela met en évidence l'une des devises centrales de la blockchain : **Ne faites pas confiance, vérifiez**.
 
-## Blocs ommer (oncle) {#ommer-blocks}
+## 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) .
+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 décentralisation accrue du réseau, car les mineurs plus modestes, qui pouvaient être confrontés à une latence plus importante, pouvaient tout de même générer des revenus via les récompenses de bloc [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.
+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**, car un seul proposeur est élu à chaque créneau. Vous pouvez constater ce changement en consultant le [graphique historique](https://ycharts.com/indicators/ethereum_uncle_rate) des blocs ommer minés.
 
-## Démonstration visuelle {#a-visual-demo}
+## Une démo visuelle {#a-visual-demo}
 
 Regardez Austin vous guider à travers le minage et la blockchain de la preuve de travail.
 
@@ -75,9 +75,9 @@ Regardez Austin vous guider à travers le minage et la blockchain de la preuve d
 
 ## L'algorithme de minage {#mining-algorithm}
 
-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/). Ethash était le successeur d'un algorithme R&D originel connu sous le nom de [«Dagger-Hashimoto»](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/).
+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/). Ethash était le successeur d'un algorithme de R&D original connu sous le nom de ['Dagger-Hashimoto'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/).
 
-[Plus de détails sur les algorithmes de minage](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/).
+[En savoir plus sur les algorithmes de minage](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/).
 
 ## Sujets connexes {#related-topics}
 
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
index 5ca1eff5dec..50e60524ed8 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
@@ -1,29 +1,29 @@
 ---
 title: Dagger-Hashimoto
-description: Un regard détaillé sur l'algorithme 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](/roadmap/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.
+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é lors de [La Fusion](/roadmap/merge/) le 15 septembre 2022. Depuis lors, Ethereum est sécurisé par 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).
+Pour mieux comprendre cette page, nous vous recommandons de vous informer d'abord sur 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é.
+1. **Résistance aux ASIC** : l'avantage de la création de matériel spécialisé pour l'algorithme doit être aussi minime que possible.
+2. **Vérifiabilité par un client léger** : un bloc doit pouvoir être vérifié efficacement par un client léger.
 
 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).
+**Stockage de la chaîne complète** : le minage doit nécessiter le stockage de l'état complet de la blockchain (en raison de la structure irrégulière du trie d'état d'Ethereum, nous prévoyons qu'un certain élagage sera possible, en particulier pour certains contrats souvent utilisés, mais nous voulons minimiser cela).
 
-## Génération DAG {#dag-generation}
+## Génération du 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é :
+Le code de l'algorithme sera défini ci-dessous en Python. Tout d'abord, nous donnons `encode_int` pour la sérialisation d'entiers non signés de précision spécifiée en chaînes de caractères. L'inverse est également donné :
 
 ```python
 NUM_BITS = 512
@@ -45,7 +45,7 @@ def decode_int(s):
     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 :
+Nous supposons ensuite que `sha3` est une fonction qui prend un entier et renvoie un entier, et que `dbl_sha3` est une fonction double-sha3 ; si vous convertissez ce code de référence en une implémentation, utilisez :
 
 ```python
 from pyethereum import utils
@@ -82,9 +82,9 @@ params = {
 }
 ```
 
-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.
+`P` dans ce cas est un nombre premier choisi de telle sorte que `log₂(P)` soit juste légèrement inférieur à 512, ce qui correspond aux 512 bits que nous avons utilisés 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}
+### Construction du graphe Dagger {#dagger-graph-building}
 
 La construction graphique Dagger primitive est définie comme suit :
 
@@ -101,11 +101,11 @@ def produce_dag(params, seed, length):
     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.
+Essentiellement, il initialise un graphe comme un nœud unique, `sha3(seed)`, et à partir de là, commence à ajouter séquentiellement d'autres nœuds en se basant sur des nœuds précédents aléatoires. Lorsqu'un nouveau nœud est créé, une puissance modulaire de la graine est calculée pour sélectionner de manière aléatoire certains indices inférieurs à `i` (en utilisant `x % i` ci-dessus), et les valeurs des nœuds à ces indices sont utilisées dans un calcul pour générer une nouvelle valeur pour `x`, qui est ensuite transmise à une petite fonction de preuve de travail (basée sur XOR) pour finalement générer la valeur du graphe à 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}
+## Évaluation par le client léger {#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.
 
@@ -131,11 +131,11 @@ def quick_calc(params, seed, 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.
+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 est inutile, bien qu'une optimisation supplémentaire précalcule les quelques milliers de premières valeurs du DAG et les conserve comme un cache statique pour les calculs ; voir l'annexe pour une implémentation de code de ceci.
 
 ## 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.
+Dans un client complet, un [_double tampon_](https://wikipedia.org/wiki/Multiple_buffering) de 2 DAG produits par la formule ci-dessus est utilisé. L'idée est que les DAG sont produits tous les `epochtime` blocs, conformément aux 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 :
 
@@ -164,7 +164,7 @@ 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
+        # Aucun tampon arrière n'est possible, il suffit de créer un tampon avant
         return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz),
                           "block_number": 0}}
     else:
@@ -254,56 +254,52 @@ Notez également que Dagger-Hashimoto impose des exigences supplémentaires à l
 - 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}
+## En savoir plus {#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.
+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 donnons l'assurance que le générateur de nombres aléatoires (RNG) de Lehmer, qui est à la base de la variable `picker`, a une longue période. Deuxièmement, nous montrons que `pow(x,3,P)` ne fera pas correspondre `x` à `1` ou `P-1`, à condition que `x ∈ [2,P-2]` au départ. 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}
+### Générateur de nombres aléatoires de 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.
+Bien que la fonction `produce_dag` n'ait pas besoin de produire des nombres aléatoires non biaisés, une menace potentielle est que `seed**i % P` ne prenne qu'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 <pre>xᵐ mod P ≡ 1</pre>
-Compte tenu de ces définitions, nous avons :
+Pour éviter cela, un résultat de la théorie du nombre est exercé. Un [_nombre premier sûr_](https://en.wikipedia.org/wiki/Safe_prime) est défini comme un nombre premier `P` tel que `(P-1)/2` est aussi un nombre premier. L'_ordre_ d'un membre `x` du [groupe multiplicatif](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` est défini comme le `m` minimal tel que <pre>xᵐ mod P ≡ 1</pre>
+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`.
+> Observation 1. Soit `x` un membre du groupe multiplicatif `ℤ/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`.
+_Preuve_. Puisque `P` est un nombre premier sûr, alors d'après le [théorème de Lagrange][lagrange], nous avons que l'ordre de `x` est soit `1`, `2`, `(P-1)/2`, ou `P-1`.
 
-L'ordre de `x` ne peut pas être `1`, puisque suivant le petit théorème de Fermat, nous avons :
+L'ordre de `x` ne peut pas être `1`, car d'après le petit théorème de Fermat, nous avons :
 
 <pre>x<sup>P-1</sup> mod P ≡ 1</pre>
 
-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.
+Par conséquent, `x` doit être une identité multiplicative de `ℤ/nℤ`, qui est unique. Puisque nous avons supposé que `x ≠ 1`, ceci 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.
+L'ordre de `x` ne peut pas être `2` à moins que `x = P-1`, car cela violerait le fait que `P` est 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]`. Compte tenu de la magnitude de `P`, nous ne devrions jamais nous attendre à un cycle d'exponentiation modulaire.
+D'après la proposition ci-dessus, nous pouvons reconnaître que l'itération de `(picker * init) % P` aura une longueur de cycle d'au moins `(P-1)/2`. C'est parce que nous avons sélectionné `P` pour être un nombre premier sûr approximativement égal à une puissance supérieure de deux, et `init` se trouve dans l'intervalle `[2,2**256+1]`. Étant donné la magnitude de `P`, nous ne devrions jamais nous attendre à un cycle provenant de l'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 :
+Lorsque nous attribuons 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 avons l'assurance 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`
+> Observation 2. Soit `x` un membre du groupe multiplicatif `ℤ/Pℤ` pour un nombre premier sûr `P`, et soit `w` un nombre naturel. Si `x mod P ≠ 1 mod P` et `x mod P ≠ P-1 mod P`, ainsi que `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}
+### Exponentiation modulaire en tant que 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}`.
+Pour certaines valeurs de `P` et `w`, la fonction `pow(x, w, P)` peut avoir 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 :
+Étant donné que `P` est un nombre premier, un `w` approprié pour une fonction de hachage par 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ℤ` :
-> 
-> <center>
->   `aʷ mod P ≡ bʷ mod P` si et seulement si `a mod P ≡ b mod P`
-> </center>
+> Observation 3. Soit `P` un nombre premier ; `w` et `P-1` sont premiers entre eux si et seulement si pour tous les `a` et `b` dans `ℤ/Pℤ` :<center>`aʷ mod P ≡ bʷ mod P` si et seulement si `a mod P ≡ b mod P`</center>
 
-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.
+Ainsi, étant donné que `P` est un nombre premier et que `w` est premier avec `P-1`, nous avons `|{pow(x, w, P) : x ∈ ℤ}| = P`, ce qui implique que la fonction de hachage a le taux de collision le plus bas 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.
+Dans le cas particulier où `P` est un nombre premier sûr comme nous l'avons sélectionné, `P-1` n'a alors que les facteurs 1, 2, `(P-1)/2` et `P-1`. Puisque `P` > 7, nous savons que 3 est premier avec `P-1`, donc `w=3` satisfait la proposition ci-dessus.
 
-## Algorithme d'évaluation basé sur un cache plus efficace {#cache-based-evaluation}
+## Algorithme d'évaluation plus efficace basé sur le cache {#cache-based-evaluation}
 
 ```python
 def quick_calc(params, seed, p):
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
index 28ee02d5b6d..24711c66dd0 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
@@ -1,6 +1,6 @@
 ---
 title: Ethash
-description: Un aperçu en détail de l'algorithme Ethash.
+description: "Un aperçu en détail de l'algorithme Ethash."
 lang: fr
 ---
 
@@ -8,12 +8,12 @@ lang: fr
 <AlertEmoji text=":wave:"/>
 <AlertContent>
 <AlertDescription>
-   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](/developers/docs/consensus-mechanisms/pos/) à la place. En savoir plus sur [La Fusion](/roadmap/merge/), [la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/) et la [mise en jeu](/staking/). Cette page n'a qu'un intérêt historique !  
+   Ethash était l'algorithme de minage par preuve de travail d'Ethereum. La preuve de travail a maintenant été **entièrement désactivée** et Ethereum est désormais sécurisé par la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). En savoir plus sur [The Merge](/roadmap/merge/), [proof-of-stake](/developers/docs/consensus-mechanisms/pos/) et [staking](/staking/). Cette page n'a qu'un intérêt historique !
 </AlertDescription>
 </AlertContent>
 </Alert>
 
-Ethash est une version modifiée de l'algorithme [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/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.
+Ethash est une version modifiée de l'algorithme [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto). La preuve de travail Ethash est [à mémoire difficile](https://wikipedia.org/wiki/Memory-hard_function), ce qui était censé rendre l'algorithme résistant aux ASIC. 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}
 
@@ -22,8 +22,8 @@ La complexité de la mémoire est obtenue avec un algorithme de preuve de travai
 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.
+2. À partir de la graine, on peut calculer un **cache pseudo-alé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 de 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.
@@ -33,23 +33,23 @@ Le grand ensemble de données est mis à jour une fois tous les 30 000 blocs, de
 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
+WORD_BYTES = 4                    # octets dans un mot
+DATASET_BYTES_INIT = 2**30        # octets dans le jeu de données à la genèse
+DATASET_BYTES_GROWTH = 2**23      # croissance du jeu de données par époque
+CACHE_BYTES_INIT = 2**24          # octets dans le cache à la genèse
+CACHE_BYTES_GROWTH = 2**17        # croissance du cache par époque
+CACHE_MULTIPLIER=1024             # Taille du DAG par rapport au cache
+EPOCH_LENGTH = 30000              # blocs par époque
+MIX_BYTES = 128                   # largeur du mix
+HASH_BYTES = 64                   # longueur du hachage en octets
+DATASET_PARENTS = 256             # nombre de parents de chaque élément du jeu de données
+CACHE_ROUNDS = 3                  # nombre de tours dans la production du cache
+ACCESSES = 64                     # nombre d'accès dans la boucle hashimoto
 ```
 
 ### 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, par exemple [ici](https://eips.ethereum.org/EIPS/eip-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).
+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, par exemple, [ici](https://eips.ethereum.org/EIPS/eip-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.
 
@@ -75,7 +75,7 @@ def get_full_size(block_number):
 
 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}
+## Génération du cache {#cache-generation}
 
 Maintenant, nous spécifions la fonction pour produire un cache :
 
@@ -97,11 +97,11 @@ def mkcache(cache_size, seed):
     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.
+Le processus de production du cache implique d'abord de remplir séquentiellement 32 Mo de mémoire, puis d'effectuer deux passes de l'algorithme _RandMemoHash_ de Sergio Demian Lerner, tiré de [_Strict Memory Hard 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.
+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 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
@@ -140,27 +140,27 @@ def calc_dataset(full_size, cache):
 
 ## 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 :
+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é_, c'est-à-dire d'un en-tête excluant les champs **mixHash** et **nonce**. `nonce` représente les huit octets d'un entier non signé de 64 bits dans l'ordre big-endian. Ainsi, `nonce[::-1]` est la représentation little-endian sur huit octets 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
+    # combine l'en-tête et le nonce en une graine de 64 octets
     s = sha3_512(header + nonce[::-1])
-    # start the mix with replicated s
+    # initialise le mix avec s répliqué
     mix = []
     for _ in range(MIX_BYTES / HASH_BYTES):
         mix.extend(s)
-    # mix in random dataset nodes
+    # mélange avec des nœuds aléatoires du jeu de données
     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
+    # compresse le 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]))
@@ -176,9 +176,9 @@ 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.
+Essentiellement, nous maintenons un "mix" de 128 octets de large, et récupérons de manière répétée et séquentielle 128 octets du jeu de données complet pour les combiner avec le mix à l'aide de la fonction `fnv`. 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.
+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é effectuée ; cette vérification PoW externe rapide peut être utilisée à des fins d'anti-DDoS. Cela sert également à fournir une assurance statistique que le résultat est un nombre non biaisé de 256 bits.
 
 ## Minage {#mining}
 
@@ -186,7 +186,7 @@ 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
+    # remplissage par des zéros de la cible pour la comparer au hachage sur le même chiffre
     target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
     from random import randint
     nonce = randint(0, 2**64)
@@ -209,7 +209,7 @@ Afin de calculer le hachage de la graine qui serait utilisé pour miner au-dessu
 
 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}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
@@ -220,7 +220,7 @@ Le code suivant devrait être préfixé si vous souhaitez exécuter la spécific
 ```python
 import sha3, copy
 
-# Assumes little endian bit ordering (same as Intel architectures)
+# Suppose un ordre des bits little-endian (identique aux architectures Intel)
 def decode_int(s):
     return int(s[::-1].encode('hex'), 16) if s else 0
 
@@ -248,7 +248,7 @@ def serialize_cache(ds):
 
 serialize_dataset = serialize_cache
 
-# sha3 hash function, outputs 64 bytes
+# fonction de hachage sha3, génère 64 octets en sortie
 def sha3_512(x):
     return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x)
 
diff --git a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
index b6c616b3d17..1527d22792b 100644
--- a/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
+++ b/public/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
@@ -1,6 +1,6 @@
 ---
 title: Algorithmes de minage
-description: Un regard détaillé sur les algorithmes utilisés pour le minage Ethereum.
+description: "Un regard détaillé sur les algorithmes utilisés pour le minage Ethereum."
 lang: fr
 ---
 
@@ -8,7 +8,7 @@ lang: fr
 <AlertEmoji text=":wave:"/>
 <AlertContent>
 <AlertDescription>
-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 <a href='/roadmap/merge/'>La Fusion</a>, <a href='/developers/docs/consensus-mechanisms/pos/'>la preuve d'enjeu</a> et <a href='/staking/'>la mise en jeu</a>. Cette page n'a qu'un intérêt historique.
+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 dès aujourd'hui. En savoir plus sur <a href='/roadmap/merge/'>La Fusion</a>, <a href='/developers/docs/consensus-mechanisms/pos/'>la preuve d'enjeu</a> et <a href='/staking/'>la mise en jeu</a>. Cette page n'a qu'un intérêt historique.
 </AlertDescription>
 </AlertContent>
 </Alert>
@@ -17,26 +17,26 @@ Le minage Ethereum utilisait un algorithme connu sous le nom d'Ethash. L'idée f
 
 ## 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).
+Pour mieux comprendre cette page, nous vous recommandons de vous informer d'abord sur 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.
+[Dagger](http://www.hashcash.org/papers/dagger.html) implique la génération d'un [graphe orienté acyclique](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.
+[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) est un algorithme qui ajoute une résistance aux ASIC en étant lié aux E/S (c'est-à-dire que les lectures de mémoire sont le facteur limitant dans le 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.
+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 au Dagger original, l'ensemble 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/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 n'a toujours utilisé qu'Ethash, Dagger Hashimoto était une version R&D de l'algorithme de minage qui a été remplacé avant que le minage commence sur le réseau principal Ethereum.
+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 n'a jamais utilisé qu'Ethash. Dagger Hashimoto était une version R&D de l'algorithme de minage qui a été remplacée avant le début du minage sur le réseau principal Ethereum.
 
 [En savoir plus sur Ethash](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/dapps/index.md b/public/content/translations/fr/developers/docs/dapps/index.md
index 23c4e41f9c5..2a585d35349 100644
--- a/public/content/translations/fr/developers/docs/dapps/index.md
+++ b/public/content/translations/fr/developers/docs/dapps/index.md
@@ -1,91 +1,91 @@
 ---
-title: Introduction aux dApps
+title: "Introduction technique aux dApps (applications décentralisées)"
 description:
 lang: fr
 ---
 
-Une application décentralisée (dApp) est une application construite sur un réseau décentralisé qui combine un [contrat intelligent](/developers/docs/smart-contracts/) et une interface utilisateur en frontend. Notez que les contrats intelligents Ethereum sont accessibles et transparents, comme les API ouvertes, de sorte que votre dApp peut même inclure un contrat intelligent que quelqu'un d'autre a rédigé.
+Une application décentralisée (dapp) est une application construite sur un réseau décentralisé qui combine un [contrat intelligent](/developers/docs/smart-contracts/) et une interface utilisateur frontend. Notez que les contrats intelligents Ethereum sont accessibles et transparents, comme les API ouvertes, de sorte que votre dApp peut même inclure un contrat intelligent que quelqu'un d'autre a rédigé.
 
 ## Prérequis {#prerequisites}
 
-Avant d'en apprendre plus sur les dApps, vous devriez connaître les [bases de la blockchain](/developers/docs/intro-to-ethereum/) et vous informer sur le réseau Ethereum et la façon dont il est décentralisé.
+Avant d'en apprendre plus sur les dapps, vous devriez couvrir les [bases de la blockchain](/developers/docs/intro-to-ethereum/) et vous informer sur le réseau Ethereum et la façon dont il est décentralisé.
 
-## Définition d'une dApp {#definition-of-a-dapp}
+## Définition d'une dapp {#definition-of-a-dapp}
 
 Une dApp a son code backend qui s'exécute sur un réseau décentralisé P2P, contrairement aux applications traditionnelles, dont le code du backend est executé sur des serveurs centralisés.
 
-Une dApp peut comporter du code frontend et des interfaces utilisateur rédigées dans n'importe quelle langue (comme une application) qui peuvent passer des appels vers son backend. De plus, son frontend peut être hébergé sur un système de stockage décentralisé comme [IPFS](https://ipfs.io/).
+Une dApp peut comporter du code frontend et des interfaces utilisateur rédigées dans n'importe quelle langue (comme une application) qui peuvent passer des appels vers son backend. De plus, son frontend peut être hébergé sur un stockage décentralisé tel que [IPFS](https://ipfs.io/).
 
-- **Décentralisé** - les dApps fonctionnent sur Ethereum, une plateforme publique décentralisée ouverte où personne ni aucun groupe n'a le contrôle
-- **Déterministes** - les dApps exécutent la même fonction indépendamment de l'environnement où elles sont exécutées
-- **Turing terminé** - les dApps peuvent exécuter n'importe quelle action au regard des ressources requises
-- **Isolées** - les dApps s'exécutent dans un environnement virtuel connu sous le nom de Machine Virtuelle Ethereum (EVM en anglais) de sorte que si le contrat intelligent comporte un bogue, cela n'entravera pas le fonctionnement normal du réseau blockchain
+- **Décentralisé** - les dapps fonctionnent sur Ethereum, une plateforme publique, ouverte et décentralisée où aucune personne ou aucun groupe n'a le contrôle
+- **Déterministe** - les dapps exécutent la même fonction quel que soit l'environnement dans lequel elles sont exécutées
+- **Turing-complet** - les dapps peuvent exécuter n'importe quelle action à condition de disposer des ressources nécessaires
+- **Isolé** - les dapps sont exécutées dans un environnement virtuel connu sous le nom de machine virtuelle Ethereum (EVM), de sorte que si le contrat intelligent contient un bogue, il n'entravera pas le fonctionnement normal du réseau blockchain
 
-### À propos des contrats intelligents {#on-smart-contracts}
+### Sur les contrats intelligents {#on-smart-contracts}
 
-Pour présenter les dApps, nous devons tout d'abord présenter les contrats intelligents (qui sont des dApps du backend, à défaut d'un meilleur terme). Pour une vue d'ensemble détaillée, rendez-vous dans notre section sur [Contrats intelligents](/developers/docs/smart-contracts/).
+Pour présenter les dApps, nous devons tout d'abord présenter les contrats intelligents (qui sont des dApps du backend, à défaut d'un meilleur terme). Pour un aperçu détaillé, consultez notre section sur les [contrats intelligents](/developers/docs/smart-contracts/).
 
 Un contrat intelligent est un code présent sur la blockchain Ethereum qui fonctionne exactement comme programmé. Une fois les contrats intelligents déployés sur le réseau, vous ne pouvez pas les modifier. Les dApps peuvent être décentralisées car elles sont contrôlées par la logique rédigée dans le contrat, pas par un individu ni une entreprise. Cela signifie que vous devez concevoir vos contrats très soigneusement et les tester de façon approfondie.
 
-## Avantages du développement de dApps {#benefits-of-dapp-development}
+## Avantages du développement de dapps {#benefits-of-dapp-development}
 
-- **Zéro temps d'arrêt** : une fois que le contrat intelligent au cœur d'une application est déployé et présent sur la blockchain, le réseau dans son ensemble sera toujours en mesure de servir les clients qui cherchent à interagir avec le contrat. Les acteurs malveillants ne peuvent donc pas lancer d'attaques par déni de service ciblées sur les dApps.
-- **Confidentialité** : vous n'avez pas à fournir une identité réelle pour déployer ou interagir avec une dApp.
-- **Résistance à la censure** : aucune entité du réseau ne peut empêcher les utilisateurs de soumettre des transactions, de déployer des dApps ou de lire des données de la blockchain.
-- **Intégrité complète des données** : grâce à des procédés cryptographiques appelés « primitives cryptographiques », les données stockées sur la blockchain sont immuables et indiscutables. Les acteurs malveillants ne peuvent pas falsifier des transactions ni d'autres données qui ont déjà été rendues publiques.
-- **Calcul trustless/comportement vérifiable** : les contrats intelligents peuvent être analysés et offrent la garantie d'une exécution prévisible sans avoir besoin de faire confiance à une autorité centrale. Ce n'est pas le cas dans les modèles financiers traditionnels. Par exemple, lorsque nous utilisons des systèmes bancaires en ligne, nous devons avoir confiance dans le fait que les institutions financières n'utiliseront pas nos données financières à mauvais escient, ne falsifieront pas les documents et ne seront pas piratées.
+- **Aucune interruption de service** – Une fois que le contrat intelligent est déployé sur la blockchain, le réseau dans son ensemble sera toujours en mesure de servir les clients qui cherchent à interagir avec le contrat. Les acteurs malveillants ne peuvent donc pas lancer d'attaques par déni de service ciblées sur les dApps.
+- **Confidentialité** – Vous n'avez pas besoin de fournir une identité du monde réel pour déployer une dapp ou interagir avec elle.
+- **Résistance à la censure** – Aucune entité unique sur le réseau ne peut empêcher les utilisateurs de soumettre des transactions, de déployer des dapps ou de lire des données de la blockchain.
+- **Intégrité totale des données** – Les données stockées sur la blockchain sont immuables et indiscutables, grâce aux primitives cryptographiques. Les acteurs malveillants ne peuvent pas falsifier des transactions ni d'autres données qui ont déjà été rendues publiques.
+- **Calcul sans confiance/comportement vérifiable** – Les contrats intelligents peuvent être analysés et leur exécution est garantie de manière prévisible, sans qu'il soit nécessaire de faire confiance à une autorité centrale. Ce n'est pas le cas dans les modèles financiers traditionnels. Par exemple, lorsque nous utilisons des systèmes bancaires en ligne, nous devons avoir confiance dans le fait que les institutions financières n'utiliseront pas nos données financières à mauvais escient, ne falsifieront pas les documents et ne seront pas piratées.
 
-## Inconvénients du développement de dApps {#drawbacks-of-dapp-development}
+## Inconvénients du développement de dapps {#drawbacks-of-dapp-development}
 
-- **Maintenance** : Les dApps peuvent être plus difficiles à maintenir car les données et le code publiés sur la blockchain sont plus difficiles à modifier. Il est difficile pour les développeurs de mettre à jour leurs dApps (ou les données sous-jacentes stockées par une dApp) une fois celles-ci déployées , même si des bogues ou des risques de sécurité ont été identifiés dans une version antérieure.
-- **Impacts sur la performance** : Il y a d'énormes impacts sur la performance et l'évolutivité est vraiment difficile. Pour atteindre le niveau de sécurité, d'intégrité, de transparence et de fiabilité auquel Ethereum aspire, chaque nœud exécute et stocke chaque transactions. En plus de cela, il faut du temps pour parvenir à un consensus par preuve d'enjeu.
-- **Congestion du réseau** : dans le modèle actuel, si une dApp utilise trop de ressources de calcul, l'ensemble du réseau est sauvegardé. Actuellement, le réseau ne peut traiter qu'une dizaine de transactions par seconde. Si les transactions sont envoyées plus rapidement que cela, le groupe de transactions non confirmées peut rapidement augmenter.
-- **Expérience utilisateur** : il pourrait s'avérer plus difficile de concevoir des expériences conviviales. L'utilisateur moyen pourrait trouver trop difficile de mettre en place la pile d'outils nécessaire pour interagir avec la blockchain de façon réellement sécurisée.
-- **Centralisation** : des solutions conviviales pour les utilisateurs et les développeurs basées sur la couche de base d'Ethereum pourraient ressembler à des services centralisés de toute façon. Par exemple, de tels services peuvent stocker des clés ou d'autres informations sensibles côté serveur, servir un frontend en utilisant un serveur centralisé ou exécutez une logique commerciale importante sur un serveur centralisé avant d'écrire dans la blockchain. La centralisation élimine de nombreux avantages de la blockchain (voir tous) par rapport au modèle traditionnel.
+- **Maintenance** – Les dapps peuvent être plus difficiles à maintenir, car le code et les données publiés sur la blockchain sont plus difficiles à modifier. Il est difficile pour les développeurs de mettre à jour leurs dApps (ou les données sous-jacentes stockées par une dApp) une fois celles-ci déployées , même si des bogues ou des risques de sécurité ont été identifiés dans une version antérieure.
+- **Surcharge de performance** – Il y a une énorme surcharge de performance, et la mise à l'échelle est très difficile. Pour atteindre le niveau de sécurité, d'intégrité, de transparence et de fiabilité auquel Ethereum aspire, chaque nœud exécute et stocke chaque transactions. En plus de cela, il faut du temps pour parvenir à un consensus par preuve d'enjeu.
+- **Congestion du réseau** – Lorsqu'une dapp utilise trop de ressources de calcul, l'ensemble du réseau est engorgé. Actuellement, le réseau ne peut traiter qu'une dizaine de transactions par seconde. Si les transactions sont envoyées plus rapidement que cela, le groupe de transactions non confirmées peut rapidement augmenter.
+- **Expérience utilisateur** – Il peut être plus difficile de concevoir des expériences conviviales, car l'utilisateur final moyen pourrait trouver trop difficile de mettre en place la pile d'outils nécessaire pour interagir avec la blockchain d'une manière vraiment sécurisée.
+- **Centralisation** – Les solutions conviviales pour les utilisateurs et les développeurs, construites sur la couche de base d'Ethereum, pourraient de toute façon finir par ressembler à des services centralisés. Par exemple, de tels services peuvent stocker des clés ou d'autres informations sensibles côté serveur, servir un frontend en utilisant un serveur centralisé ou exécutez une logique commerciale importante sur un serveur centralisé avant d'écrire dans la blockchain. La centralisation élimine de nombreux avantages de la blockchain (voir tous) par rapport au modèle traditionnel.
 
-## En savoir plus via un apprenti visuel ? {#visual-learner}
+## Davantage qu'un apprenant visuel ? {#visual-learner}
 
 <YouTube id="F50OrwV6Uk8" />
 
-## Outils pour créer des dApps {#dapp-tools}
+## Outils pour créer des dapps {#dapp-tools}
 
 **Scaffold-ETH _- Expérimentez rapidement avec Solidity en utilisant un frontend qui s'adapte à votre contrat intelligent._**
 
 - [GitHub](https://github.com/scaffold-eth/scaffold-eth-2)
-- [Exemple dApp](https://punkwallet.io/)
+- [Exemple de dapp](https://punkwallet.io/)
 
-**Créez une App Eth _- Créez des applications sous Ethereum en une seule commande._**
+**Create Eth App _- Créez des applications alimentées par Ethereum avec une seule commande._**
 
 - [GitHub](https://github.com/paulrberg/create-eth-app)
 
-**One Click Dapp _- outil FOSS pour générer des interfaces dapp en frontend à partir d'une [ABI](/glossary/#abi)._**
+**One Click Dapp _- Outil FOSS pour générer des frontends de dapp à partir d'une [ABI](/glossary/#abi)._**
 
 - [oneclickdapp.com](https://oneclickdapp.com)
 - [GitHub](https://github.com/oneclickdapp/oneclickdapp-v1)
 
-**Etherflow _- Outil FOSS permettant aux développeurs Ethereum de tester leur nœud, et de composer et déboguer les appels RPC du navigateur._**
+**Etherflow _- Outil FOSS pour les développeurs Ethereum pour tester leur nœud, et composer et déboguer les appels RPC depuis le navigateur._**
 
 - [etherflow.quiknode.io](https://etherflow.quiknode.io/)
 - [GitHub](https://github.com/abunsen/etherflow)
 
-**thirdweb _- SDKs dans tous les langages, smart contrats, outils et infrastructure pour le développement web3._**
+**thirdweb _- Des SDK dans tous les langages, des contrats intelligents, des outils et une infrastructure pour le développement web3._**
 
 - [Page d'accueil](https://thirdweb.com/)
 - [Documentation](https://portal.thirdweb.com/)
 - [GitHub](https://github.com/thirdweb-dev/)
 
-**Crossmint - _ Plateforme de développement web3 de niveau entreprise pour déployer des contrats intelligents, permettre les paiements par carte de crédit et inter-chaîne, et utiliser des API pour créer, distribuer, vendre, stocker et modifier des NFT_**
+**Crossmint _- Plateforme de développement web3 de niveau entreprise pour déployer des contrats intelligents, permettre les paiements par carte de crédit et inter-chaînes, et utiliser des API pour créer, distribuer, vendre, stocker et modifier des NFT._**
 
 - [crossmint.com](https://www.crossmint.com)
 - [Documentation](https://docs.crossmint.com)
 - [Discord](https://discord.com/invite/crossmint)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Explorez des applications décentralisées](/apps)
-- [L'Architecture d'une application Web 3.0](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
-- [Le guide 2021 pour les applications décentralisées](https://limechain.tech/blog/what-are-dapps-the-2021-guide/) - _LimeChain_
-- [Qu'est-ce que les applications décentralisées ?](https://www.gemini.com/cryptopedia/decentralized-applications-defi-dapps) - _Gemini_
+- [Explorer les dapps](/apps)
+- [L'architecture d'une application Web 3.0](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
+- [Un guide 2021 des applications décentralisées](https://limechain.tech/blog/what-are-dapps-the-2021-guide/) - _LimeChain_
+- [Que sont les applications décentralisées ?](https://www.gemini.com/cryptopedia/decentralized-applications-defi-dapps) - _Gemini_
 - [Dapps populaires](https://www.alchemy.com/dapps) - _Alchemy_
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md b/public/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md
index 126e37bd633..ef390998e20 100644
--- a/public/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md
+++ b/public/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md
@@ -1,6 +1,6 @@
 ---
-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.
+title: Explorateurs de bloc
+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
 ---
@@ -9,23 +9,21 @@ Les explorateurs de blocs sont votre portail vers les données Ethereum. Vous po
 
 ## Prérequis {#prerequisites}
 
-Pour que les données fournies par un explorateur de blocs aient du sens, vous devez avoir compris les concepts de base d'Ethereum. Commencez par lire la page [Introduction à Ethereum](/developers/docs/intro-to-ethereum/).
+Pour que les données fournies par un explorateur de blocs aient du sens, vous devez avoir compris les concepts de base d'Ethereum. Commencez par [une introduction à Ethereum](/developers/docs/intro-to-ethereum/).
 
 ## Services {#services}
 
-- [Etherscan](https://etherscan.io/) - _Également disponible en chinois, coréen, russe et japonais_
+- [Etherscan](https://etherscan.io/) -_Également disponible en chinois, coréen, russe et japonais_
 - [3xpl](https://3xpl.com/ethereum)
 - [Beaconcha.in](https://beaconcha.in/)
-- [Blockchair](https://blockchair.com/ethereum) - _Également disponible en espagnol, français, italien, néerlandais, portugais, russe, chinois et Farsi_
+- [Blockchair](https://blockchair.com/ethereum) -_Également disponible en espagnol, français, italien, néerlandais, portugais, russe, chinois et farsi_
 - [Blockscout](https://eth.blockscout.com/)
 - [Chainlens](https://www.chainlens.com/)
-- [Explorateurs de bloc DexGuru](https://ethereum.dex.guru/)
+- [Explorateur de blocs DexGuru](https://ethereum.dex.guru/)
 - [Etherchain](https://www.etherchain.org/)
-- [Ethernow](https://www.ethernow.xyz/)
-- [Ethplorer](https://ethplorer.io/) - _Aussi disponible en chinois, espagnol, français, turc, russe, coréen et vietnamien_
+- [Ethplorer](https://ethplorer.io/) -_Également disponible en chinois, espagnol, français, turc, russe, coréen et vietnamien_
 - [EthVM](https://www.ethvm.com/)
 - [OKLink](https://www.oklink.com/eth)
-- [Rantom](https://rantom.app/)
 - [Ethseer](https://ethseer.io)
 
 ## Outils open source {#open-source-tools}
@@ -95,7 +93,7 @@ De plus en plus d'utilisateurs tirent parti des explorateurs de blocs pour suivr
 - 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
+- Nonce - Le numéro de transaction pour l'adresse `from` (n'oubliez pas que la numérotation commence à 0 et qu'un nonce de `100` serait donc 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}
@@ -145,7 +143,7 @@ Certaines données de bloc sont préoccupées par la santé d'Ethereum de maniè
 - 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}
+## Données de la couche de consensus {#consensus-layer-data}
 
 ### Période {#epoch}
 
@@ -238,16 +236,12 @@ Les données de couches de consensus de haut niveau comprennent les éléments s
 
 ## Explorateurs de blocs {#block-explorers}
 
-- [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
-- [Etherscan Sepolia](https://sepolia.etherscan.io/) - un explorateur de blocs que vous pouvez utiliser pour récupérer des données pour le réseau de test Sepolia
-- [Etherscan Hoodi](https://hoodi.etherscan.io/) - un explorateur de blocs que vous pouvez utiliser pour récupérer des données pour le réseau de test Hoodi
-- [3xpl](https://3xpl.com/ethereum) - un explorateur Ethereum open source sans publicité qui permet de télécharger ses ensembles de données
-- [Beaconcha.in](https://beaconcha.in/) - un explorateur de blocs open source pour le réseau principal Ethereum
-- [Blockchair](https://blockchair.com/ethereum) - l'explorateur Ethereum le plus privé. Également pour le tri et le filtrage des données (mempool)
+- [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 les réseaux de test
+- [3xpl](https://3xpl.com/ethereum) - un explorateur Ethereum open source et sans publicité qui permet de télécharger ses ensembles de données
+- [Beaconcha.in](https://beaconcha.in/) - un explorateur de blocs open source pour le réseau principal Ethereum et les réseaux de test
+- [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 axé sur les jetons pour le réseau principal Ethereum et le réseau de test Kovan
-- [Rantom](https://rantom.app/) - Un visualiseur de transactions DeFi et NFT open source convivial pour des informations détaillées
-- [Ethernow](https://www.ethernow.xyz/) - un explorateur de transactions en temps réel qui vous permet de voir la couche pré-chaîne du réseau principal Ethereum
 
 ## En savoir plus {#further-reading}
 
diff --git a/public/content/translations/fr/developers/docs/data-and-analytics/index.md b/public/content/translations/fr/developers/docs/data-and-analytics/index.md
index 0cf2e892bdc..e572823085b 100644
--- a/public/content/translations/fr/developers/docs/data-and-analytics/index.md
+++ b/public/content/translations/fr/developers/docs/data-and-analytics/index.md
@@ -1,6 +1,6 @@
 ---
-title: Données et analyses
-description: Comment obtenir des analyses et des données en chaîne utiles pour vos dApps
+title: "Données et analyses"
+description: "Comment obtenir des analyses et des données en chaîne utiles pour vos dApps"
 lang: fr
 ---
 
@@ -10,46 +10,63 @@ lang: fr
 
 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}
+## 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'[indice](/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 blocs](/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.
 
-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.
+En termes de fondamentaux architecturaux, comprendre ce qu'est une [API](https://www.wikipedia.org/wiki/API) et [REST](https://www.wikipedia.org/wiki/Representational_state_transfer), même en théorie.
 
-## Explorateurs de bloc {#block-explorers}
+## Explorateurs de blocs {#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 validateurs, les comptes et autres activités sur la chaîne.
+De nombreux [explorateurs de blocs](/developers/docs/data-and-analytics/block-explorers/) proposent des passerelles [API](https://www.wikipedia.org/wiki/API) [RESTful](https://www.wikipedia.org/wiki/Representational_state_transfer) qui offrent aux développeurs une visibilité sur les données en temps réel des blocs, des transactions, des validateurs, des comptes et d'autres activités en chaîne.
 
-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.
+Les développeurs peuvent ensuite traiter et transformer ces données pour offrir à leurs utilisateurs des informations uniques et des interactions avec la [blockchain](/glossary/#blockchain). Par exemple, [Etherscan](https://etherscan.io) et [Blockscout](https://eth.blockscout.com) fournissent des données d'exécution et de consensus pour chaque créneau de 12 s.
 
-## Le réseau Graph {#the-graph}
+## The 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 chaîne, avec The Graph, les développeurs peuvent construire des applications sans serveur qui fonctionnent entièrement sur une infrastructure publique.
+[The Graph](https://thegraph.com/) est un protocole d'indexation qui offre un moyen simple d'interroger les données de la blockchain via des API ouvertes appelées sous-graphes.
 
-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.
+Avec The Graph, les développeurs peuvent bénéficier de :
 
-## Diversité des clients
+- Indexation décentralisée : Permet d’indexer les données de la blockchain via plusieurs indexeurs, éliminant ainsi tout point de défaillance unique
+- Requêtes GraphQL : Offre une interface GraphQL puissante pour interroger des données indexées, ce qui rend la récupération des données très simple
+- Personnalisation : Définissez votre propre logique pour transformer et stocker les données de la blockchain, et réutilisez les sous-graphes publiés par d'autres développeurs sur The Graph Network.
 
-[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 existe désormais plusieurs tableaux de bord sur la diversité des clients, notamment [clientdiversity.org](https://clientdiversity.org/), [rated.network](https://www.rated.network), [supermajority.info](https://supermajority.info//) and [Ethernodes](https://ethernodes.org/).
+Suivez ce guide de [démarrage rapide](https://thegraph.com/docs/en/quick-start/) pour créer, déployer et interroger un sous-graphe en moins de 5 minutes.
+
+## Diversité des clients {#client-diversity}
+
+[La diversité des clients](/developers/docs/nodes-and-clients/client-diversity/) est importante pour la santé globale du réseau Ethereum, car elle offre une résilience face aux bogues et aux exploits. Il existe maintenant plusieurs tableaux de bord sur la diversité des clients, notamment [clientdiversity.org](https://clientdiversity.org/), [rated.network](https://www.rated.network), [supermajority.info](https://supermajority.info//) et [Ethernodes](https://ethernodes.org/).
 
 ## Dune Analytics {#dune-analytics}
 
-[Dune Analytics](https://dune.com/) prétraite les données de la blockchain en tables de base de données relationnelles (DuneSQL), 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.
+[Dune Analytics](https://dune.com/) prétraite les données de la blockchain en tables de base de données relationnelles (DuneSQL), 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 en chaîne sont organisées en 4 tables brutes : `blocks`, `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.
+
+## SQD {#sqd}
 
-## Réseau SubQuery {#subquery-network}
+[SQD](https://sqd.dev/) est une plateforme de données décentralisée, hyper-scalable, optimisée pour offrir un accès efficace et sans permission à de grands volumes de données. Il fournit actuellement des données historiques on-chain, y compris les journaux d’événements, les reçus de transaction, les traces et les différences d’état par transaction. SQD offre un ensemble d’outils puissants pour créer des pipelines personnalisés d’extraction et de traitement des données, atteignant une vitesse d’indexation allant jusqu’à 150k blocs par seconde.
+
+Pour commencer, consultez la [documentation](https://docs.sqd.dev/) ou regardez des [exemples EVM](https://github.com/subsquid-labs/squid-evm-examples) de ce que vous pouvez construire avec SQD.
+
+## SubQuery Network {#subquery-network}
 
 [SubQuery](https://subquery.network/) est un indexeur de données de premier plan qui offre aux développeurs des API rapides, fiables, décentralisées et personnalisées pour leurs projets web3. Suber permet aux développeurs de plus de 165+ écosystèmes (y compris Ethereum) de disposer de riches données indexées pour construire des expériences intuitives et immersives pour leurs utilisateurs. Le réseau SubQuery alimente votre application inarrêtable avec un réseau d'infrastructures résiliant et décentralisé. Utilisez la boite à outils de développeur blockchain de SubQuery pour construire les applications Web3 du futur, sans passer de temps à concevoir un backend personnalisé pour les activités de traitement de données.
 
-Pour commencer, consultez le [guide de démarrage rapide Ethereum](https://academy.subquery.network/quickstart/quickstart_chains/ethereum-gravatar.html) pour commencer à indexer les données de la blockchain Ethereum en quelques minutes dans un environnement Docker local à des fins de test avant de mettre en ligne sur un [service géré de SubQuery](https://managedservice.subquery.network/) ou sur le [réseau décentralisé de SubQuery](https://app.subquery.network/dashboard).
+Pour commencer, consultez le [guide de démarrage rapide d'Ethereum](https://academy.subquery.network/quickstart/quickstart_chains/ethereum-gravatar.html) pour commencer à indexer les données de la blockchain Ethereum en quelques minutes dans un environnement Docker local à des fins de test avant la mise en service sur le [service géré de SubQuery](https://managedservice.subquery.network/) ou sur le [réseau décentralisé de SubQuery](https://app.subquery.network/dashboard).
+
+## Langage de requête EVM {#evm-query-language}
 
-## Ethernow - Le programme de données de la mempool {#ethernow}
-[Blocknative](https://www.blocknative.com/) offre un accès ouvert à son [archive de données historique de la mempool](https://www.ethernow.xyz/mempool-data-archive) Ethereum. Cela permet aux chercheurs et aux bons projets communautaires d'explorer la couche pré-chaîne du réseau principal Ethereum. L'ensemble de données est activement maintenu et constitue l'enregistrement historique le plus complet des événements de transaction de la mempool au sein de l'écosystème Ethereum. En savoir plus sur [Ethernow](https://www.ethernow.xyz/).
+Le langage de requête EVM (EQL) est un langage similaire au SQL, conçu pour interroger les chaînes compatibles avec la machine virtuelle Ethereum (EVM). L’objectif principal d’EQL est de prendre en charge des requêtes relationnelles complexes sur les entités principales des chaînes EVM (blocs, comptes et transactions), tout en offrant aux développeurs et chercheurs une syntaxe ergonomique pour une utilisation quotidienne. Avec EQL, les développeurs peuvent récupérer des données de la blockchain en utilisant une syntaxe familière proche du SQL, ce qui leur permet d’éliminer le besoin de code standard complexe. EQL prend en charge les requêtes standards de données blockchain (par exemple, récupérer le nonce et le solde d’un compte sur Ethereum, ou obtenir la taille et l’horodatage du bloc actuel) et ajoute en permanence la prise en charge de requêtes plus complexes et de nouvelles fonctionnalités.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Présentation du réseau Graph](https://thegraph.com/docs/en/about/)
-- [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)
-- [Guide de démarrage rapide de SubQuery Ethereum](https://academy.subquery.network/indexer/quickstart/quickstart_chains/ethereum-gravatar.html)
+- [Exploration des données cryptographiques I : Architectures de flux de données](https://web.archive.org/web/20250125012042/https://research.2077.xyz/exploring-crypto-data-1-data-flow-architectures)
+- [Aperçu du réseau Graph](https://thegraph.com/docs/en/about/)
+- [Playground de requêtes Graph](https://thegraph.com/explorer/subgraph/graphprotocol/graph-network-mainnet?version=current)
+- [Exemples de code d'API sur Etherscan](https://etherscan.io/apis#contracts)
+- [Documentation de l'API sur Blockscout](https://docs.blockscout.com/devs/apis)
+- [Explorateur de la Chaîne phare Beaconcha.in](https://beaconcha.in)
+- [Les bases de Dune](https://docs.dune.com/#dune-basics)
+- [Guide de démarrage rapide SubQuery pour Ethereum](https://academy.subquery.network/indexer/quickstart/quickstart_chains/ethereum-gravatar.html)
+- [Aperçu du réseau SQD](https://docs.sqd.dev/)
+- [Langage de requête EVM](https://eql.sh/blog/alpha-release-notes)
diff --git a/public/content/translations/fr/developers/docs/data-availability/blockchain-data-storage-strategies/index.md b/public/content/translations/fr/developers/docs/data-availability/blockchain-data-storage-strategies/index.md
index 361904fc8e0..7f4084e5d62 100644
--- a/public/content/translations/fr/developers/docs/data-availability/blockchain-data-storage-strategies/index.md
+++ b/public/content/translations/fr/developers/docs/data-availability/blockchain-data-storage-strategies/index.md
@@ -1,6 +1,6 @@
 ---
-title: Stratégies de stockage des données de la Blockchain
-description: Il existe plusieurs façons de stocker des données en utilisant la blockchain. Cet article comparera les différentes stratégies, leurs coûts et avantages, ainsi que les conditions requises pour les utiliser en toute sécurité.
+title: "Stratégies de stockage des données de la Blockchain"
+description: "Il existe plusieurs façons de stocker des données en utilisant la blockchain. Cet article comparera les différentes stratégies, leurs coûts et avantages, ainsi que les conditions requises pour les utiliser en toute sécurité."
 lang: fr
 ---
 
@@ -10,13 +10,13 @@ Il existe de multiples façons de stocker des informations, soit directement sur
 - Données d'appel
 - Hors chaîne avec des mécanismes de couche de niveau 1
 - "Code" de contrat
-- Évènements
+- Événements
 - Stockage EVM
 
 Le choix de la méthode à utiliser repose sur plusieurs critères :
 
 - La source de l'information. Les informations dans calldata ne peuvent pas provenir directement de la blockchain elle-même.
-- La destination de l'information. Le calldata n'est disponible que dans la transaction qu'il initie. Les événements ne sont pas accessibles sur la chaine.
+- La destination de l'information. Le calldata n'est disponible que dans la transaction qui l'inclut. Les événements ne sont pas accessibles sur la chaine.
 - Quel niveau de complexité est acceptable ? Les ordinateurs qui exécutent un nœud complet peuvent effectuer plus de traitement qu'un client léger dans une application fonctionnant dans un navigateur.
 - Est-il nécessaire de faciliter l'accès aux informations depuis chaque nœud ?
 - Les exigences en matière de sécurité.
@@ -27,7 +27,7 @@ En général, la sécurité de l'information se compose de trois attributs :
 
 - _Confidentialité_, les entités non autorisées n'ont pas le droit de lire les informations. Cela est important dans de nombreux cas, mais pas ici. _Il n'y a pas de secret sur la blockchain_. Les blockchains fonctionnent parce que n'importe qui peut vérifier les transitions d'état, de sorte qu'il est impossible de les utiliser pour stocker directement des secrets. Il existe des moyens de stocker des informations confidentielles sur la blockchain, mais ils reposent tous sur un composant hors blockchain pour stocker au moins une clé.
 
-- _Intégrité_, les informations sont correctes, elles ne peuvent pas être modifiées par des entités non autorisées, ou de manière non autorisée (par exemple, en transférant des [jetons ERC-20] (https://eips.ethereum.org/EIPS/eip-20#events) sans un événement `Transfer`). Sur la blockchain, chaque nœud vérifie chaque changement d'état, ce qui garantit l'intégrité.
+- _Intégrité_, les informations sont correctes, elles ne peuvent pas être modifiées par des entités non autorisées, ou de manière non autorisée (par exemple, en transférant des [jetons ERC-20](https://eips.ethereum.org/EIPS/eip-20#events) sans un événement `Transfer`). Sur la blockchain, chaque nœud vérifie chaque changement d'état, ce qui garantit l'intégrité.
 
 - _Disponibilité_, l'information est accessible à toute entité autorisée. Sur la blockchain, cela est généralement réalisé en rendant l'information disponible sur chaque [nœud complet](https://ethereum.org/developers/docs/nodes-and-clients/#full-node).
 
@@ -114,5 +114,5 @@ Ce tableau résume les différentes options, leurs avantages et inconvénients.
 | Données d'appel                                       | Hors chaîne               | Garantie perpétuelle sur Ethereum (fait partie de la blockchain)                                                                     | Disponible uniquement si écrit dans un contrat, et lors de cette transaction |                                                                                        |
 | Hors chaîne avec des mécanismes de couche de niveau 1 | Hors chaîne               | Garantie d'un "vérificateur honnête" pendant la période de contestation                                                                                 | Hachage uniquement                                                           | Garanti par le mécanisme de contestation, seulement pendant la période de contestation |
 | Code contrat                                          | Sur chaîne ou hors chaîne | Garantie perpétuelle sur Ethereum (fait partie de la blockchain)                                                                     | Oui                                                                          | Écrit à une adresse "aléatoire", ne peut pas commencer par `0xEF`                      |
-| Évènements                                            | Sur la chaîne             | Garantie perpétuelle sur Ethereum (fait partie de la blockchain)                                                                     | Non                                                                          |                                                                                        |
+| Événements                                            | Sur la chaîne             | Garantie perpétuelle sur Ethereum (fait partie de la blockchain)                                                                     | Non                                                                          |                                                                                        |
 | Stockage                                              | Sur la chaîne             | Garantie perpétuelle sur Ethereum (fait partie de la blockchain et de l'état actuel jusqu'à écrasement)                              | Oui                                                                          |                                                                                        |
diff --git a/public/content/translations/fr/developers/docs/data-availability/index.md b/public/content/translations/fr/developers/docs/data-availability/index.md
index d035f45edca..2fa0abc6b9d 100644
--- a/public/content/translations/fr/developers/docs/data-availability/index.md
+++ b/public/content/translations/fr/developers/docs/data-availability/index.md
@@ -1,36 +1,36 @@
 ---
-title: Disponibilité des données
-description: Un aperçu des problèmes et des solutions liés à la disponibilité des données sur Ethereum
+title: "Disponibilité des données"
+description: "Un aperçu des problèmes et des solutions liés à la disponibilité des données sur Ethereum"
 lang: fr
 ---
 
 « Ne pas faire confiance, vérifier » est une maxime courante dans Ethereum. L'idée est que votre nœud peut vérifier de façon indépendante que les informations qu'il reçoit sont correctes en exécutant toutes les transactions dans les blocs qu'il reçoit de ses pairs pour s'assurer que les changements proposés correspondent exactement à ceux calculés indépendamment par le noeud. Cela signifie que les nœuds n'ont pas à croire que les expéditeurs du bloc sont honnêtes. Ce n'est pas possible si les données sont manquantes.
 
-**La disponibilité des données** fait référence à la confiance qu'un utilisateur peut avoir que les données requises pour vérifier qu'un bloc est vraiment disponible pour tous les participants au réseau. Pour les nœuds complets de la couche Ethereum 1, c'est relativement simple ; le noeud complet télécharge une copie de toutes les données dans chaque bloc - les données _doivent être disponibles_ pour que le téléchargement soit possible. Un bloc avec des données manquantes serait jeté plutôt que d'être ajouté à la blockchain. Il s'agit de la « disponibilité des données sur la chaîne » et c'est une caractéristique des blockchains monolithiques. Les nœuds complets ne peuvent pas être amenés à accepter des transactions invalides car ils téléchargent et exécutent chaque transaction pour eux-mêmes. Cependant, pour les blockchains modulaires, les rollups de la couche 2 et les clients légers, le paysage de disponibilité des données est plus complexe, nécessitant des procédures de vérification plus sophistiquées.
+**La disponibilité des données** fait référence à la confiance qu'un utilisateur peut avoir dans le fait que les données nécessaires à la vérification d'un bloc sont réellement disponibles pour tous les participants du réseau. Pour les nœuds complets sur la couche 1 d'Ethereum, c'est relativement simple ; le nœud complet télécharge une copie de toutes les données de chaque bloc - les données _doivent_ être disponibles pour que le téléchargement soit possible. Un bloc avec des données manquantes serait jeté plutôt que d'être ajouté à la blockchain. Il s'agit de la « disponibilité des données sur la chaîne » et c'est une caractéristique des blockchains monolithiques. Les nœuds complets ne peuvent pas être amenés à accepter des transactions invalides car ils téléchargent et exécutent chaque transaction pour eux-mêmes. Cependant, pour les blockchains modulaires, les rollups de la couche 2 et les clients légers, le paysage de disponibilité des données est plus complexe, nécessitant des procédures de vérification plus sophistiquées.
 
 ## Prérequis {#prerequisites}
 
-Vous devriez avoir une bonne compréhension des [fondamentaux de la blockchain](/developers/docs/intro-to-ethereum/), en particulier des [mécanismes de consensus](/developers/docs/consensus-mechanisms/). Cette page suppose également que le lecteur est familier avec les [blocs](/developers/docs/blocks/), [transactions](/developers/docs/transactions/), [noeuds](/developers/docs/nodes-and-clients/), [solutions d'échelle](/developers/docs/scaling/), et autres sujets pertinents.
+Vous devez avoir une bonne compréhension des [principes fondamentaux de la blockchain](/developers/docs/intro-to-ethereum/), en particulier des [mécanismes de consensus](/developers/docs/consensus-mechanisms/). Cette page suppose également que le lecteur est familier avec les [blocs](/developers/docs/blocks/), les [transactions](/developers/docs/transactions/), les [nœuds](/developers/docs/nodes-and-clients/), les [solutions de mise à l'échelle](/developers/docs/scaling/) et d'autres sujets pertinents.
 
-## Problème de disponibilité des données {#the-data-availability-problem}
+## Le problème de la disponibilité des données {#the-data-availability-problem}
 
 Le problème de la disponibilité des données est la nécessité de prouver à l'ensemble du réseau que la forme résumée de certaines données de transaction qui sont ajoutées à la blockchain représente vraiment un ensemble de transactions valides, mais sans obliger tous les nœuds à télécharger toutes les données. Les données de transaction complètes sont nécessaires pour la vérification indépendante des blocs, mais exiger que tous les nœuds téléchargent toutes les données de transaction est un obstacle à la mise à l'échelle. Les solutions au problème de la disponibilité des données visent à fournir suffisamment d'assurance que toutes les données de transaction ont été mises à la disposition des participants du réseau qui ne téléchargent pas et ne stockent pas les données pour eux-mêmes.
 
-[Les nœuds légers](/developers/docs/nodes-and-clients/light-clients) et [les rollups de la couche 2](/developers/docs/scaling) sont des exemples importants de participants au réseau qui nécessitent une forte assurance de disponibilité des données, mais ne peuvent pas télécharger et traiter les données de transaction pour eux-mêmes. Une opération de téléchargement des données de transaction non effectuée, c'est ce qui rend les light nodes légers, et permet à la fois aux rollups de se présenter en tant que véritables solutions pour résoudre les problèmes de scalabilité.
+[Les nœuds légers](/developers/docs/nodes-and-clients/light-clients) et les [rollups de couche 2](/developers/docs/scaling) sont des exemples importants de participants au réseau qui nécessitent de solides garanties de disponibilité des données, mais ne peuvent pas télécharger et traiter les données de transaction par eux-mêmes. Une opération de téléchargement des données de transaction non effectuée, c'est ce qui rend les light nodes légers, et permet à la fois aux rollups de se présenter en tant que véritables solutions pour résoudre les problèmes de scalabilité.
 
-La disponibilité des données constitue aussi un sujet de préoccupation majeure pour les clients [« apatrides »](/roadmap/statelessness) d'Ethereum à venir, qui n'auraient pas besoin de télécharger ou de stocker des données afin de vérifier des blocs. Les clients « stateless » ont constamment besoin d'être assurés que les données sont disponibles_, peu importe comment,_ et que le traitement des données s'est déroulé de façon correcte.
+La disponibilité des données est également une préoccupation essentielle pour les futurs clients Ethereum [« sans état »](/roadmap/statelessness) qui n'ont pas besoin de télécharger et de stocker les données d'état pour vérifier les blocs. Les clients sans état doivent toujours être certains que les données sont disponibles _quelque part_ et qu'elles ont été traitées correctement.
 
-## Des solutions garantissant la disponibilité des données {#data-availability-solutions}
+## Solutions de disponibilité des données {#data-availability-solutions}
 
 ### Échantillonnage de la disponibilité des données (DAS) {#data-availability-sampling}
 
-L'échantillonnage de la disponibilité des données (DAS) est un moyen pour le réseau de vérifier que les données sont disponibles sans mettre trop de pression sur un nœud individuel. Chaque nœud (y compris les nœuds non jalonnés) télécharge un petit sous-ensemble sélectionné au hasard des données totales. Le téléchargement réussi des échantillons confirme avec une grande confiance que toutes les données sont disponibles. Cela repose sur un système de chiffrage qui permet l'effacement de données, tout en favorisant l'extension d'un ensemble de données avec des informations redondantes (la façon dont cela s'effectue est d'adapter une fonction connue sous le nom de _fonctions polynomiales,_ sur les données et dévaluer ce polynôme en des points supplémentaires). Les données originales peuvent ainsi être recouvertes, si nécessaire, sur un ensemble de données redondantes. Par conséquent, si _aucune_ donnée originale n'était disponible, la création des données engendrait une perte de la _moitié_ des données étendues ! La quantité d'échantillons de données téléchargées peut être ajustée par noeud. De ce fait, il est _fort_ probable qu'au moins un des fragments de données échantillonnés par chaque client soit manquant _si_ moins de la moitié des données sont réellement disponibles.
+L'échantillonnage de la disponibilité des données (DAS) est un moyen pour le réseau de vérifier que les données sont disponibles sans mettre trop de pression sur un nœud individuel. Chaque nœud (y compris les nœuds non jalonnés) télécharge un petit sous-ensemble sélectionné au hasard des données totales. Le téléchargement réussi des échantillons confirme avec une grande confiance que toutes les données sont disponibles. Cela repose sur le codage à effacement de données, qui étend un ensemble de données donné avec des informations redondantes (pour ce faire, on ajuste une fonction connue sous le nom de _polynôme_ sur les données et on évalue ce polynôme en des points supplémentaires). Les données originales peuvent ainsi être recouvertes, si nécessaire, sur un ensemble de données redondantes. Une conséquence de cette création de données est que si _une partie_ des données originales n'est pas disponible, la _moitié_ des données étendues sera manquante ! La quantité d'échantillons de données téléchargés par chaque nœud peut être ajustée de sorte qu'il soit _extrêmement_ probable qu'au moins un des fragments de données échantillonnés par chaque client soit manquant _si_ moins de la moitié des données est réellement disponible.
 
-DAS sera employé pour permettre aux opérateurs de rollup de rendre leurs données de transaction disponibles, après l'implémentation du[Danksharding complet](/roadmap/danksharding/#what-is-danksharding). Les nœuds Ethereum procéderont à un échantillonnage aléatoire des données de transaction fournies dans les blobs en utilisant le schéma de redondance expliqué ci-dessus pour s'assurer que toutes les données existent. La même technique pourrait également être employée pour s'assurer que les producteurs de blocs mettent toutes leurs données à la disposition de la sécurisation des clients légers. De même, sous [la séparation proposant-constructeur](/roadmap/pbs), seul le constructeur d'un bloc serait requis pour traiter un bloc entier - d'autres validateurs procéderaient à une vérification en utilisant l'échantillonnage de la disponibilité des données.
+Le DAS sera utilisé pour s'assurer que les opérateurs de rollup rendent leurs données de transaction disponibles après la mise en œuvre du [Danksharding complet](/roadmap/danksharding/#what-is-danksharding). Les nœuds Ethereum procéderont à un échantillonnage aléatoire des données de transaction fournies dans les blobs en utilisant le schéma de redondance expliqué ci-dessus pour s'assurer que toutes les données existent. La même technique pourrait également être employée pour s'assurer que les producteurs de blocs mettent toutes leurs données à la disposition de la sécurisation des clients légers. De même, dans le cadre de la [séparation proposant-constructeur](/roadmap/pbs), seul le constructeur de bloc serait tenu de traiter un bloc entier - les autres validateurs effectueraient une vérification en utilisant l'échantillonnage de disponibilité des données.
 
 ### Comités de disponibilité des données {#data-availability-committees}
 
-Les comités de disponibilité des données (DAC) sont des tiers de confiance qui fournissent ou attestent de la disponibilité des données. Les DAC peuvent être utilisés à la place de, [ou en combinaison avec](https://hackmd.io/@vbuterin/sharding_proposal#Why-not-use-just-committees-and-not-DAS) DAS. Les garanties données par les comités en matière de sécurité, relèvent de leur mise en place spécifique. Ethereum utilise des échantillons aléatoires de sous-ensembles de validateurs pour attester de la disponibilité des données pour les nœuds légers, par exemple.
+Les comités de disponibilité des données (DAC) sont des tiers de confiance qui fournissent ou attestent de la disponibilité des données. Les DAC peuvent être utilisés à la place du DAS, [ou en combinaison avec celui-ci](https://hackmd.io/@vbuterin/sharding_proposal#Why-not-use-just-committees-and-not-DAS). Les garanties données par les comités en matière de sécurité, relèvent de leur mise en place spécifique. Ethereum utilise des échantillons aléatoires de sous-ensembles de validateurs pour attester de la disponibilité des données pour les nœuds légers, par exemple.
 
 Les DAC sont également utilisés par certains validiums. Le DAC est un ensemble de noeuds de confiance qui stocke des copies de données hors ligne. Le DAC est nécessaire pour la mise à disposition des données en cas de litige. Les membres de la DAC publient également des attestations en chaîne pour prouver que les données en question sont effectivement disponibles. Certains Validiums remplacent les DAC par un système de validation par preuve d'enjeu (PoS). Ici, tout le monde peut devenir un validateur et stocker des données hors chaîne. Cependant, ils doivent fournir une « obligation », qui est déposée dans un contrat intelligent. En cas d'intention malveillante, telle que la retenue des données du validateur, cet accord pourrait être résilié. Les comités de disponibilité des données basée sur la preuve d'enjeu sont bien plus sécuritaires que les DAC régulières, car ils encouragent directement les comportements honnêtes.
 
@@ -38,47 +38,47 @@ Les DAC sont également utilisés par certains validiums. Le DAC est un ensemble
 
 [Les nœuds légers](/developers/docs/nodes-and-clients/light-clients) doivent valider l'exactitude des en-têtes de bloc qu'ils reçoivent sans télécharger les données du bloc. Le coût de cette légèreté est l'incapacité à vérifier indépendamment les en-têtes de bloc en réexécutant les transactions localement à la manière des nœuds complets.
 
-Les nœuds légers Ethereum font confiance à des ensembles aléatoires de 512 validateurs qui ont été assignés à un _comité de synchronisation_. Le comité de synchronisation agit comme une DAC qui signale aux clients légers que les données dans l'en-tête sont correctes en utilisant une signature cryptographique. Le comité de synchronisation effectue des rafraîchissements journaliers des données. Chaque en-tête de bloc alerte les nœuds légers quant aux validateurs qui s'attendent à approuver le bloc _suivant_, afin qu'ils ne puissent pas être amenés à faire confiance à un groupe malveillant prétendant être le vrai comité de synchronisation.
+Les nœuds légers d'Ethereum font confiance à des ensembles aléatoires de 512 validateurs qui ont été assignés à un _comité de synchronisation_. Le comité de synchronisation agit comme une DAC qui signale aux clients légers que les données dans l'en-tête sont correctes en utilisant une signature cryptographique. Le comité de synchronisation effectue des rafraîchissements journaliers des données. Chaque en-tête de bloc informe les nœuds légers des validateurs qui devraient signer le bloc _suivant_, afin qu'ils ne puissent pas être amenés à faire confiance à un groupe malveillant se faisant passer pour le véritable comité de synchronisation.
 
-Cependant, que se passe-t-il si un attaquant _parvient_ d'une manière ou d'une autre à transmettre un en-tête de bloc malveillant aux clients légers et à les convaincre qu'il a été approuvé par un comité de synchronisation honnête ? Dans ce cas, l'attaquant pourrait inclure des transactions invalides et le client léger les accepterait aveuglément, car il ne vérifie pas indépendamment tous les changements d'état résumés dans l'en-tête du bloc. Pour se prémunir contre cela, le client léger pourrait utiliser des preuves de fraude.
+Cependant, que se passe-t-il si un attaquant parvient d'une manière ou d'une autre à transmettre un en-tête de bloc malveillant à des clients légers et à les convaincre qu'il a été signé par un comité de synchronisation honnête ? Dans ce cas, l'attaquant pourrait inclure des transactions invalides et le client léger les accepterait aveuglément, car il ne vérifie pas indépendamment tous les changements d'état résumés dans l'en-tête du bloc. Pour se prémunir contre cela, le client léger pourrait utiliser des preuves de fraude.
 
 La façon dont ces preuves de fraude fonctionnent est qu'un nœud complet, voyant une transition d'état invalide faire l'objet de commérages dans le réseau, pourrait rapidement générer une petite partie de données démontrant qu'une transition d'état proposée ne pourrait pas provenir d'un ensemble donné de transactions et diffuser ces données aux pairs. Les nœuds légers pourraient récupérer ces preuves de fraude et les utiliser pour éliminer les en-têtes de bloc défectueux, en s'assurant d'un maintien sur la même chaîne honnête que les nœuds complets.
 
 Cela repose sur des nœuds complets ayant accès à des données de transaction complètes. Un attaquant qui diffuse un mauvais en-tête de bloc et ne parvient pas non plus à rendre les données de transaction disponibles serait en mesure d'empêcher les nœuds complets de générer des preuves de fraude. Les nœuds complets pourraient être en mesure de signaler la présence d'un bloc défectueux, mais ils ne pourraient pas assurer la mise en place de leur avertissement avec une preuve, du fait de l'absence de disponibilité des données pour générer la preuve !
 
-DAS : la solution au problème de disponibilité des données. Les nœuds légers téléchargent de très petits morceaux aléatoires des données d'état complètes et utilisent les échantillons pour vérifier que l'ensemble de données complet est disponible. La probabilité réelle de supposer à tort la disponibilité totale des données après le téléchargement de N morceaux aléatoires peut être calculée ([pour 100 morceaux, la chance est de 10^-30](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html), c'est-à-dire incroyablement improbable).
+DAS : la solution au problème de disponibilité des données. Les nœuds légers téléchargent de très petits morceaux aléatoires des données d'état complètes et utilisent les échantillons pour vérifier que l'ensemble de données complet est disponible. La probabilité réelle de supposer à tort une disponibilité totale des données après le téléchargement de N morceaux aléatoires peut être calculée ([pour 100 morceaux, la probabilité est de 10^-30](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html), c'est-à-dire incroyablement improbable).
 
 Même dans ce scénario, les attaques qui retiennent seulement quelques octets pourraient vraisemblablement passer inaperçues auprès des clients effectuant des demandes de données aléatoires. Le code d'effacement corrige cela en reconstruisant de petites parties de données manquantes qui peuvent être utilisées pour vérifier les changements d'état proposés. Une preuve de fraude pourrait alors être construite en utilisant les données reconstruites, empêchant les nœuds légers d'accepter de mauvais en-têtes.
 
-**Remarque :** Les preuves DAS et de fraude n'ont pas encore été implémentées pour les clients légers Ethereum prouvés en jeu mais elles sont sur la feuille de route, très probablement sous la forme de preuves basées sur ZK-SNARK. Les clients légers d'aujourd'hui s'appuient sur une forme de DAC : ils vérifient les identités du comité de synchronisation et font ensuite confiance aux en-têtes de blocs signés qu'ils reçoivent.
+**Note :** Le DAS et les preuves de fraude n'ont pas encore été implémentés pour les clients légers Ethereum à preuve d'enjeu, mais ils figurent sur la feuille de route, et prendront très probablement la forme de preuves basées sur les ZK-SNARK. Les clients légers d'aujourd'hui s'appuient sur une forme de DAC : ils vérifient les identités du comité de synchronisation et font ensuite confiance aux en-têtes de blocs signés qu'ils reçoivent.
 
-## Disponibilité des données et couche 2 rollups {#data-availability-and-layer-2-rollups}
+## Disponibilité des données et rollups de couche 2 {#data-availability-and-layer-2-rollups}
 
-[Les solutions d'évolutivité de la couche 2](/layer-2/), telles que les [rollups](/glossary/#rollups), réduisent les coûts de transaction et augmentent le débit d'Ethereum en traitant les transactions hors chaîne. Les transactions de rollup sont compressées et publiées par lots sur Ethereum. Les lots représentent des milliers de transactions individuelles hors chaîne en une seule transaction sur Ethereum. Cela réduit la congestion de la couche de base et réduit les frais pour les utilisateurs.
+[Les solutions de mise à l'échelle de couche 2](/layer-2/), telles que les [rollups](/glossary/#rollups), réduisent les coûts de transaction et augmentent le débit d'Ethereum en traitant les transactions hors chaîne. Les transactions de rollup sont compressées et publiées par lots sur Ethereum. Les lots représentent des milliers de transactions individuelles hors chaîne en une seule transaction sur Ethereum. Cela réduit la congestion de la couche de base et réduit les frais pour les utilisateurs.
 
 Cependant, il n'est possible de faire confiance aux transactions « résumées » publiées sur Ethereum que si le changement d'état proposé peut être vérifié indépendamment et confirmé comme étant le résultat de l'application de toutes les transactions individuelles hors chaîne. Si les opérateurs de rollup ne rendent pas disponibles les données de transaction pour cette vérification, ils pourraient envoyer des données incorrectes à Ethereum.
 
-[Les rollups optimistes](/developers/docs/scaling/optimistic-rollups/) postent des données de transaction compressées sur Ethereum et attendent un certain temps (typiquement 7 jours) pour permettre aux vérificateurs indépendants de vérifier les données. Si quelqu'un identifie un problème, il peut générer une étanchéité à la fraude et l'utiliser pour défier le rollup. Cela provoquerait l'annulation de la chaîne et l'omission du bloc invalide. Ce n'est pas possible si les données sont manquantes. Actuellement, il existe deux façons pour les rollups optimistes de publier les données de transaction sur la couche de niveau 1. Certains rollups rendent les données disponibles de manière permanente en tant que `CALLDATA`, qui reste en permanence sur la chaîne. Avec l'introduction de l'EIP-4844, certains rollups publient plutôt leurs données de transaction dans un stockage blob moins coûteux. Il ne s'agit pas d'un stockage permanent. Les vérificateurs indépendants doivent interroger les blobs et soulever leurs objections dans un délai d'environ 18 jours avant que les données ne soient supprimées de la couche de niveau 1 d'Ethereum. La disponibilité des données n'est garantie que par le protocole Ethereum pour cette courte fenêtre fixe. Ensuite, cela incombe à d'autres entités de l'écosystème Ethereum. N'importe quel nœud peut vérifier la disponibilité des données en utilisant DAS, c'est-à-dire en téléchargeant de petits échantillons aléatoires des données du blob.
+[Les rollups optimistes](/developers/docs/scaling/optimistic-rollups/) publient des données de transaction compressées sur Ethereum et attendent un certain temps (généralement 7 jours) pour permettre à des vérificateurs indépendants de contrôler les données. Si quelqu'un identifie un problème, il peut générer une étanchéité à la fraude et l'utiliser pour défier le rollup. Cela provoquerait l'annulation de la chaîne et l'omission du bloc invalide. Ce n'est pas possible si les données sont manquantes. Actuellement, il existe deux façons pour les rollups optimistes de publier les données de transaction sur la couche de niveau 1. Certains rollups rendent les données disponibles en permanence en tant que `CALLDATA` qui reste en permanence sur la chaîne. Avec l'introduction de l'EIP-4844, certains rollups publient plutôt leurs données de transaction dans un stockage blob moins coûteux. Il ne s'agit pas d'un stockage permanent. Les vérificateurs indépendants doivent interroger les blobs et soulever leurs objections dans un délai d'environ 18 jours avant que les données ne soient supprimées de la couche de niveau 1 d'Ethereum. La disponibilité des données n'est garantie que par le protocole Ethereum pour cette courte fenêtre fixe. Ensuite, cela incombe à d'autres entités de l'écosystème Ethereum. N'importe quel nœud peut vérifier la disponibilité des données en utilisant le DAS, c'est-à-dire en téléchargeant de petits échantillons aléatoires des données blob.
 
-[Les rollups Zero-knowledge (ZK)](/developers/docs/scaling/zk-rollups) ne nécessitent pas de publier de données de transaction car [les preuves de validité de la nulle-connaissance](/glossary/#zk-proof) garantissent l'exactitude des transitions d'état. Cependant, la disponibilité des données reste un problème parce que nous ne pouvons pas garantir la fonctionnalité du ZK-rollup (ou interagir avec elle) sans accès à ses données d'état. Par exemple, les utilisateurs ne peuvent pas connaître leurs soldes si un opérateur retient des détails sur l’état du rollup. De plus, ils ne peuvent pas effectuer de mises à jour d'état en utilisant des informations contenues dans un bloc nouvellement ajouté.
+[Les rollups à preuve à divulgation nulle de connaissance (ZK)](/developers/docs/scaling/zk-rollups) n'ont pas besoin de publier des données de transaction, car les [preuves de validité à divulgation nulle de connaissance](/glossary/#zk-proof) garantissent l'exactitude des transitions d'état. Cependant, la disponibilité des données reste un problème parce que nous ne pouvons pas garantir la fonctionnalité du ZK-rollup (ou interagir avec elle) sans accès à ses données d'état. Par exemple, les utilisateurs ne peuvent pas connaître leurs soldes si un opérateur retient des détails sur l’état du rollup. De plus, ils ne peuvent pas effectuer de mises à jour d'état en utilisant des informations contenues dans un bloc nouvellement ajouté.
 
-## Disponibilité des données par rapport à la récupération des données {#data-availability-vs-data-retrievability}
+## Disponibilité des données vs récupérabilité des données {#data-availability-vs-data-retrievability}
 
 Disponibilité des données par rapport à la récupération des données. La disponibilité des données est l'assurance que des nœuds complets ont été en mesure de vérifier l'ensemble des transactions associées à un bloc spécifique et d'y accéder. Il ne s'ensuit pas nécessairement que les données sont accessibles pour toujours.
 
-La possibilité de récupérer des données est la capacité des nœuds à récupérer _des informations historiques_ de la blockchain. Ces données historiques ne sont pas nécessaires pour vérifier de nouveaux blocs, elles sont seulement requises pour synchroniser des nœuds complets à partir du bloc d'origine ou pour répondre à des requêtes historiques spécifiques.
+La récupérabilité des données est la capacité des nœuds à récupérer des _informations historiques_ de la blockchain. Ces données historiques ne sont pas nécessaires pour vérifier de nouveaux blocs, elles sont seulement requises pour synchroniser des nœuds complets à partir du bloc d'origine ou pour répondre à des requêtes historiques spécifiques.
 
-Le protocole Ethereum de base est principalement concerné par la disponibilité des données, et non par la récupération des données. La possibilité de récupérer les données peut être fournie par une petite population de nœuds d'archive exécutés par des tiers, ou une distribution est possible à travers le réseau en utilisant un stockage de fichiers décentralisé tel que le [réseau du portail](https://www.ethportal.net/).
+Le protocole Ethereum de base est principalement concerné par la disponibilité des données, et non par la récupération des données. La récupérabilité des données peut être assurée par un petit nombre de nœuds d'archive gérés par des tiers, ou elle peut être répartie sur le réseau à l'aide d'un stockage de fichiers décentralisé tel que le [Réseau Portal](https://www.ethportal.net/).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Le WTF est-il la disponibilité des données ?](https://medium.com/blockchain-capital-blog/wtf-is-data-availability-80c2c95ded0f)
-- [Qu'est-ce que la disponibilité des données ?](https://coinmarketcap.com/alexandria/article/what-is-data-availability)
-- [Un préfixe sur les vérifications de disponibilité des données](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html)
-- [Une explication de la proposition de fragmentation + DAS](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling)
-- [Une note sur la disponibilité des données et le codage de l'effacement](https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding#can-an-attacker-not-circumvent-this-scheme-by-releasing-a-full-unavailable-block-but-then-only-releasing-individual-bits-of-data-as-clients-query-for-them)
+- [WTF is Data Availability?](https://medium.com/blockchain-capital-blog/wtf-is-data-availability-80c2c95ded0f)
+- [Qu'est-ce que la disponibilité des données ?](https://coinmarketcap.com/academy/article/what-is-data-availability)
+- [Introduction aux contrôles de disponibilité des données](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html)
+- [Explication de la proposition de sharding + DAS](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling)
+- [Note sur la disponibilité des données et le codage à effacement](https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding#can-an-attacker-not-circumvent-this-scheme-by-releasing-a-full-unavailable-block-but-then-only-releasing-individual-bits-of-data-as-clients-query-for-them)
 - [Comités de disponibilité des données.](https://medium.com/starkware/data-availability-e5564c416424)
-- [Comités de disponibilité des données de preuve d'enjeu.](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf)
-- [Solutions au problème de récupération des données](https://notes.ethereum.org/@vbuterin/data_sharding_roadmap#Who-would-store-historical-data-under-sharding)
-- [Disponibilité des données ou : Comment les Rollups ont appris à ne plus s'inquiéter et à aimer Ethereum](https://web.archive.org/web/20250515194659/https://web.archive.org/web/20241108192208/https://research.2077.xyz/data-availability-or-how-rollups-learned-to-stop-worrying-and-love-ethereum)
-- [EIP-7623 - Augmenter le Coût du Calldata](https://web.archive.org/web/20250515194659/https://research.2077.xyz/eip-7623-increase-calldata-cost)
+- [Comités de disponibilité des données à preuve d'enjeu.](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf)
+- [Solutions au problème de la récupérabilité des données](https://notes.ethereum.org/@vbuterin/data_sharding_roadmap#Who-would-store-historical-data-under-sharding)
+- [Data Availability Or: How Rollups Learned To Stop Worrying And Love Ethereum](https://web.archive.org/web/20250515194659/https://web.archive.org/web/20241108192208/https://research.2077.xyz/data-availability-or-how-rollups-learned-to-stop-worrying-and-love-ethereum)
+- [EIP-7623 : Augmentation du coût des Calldata](https://web.archive.org/web/20250515194659/https://research.2077.xyz/eip-7623-increase-calldata-cost)
diff --git a/public/content/translations/fr/developers/docs/data-structures-and-encoding/index.md b/public/content/translations/fr/developers/docs/data-structures-and-encoding/index.md
index 1c15140b107..0733d725504 100644
--- a/public/content/translations/fr/developers/docs/data-structures-and-encoding/index.md
+++ b/public/content/translations/fr/developers/docs/data-structures-and-encoding/index.md
@@ -1,32 +1,32 @@
 ---
-title: Structures de données et encodage
-description: Un aperçu des structures fondamentales de données Ethereum.
+title: "Structures de données et encodage"
+description: "Un aperçu des structures fondamentales de données Ethereum."
 lang: fr
 sidebarDepth: 2
 ---
 
-Ethereum crée, stocke et transfère de grands volumes de données. Ces données doivent être formatées par des moyens standardisés et efficaces en matière de mémoire pour permettre à quiconque [d'exécuter un nœud](/run-a-node/) sur du matériel relativement modeste. Pour cela, plusieurs structures de données spécifiques sont utilisées sur la pile Ethereum.
+Ethereum crée, stocke et transfère de grands volumes de données. Ces données doivent être formatées de manière standardisée et économe en mémoire pour permettre à quiconque d'[exécuter un nœud](/run-a-node/) sur du matériel grand public relativement modeste. Pour cela, plusieurs structures de données spécifiques sont utilisées sur la pile Ethereum.
 
 ## Prérequis {#prerequisites}
 
-Vous devriez d'abord maitriser les fondamentaux d'Ethereum et notamment du [logiciel client](/developers/docs/nodes-and-clients/). Il est recommandé de vous familiariser avec la couche réseau et [le livre blanc Ethereum](/whitepaper/).
+Vous devriez comprendre les fondamentaux d'Ethereum et les [logiciels clients](/developers/docs/nodes-and-clients/). Il est recommandé de vous familiariser avec la couche réseau et [le livre blanc d'Ethereum](/whitepaper/).
 
-## Structures des données {#data-structures}
+## Structures de données {#data-structures}
 
-### Arbre de Merkle Patricia {#patricia-merkle-tries}
+### Arbres de Merkle Patricia {#patricia-merkle-tries}
 
 Les arbres de Merkle Patricia sont des structures qui permettent d'encoder des paires clé-valeur dans un arbre déterministe et authentifié cryptographiquement. Ils sont largement utilisés dans la couche d'exécution d'Ethereum.
 
 [En savoir plus sur les arbres de Merkle Patricia](/developers/docs/data-structures-and-encoding/patricia-merkle-trie)
 
-### Préfixe de longueur récursive (RLP)  {#recursive-length-prefix}
+### Préfixe de longueur récursive {#recursive-length-prefix}
 
 Le préfixe de longueur récursive (RLP) est une méthode de sérialisation largement utilisée à travers la couche d'exécution d'Ethereum.
 
-[En savoir plus sur le RLP](/developers/docs/data-structures-and-encoding/rlp)
+[En savoir plus sur RLP](/developers/docs/data-structures-and-encoding/rlp)
 
-### Sérialisation simple (Simple Serialize) {#simple-serialize}
+### Sérialisation simple {#simple-serialize}
 
 La sérialisation simple (Simple Serialize, ou SSZ) est le format de sérialisation dominant sur la couche de consensus d'Ethereum en raison de sa compatibilité avec la merklelization.
 
-[En savoir plus sur la SSZ](/developers/docs/data-structures-and-encoding/ssz)
+[En savoir plus sur SSZ](/developers/docs/data-structures-and-encoding/ssz)
diff --git a/public/content/translations/fr/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md b/public/content/translations/fr/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
index 6384c4ff1a3..83c2f9c325b 100644
--- a/public/content/translations/fr/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
+++ b/public/content/translations/fr/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md
@@ -1,23 +1,23 @@
 ---
 title: Arbre de Merkle Patricia
-description: Introduction à l'Arbre de Merkle Patricia
+description: "Introduction à l'Arbre de Merkle Patricia"
 lang: fr
 sidebarDepth: 2
 ---
 
-L'état d'Ethereum (l'ensemble des comptes, des soldes et des contrats intelligents) est codé dans une version spéciale de la structure de données couramment connue en informatique sous le nom d'arbre de Merkle. Cette structure est utile pour de nombreuses applications en cryptographie, car elle crée une relation vérifiable entre toutes les pièces de données individuelles entrelacées dans l'arbre, aboutissant à une seule valeur **racine** qui peut être utilisée pour prouver des éléments relatifs aux données.
+L'état d'Ethereum (l'ensemble des comptes, des soldes et des contrats intelligents) est codé dans une version spéciale de la structure de données couramment connue en informatique sous le nom d'arbre de Merkle. Cette structure est utile pour de nombreuses applications en cryptographie, car elle crée une relation vérifiable entre toutes les données individuelles entrelacées dans l'arbre, ce qui aboutit à une seule valeur **racine** qui peut être utilisée pour prouver des éléments concernant les données.
 
-La structure de données d'Ethereum est un arbre de Patricia Merkle modifié, nommé ainsi parce qu'il emprunte certaines caractéristiques de PATRICIA (ou Practical Algorithm To Retrieve Information Coded in Alphanumeric), et parce qu'il est conçu pour récupérer efficacement les données (re**trie**val) des éléments qui composent l'état Ethereum.
+La structure de données d'Ethereum est un « Arbre de Merkle-Patricia modifié », ainsi nommé car il emprunte certaines fonctionnalités de PATRICIA (Practical Algorithm To Retrieve Information Coded in Alphanumeric) et parce qu'il est conçu pour une récupération efficace des données (re**trie**val) des éléments qui composent l'état d'Ethereum.
 
-Un arbre de Patricia Merkle est déterministe et cryptographiquement vérifiable : la seule façon de générer une racine d'état est de la calculer à partir de chaque morceau individuel de l'état, et deux états qui sont identiques peuvent être facilement prouvés en comparant le hash de racine et les hashes qui y ont conduit (_a Merkle proof_). Inversement, il n'est pas possible de créer deux états différents avec le même hachage de racine, et toute tentative de modifier l'état avec différentes valeurs donnera lieu à un hachage de racine d'état différent. Théoriquement, cette structure fournit le sacré Graal de l'efficacité `O(log(n))` pour les inserts, les recherches et les suppressions.
+Un arbre de Merkle-Patricia est déterministe et cryptographiquement vérifiable : la seule façon de générer une racine d'état est de la calculer à partir de chaque élément individuel de l'état, et deux états identiques peuvent être facilement prouvés comme tels en comparant le hachage racine et les hachages qui y ont conduit (_une preuve de Merkle_). Inversement, il n'est pas possible de créer deux états différents avec le même hachage de racine, et toute tentative de modifier l'état avec différentes valeurs donnera lieu à un hachage de racine d'état différent. Théoriquement, cette structure fournit le « Saint Graal » de l'efficacité `O(log(n))` pour les insertions, les recherches et les suppressions.
 
 Dans un avenir proche, Ethereum prévoit de migrer vers une structure en [arbre de Verkle](/roadmap/verkle-trees), ce qui ouvrira de nombreuses possibilités d'amélioration du protocole.
 
 ## Prérequis {#prerequisites}
 
-Pour mieux comprendre cette page, il serait utile d'avoir des connaissances de base sur les [hachages](https://en.wikipedia.org/wiki/Hash_function), les [arbres de Merkle](https://en.wikipedia.org/wiki/Merkle_tree), les [arbres](https://en.wikipedia.org/wiki/Trie) et la [sérialisation](https://en.wikipedia.org/wiki/Serialization). Cet article commence par une description d'un [arbre radix](https://en.wikipedia.org/wiki/Radix_tree) de base, puis introduit progressivement les modifications nécessaires pour la construction d'une structure de données plus optimisée d'Ethereum.
+Pour mieux comprendre cette page, il serait utile d'avoir des connaissances de base sur les [hachages](https://en.wikipedia.org/wiki/Hash_function), les [arbres de Merkle](https://en.wikipedia.org/wiki/Merkle_tree), les [tries](https://en.wikipedia.org/wiki/Trie) et la [sérialisation](https://en.wikipedia.org/wiki/Serialization). Cet article commence par une description d'un [arbre radix](https://en.wikipedia.org/wiki/Radix_tree) de base, puis introduit progressivement les modifications nécessaires à la structure de données plus optimisée d'Ethereum.
 
-## Arbres radix de base {#basic-radix-tries}
+## Tries radix de base {#basic-radix-tries}
 
 Dans un arbre radix de base, chaque nœud se présente comme suit :
 
@@ -25,19 +25,19 @@ Dans un arbre radix de base, chaque nœud se présente comme suit :
     [i_0, i_1 ... i_n, value]
 ```
 
-Là où `i0 ... in` représentent les symboles de l'alphabet (souvent binaires ou hexagonaux), `value` est la valeur terminale du nœud, et les valeurs dans les créneaux `i0 ... in` sont soit `NULL` soit des pointeurs vers (dans notre cas, des hashs) d'autres nœuds. Cela forme un registre de base `(key, value)`.
+Où `i_0 ...` i_n`représentent les symboles de l'alphabet (souvent binaire ou hexadécimal),`value`est la valeur terminale au niveau du nœud, et les valeurs dans les`i_0, i_1 ...`créneaux`i_n`sont soit`NULL`, soit des pointeurs vers (dans notre cas, des hachages) d'autres nœuds. Ceci forme un magasin `(clé, valeur)` de base.
 
-Supposons que vous souhaitiez utiliser une structure de données d'arborescence radix pour maintenir une commande sur un ensemble de paires de valeurs clés. Pour connaître la valeur actuellement associée à `dog` dans le tableau, vous devriez d'abord convertir `dog` en lettres de l'alphabet (ce qui donne `64 6f 67`), puis descendre dans l'arbre en suivant ce chemin jusqu'à ce que vous trouviez la valeur. C'est-à-dire que vous commencez par chercher le hachage racine dans une base de données/valeur plate pour trouver le nœud racine de l'arbre. Il se présente sous la forme d'un tableau de clés pointant vers d'autres nœuds. Vous utilisez ensuite la valeur à l'index `6` comme clé et la recherchez dans la base de données clé/valeur pour obtenir le nœud un niveau plus bas. Ensuite, choisissez l'index `4` pour rechercher la valeur suivante, puis choisissez l'index `6`, et ainsi de suite, jusqu'à ce que, une fois suivi le chemin : `racine -> -> -> 6 - > 6 -> 15 -> 6 -> 7`, vous cherchiez la valeur du nœud et retourniez le résultat.
+Supposons que vous souhaitiez utiliser une structure de données d'arborescence radix pour maintenir une commande sur un ensemble de paires de valeurs clés. Pour trouver la valeur actuellement mappée à la clé `dog` dans le trie, vous devez d'abord convertir `dog` en lettres de l'alphabet (ce qui donne `64 6f 67`), puis descendre dans le trie en suivant ce chemin jusqu'à trouver la valeur. C'est-à-dire que vous commencez par chercher le hachage racine dans une base de données/valeur plate pour trouver le nœud racine de l'arbre. Il se présente sous la forme d'un tableau de clés pointant vers d'autres nœuds. Vous utiliseriez la valeur à l'index `6` comme clé et la rechercheriez dans la base de données clé/valeur plate pour obtenir le nœud un niveau plus bas. Ensuite, choisissez l'index `4` pour rechercher la valeur suivante, puis l'index `6`, et ainsi de suite. Une fois le chemin suivi : `root -> 6 -> 4 -> 6 -> 15 -> 6 -> 7`, vous rechercherez la valeur du nœud et renverrez le résultat.
 
 Il y a une différence entre rechercher quelque chose dans l'"arbre" et la "base de données" plate sous-jacente (clé/valeur). Ils définissent tous deux des combinaisons clé/valeur, mais la base de données sous-jacente peut rechercher une clé en une seule étape basique. La recherche d'une clé dans le tableau nécessite plusieurs consultations de la base de données sous-jacente pour obtenir la valeur finale décrite ci-dessus. Faisons référence à ce dernier comme à un `path` (chemin) pour éliminer toute ambiguïté.
 
 Les opérations de mise à jour et de suppression pour les arbres radix peuvent être définies comme suit :
 
-```
+```python
     def update(node_hash, path, value):
-        curnode = db.get(node_hash) if node_hash else [ NULL ] * 17
+        curnode = db.get(node_hash) if node_hash else [NULL] * 17
         newnode = curnode.copy()
-        if path == '':
+        if path == "":
             newnode[-1] = value
         else:
             newindex = update(curnode[path[0]], path[1:], value)
@@ -51,7 +51,7 @@ Les opérations de mise à jour et de suppression pour les arbres radix peuvent
         else:
             curnode = db.get(node_hash)
             newnode = curnode.copy()
-            if path == '':
+            if path == "":
                 newnode[-1] = NULL
             else:
                 newindex = delete(curnode[path[0]], path[1:])
@@ -64,107 +64,110 @@ Les opérations de mise à jour et de suppression pour les arbres radix peuvent
                 return hash(newnode)
 ```
 
-Un arbre Radix « Merkle» est construit en reliant les nœuds à l'aide des diagrammes de hachage cryptographiques générés de manière déterministe. Cette adresse de contenu (dans la base de données clé/valeur `key == keccak256(rlp(value))`) fournit une garantie d'intégrité cryptographique des données stockées. Si le hash racine d'un arbre donné est connu publiquement, alors tout le monde ayant accès à cette feuille peut fournir une preuve que l'arbre inclut une valeur donnée à un endroit spécifique, en fournissant les hachages de chaque nœud reliant une valeur spécifique à la racine de l'arborescence.
+Un arbre Radix « Merkle» est construit en reliant les nœuds à l'aide des diagrammes de hachage cryptographiques générés de manière déterministe. Cet adressage de contenu (dans la base de données clé/valeur `key == keccak256(rlp(value))`) fournit une garantie d'intégrité cryptographique des données stockées. Si le hash racine d'un arbre donné est connu publiquement, alors tout le monde ayant accès à cette feuille peut fournir une preuve que l'arbre inclut une valeur donnée à un endroit spécifique, en fournissant les hachages de chaque nœud reliant une valeur spécifique à la racine de l'arborescence.
 
-Il est impossible pour un attaquant de fournir une preuve d'une paire de `(path, value)` qui n'existe pas car le hachage racine est basé en fin de compte sur tous les hachages situés au-dessous. Toute modification sous-jacente modifierait le hash racine. Vous pouvez considérer le hash comme une représentation compressée des informations structurelles sur les données, sécurisée par la protection de pré-image de la fonction de hachage.
+Il est impossible pour un attaquant de fournir une preuve d'une paire `(path, value)` qui n'existe pas, car le hachage racine est en fin de compte basé sur tous les hachages en dessous de lui. Toute modification sous-jacente modifierait le hash racine. Vous pouvez considérer le hash comme une représentation compressée des informations structurelles sur les données, sécurisée par la protection de pré-image de la fonction de hachage.
 
-Nous allons faire référence à une unité atomique d'un arbre radix (par exemple un seul caractère hexadécimal, ou un nombre binaire de 4 bits) en tant que "nibble". Lorsque l'on parcourt un chemin un nibble à la fois, comme décrit ci-dessus, les nœuds peuvent faire référence à 16 enfants au maximum, mais peuvent également inclure un élément `value`. Nous les représentons donc comme un tableau de longueur 17. Nous appelons ces tableaux à 17 éléments des "nœuds de branches".
+Nous désignerons une unité atomique d'un arbre radix (p. ex. un seul caractère hexadécimal ou un nombre binaire de 4 bits) par le terme "nibble". En parcourant un chemin un nibble à la fois, comme décrit ci-dessus, les nœuds peuvent au maximum faire référence à 16 enfants, mais ils incluent un élément `value`. Nous les représentons donc comme un tableau de longueur 17. Nous appelons ces tableaux à 17 éléments des "nœuds de branches".
 
-## Arbre de Merkle de Patricia {#merkle-patricia-trees}
+## Trie de Merkle-Patricia {#merkle-patricia-trees}
 
-Cependant, les arbres radix ont une limitation majeure : ils sont inefficaces. Si vous voulez stocker une seule liaison `(path, value)` où le chemin est, comme dans Ethereum, long de 64 caractères (nombre de nibbles dans `bytes32`), vous aurez besoin de plus d'un kilooctet d'espace supplémentaire pour stocker un niveau par caractère, et chaque consultation ou suppression prendra les 64 étapes complètes. L'arbre de Patricia présenté dans ce qui suit résout ce problème.
+Cependant, les arbres radix ont une limitation majeure : ils sont inefficaces. Si vous voulez stocker une seule liaison `(path, value)` où le chemin, comme dans Ethereum, est long de 64 caractères (le nombre de nibbles dans `bytes32`), vous aurez besoin de plus d'un kilooctet d'espace supplémentaire pour stocker un niveau par caractère, et chaque consultation ou suppression prendra les 64 étapes complètes. L'arbre de Patricia présenté dans ce qui suit résout ce problème.
 
 ### Optimisation {#optimization}
 
 Un nœud dans un arbre de Merkle Patricia correspond à l'un des éléments suivants :
 
-1.  `NULL` (représenté comme une chaîne vide)
-2.  `branch` Un nœud de 17 éléments `[ v0 ... v15, vt ]`
-3.  `leaf` Un nœud de 2 éléments `[ encodedPath, value ]`
-4.  `extension` Un nœud de 2 éléments `[ encodedPath, key ]`
+1. `NULL` (représenté par la chaîne vide)
+2. `branche` Un nœud de 17 éléments `[ v0 ...` v15, vt ]`
+3. `feuille` Un nœud de 2 éléments `[ encodedPath, value ]`
+4. `extension` Un nœud de 2 éléments `[ encodedPath, key ]`
 
-Avec 64 chemins de caractères, il est inévitable qu'après avoir traversé les premières couches de l'arbre, vous atteigniez un nœud où aucun chemin divergent n'existe sur au moins une partie de la descente. Pour éviter de devoir créer jusqu'à 15 nœuds `NULL` épars le long du chemin, nous raccourcissons la descente en créant un nœud `extension` de la forme `[ encodedPath, key ]`, où `encodedPath` contient le "chemin partiel" à sauter (à l'aide d'un codage compact décrit ci-dessous), et où la `key` est destinée à la consultation suivante de la base de données.
+Avec 64 chemins de caractères, il est inévitable qu'après avoir traversé les premières couches de l'arbre, vous atteigniez un nœud où aucun chemin divergent n'existe sur au moins une partie de la descente. Pour éviter d'avoir à créer jusqu'à 15 nœuds `NULL` épars le long du chemin, nous raccourcissons la descente en créant un nœud `extension` de la forme `[ encodedPath, key ]`, où `encodedPath` contient le "chemin partiel" à sauter (en utilisant un encodage compact décrit ci-dessous), et où la `key` est pour la prochaine consultation de la base de données.
 
-Pour un nœud `feuille`, qui peut être marqué par un drapeau dans la première pièce du `encodedPath`, le chemin encode tous les fragments de chemin du nœud précédent et nous pouvons consulter la `valeur` directement.
+Pour un nœud `leaf`, qui peut être marqué par un indicateur dans le premier nibble de l'`encodedPath`, le chemin encode tous les fragments de chemin du nœud précédent et nous pouvons consulter la `value` directement.
 
 Cette optimisation introduit toutefois une ambiguïté.
 
-Lors de la traversée de chemins en nibbles, nous pourrions nous retrouver avec un nombre impair de nibbles à traverser, mais comme toutes les données sont stockées au format `bytes`, il est possible que le nombre de nibbles à parcourir soit impair. Il n'est pas possible de différencier entre, par exemple, le nibble `1`, et les nibbles `01` (les deux doivent être stockés sous la forme `<01>`). Pour spécifier une longueur impaire, le chemin partiel est précédé d'un drapeau.
+En parcourant les chemins par nibbles, on peut se retrouver avec un nombre impair de nibbles à parcourir, mais comme toutes les données sont stockées au format `bytes`. Il n'est pas possible de différencier, par exemple, le nibble `1` des nibbles `01` (tous deux doivent être stockés sous la forme `<01>`). Pour spécifier une longueur impaire, le chemin partiel est précédé d'un drapeau.
 
-### Spécification : Codage compact d'une séquence hexagonale avec terminateur optionnel {#specification}
+### Spécification : Encodage compact de séquence hexadécimale avec terminateur optionnel {#specification}
 
-Le marquage de la _longueur du chemin partiel restante impaire ou paire_ et de la _feuille ou nœud d'extension_, tel que décrit ci-dessus, se trouve dans le premier élément du chemin partiel de tout nœud à deux éléments. Cela se traduit comme suit :
+Le marquage de la _longueur impaire ou paire du chemin partiel restant_ et du _nœud feuille ou extension_, tel que décrit ci-dessus, se trouve dans le premier nibble du chemin partiel de tout nœud à 2 éléments. Cela se traduit comme suit :
 
-    hex char    bits    |    node type partial     path length
-    ----------------------------------------------------------
-       0        0000    |       extension              even
-       1        0001    |       extension              odd
-       2        0010    |   terminating (leaf)         even
-       3        0011    |   terminating (leaf)         odd
+| char hex | bits | type partiel de nœud                  | longueur de chemin |
+| -------- | ---- | ------------------------------------- | ------------------ |
+| 0        | 0000 | extension                             | pairs              |
+| 1        | 0001 | extension                             | impair             |
+| 2        | 0010 | terminal (feuille) | pairs              |
+| 3        | 0011 | terminal (feuille) | impair             |
 
-Pour une longueur de chemin restante paire (`0` ou `2`), un autre nibble de "remplissage" de `0` suivra toujours.
+Pour une longueur de chemin restante paire (`0` ou `2`), un autre nibble de « remplissage » `0` suivra toujours.
 
-```
+```python
     def compact_encode(hexarray):
         term = 1 if hexarray[-1] == 16 else 0
-        if term: hexarray = hexarray[:-1]
+        if term:
+            hexarray = hexarray[:-1]
         oddlen = len(hexarray) % 2
         flags = 2 * term + oddlen
         if oddlen:
             hexarray = [flags] + hexarray
         else:
             hexarray = [flags] + [0] + hexarray
-        // hexarray now has an even length whose first nibble is the flags.
-        o = ''
-        for i in range(0,len(hexarray),2):
-            o += chr(16 * hexarray[i] + hexarray[i+1])
+        # hexarray now has an even length whose first nibble is the flags.
+        o = ""
+        for i in range(0, len(hexarray), 2):
+            o += chr(16 * hexarray[i] + hexarray[i + 1])
         return o
 ```
 
 Exemples :
 
-```
-    > [ 1, 2, 3, 4, 5, ...]
+```python
+    > [1, 2, 3, 4, 5, ...]
     '11 23 45'
-    > [ 0, 1, 2, 3, 4, 5, ...]
+    > [0, 1, 2, 3, 4, 5, ...]
     '00 01 23 45'
-    > [ 0, f, 1, c, b, 8, 10]
+    > [0, f, 1, c, b, 8, 10]
     '20 0f 1c b8'
-    > [ f, 1, c, b, 8, 10]
+    > [f, 1, c, b, 8, 10]
     '3f 1c b8'
 ```
 
 Voici le code étendu pour obtenir un nœud dans l'arbre de Merkle Patricia :
 
-```
-    def get_helper(node_hash,path):
-        if path == []: return node_hash
-        if node_hash == '': return ''
+```python
+    def get_helper(node_hash, path):
+        if path == []:
+            return node_hash
+        if node_hash == "":
+            return ""
         curnode = rlp.decode(node_hash if len(node_hash) < 32 else db.get(node_hash))
         if len(curnode) == 2:
             (k2, v2) = curnode
             k2 = compact_decode(k2)
-            if k2 == path[:len(k2)]:
-                return get(v2, path[len(k2):])
+            if k2 == path[: len(k2)]:
+                return get(v2, path[len(k2) :])
             else:
-                return ''
+                return ""
         elif len(curnode) == 17:
-            return get_helper(curnode[path[0]],path[1:])
+            return get_helper(curnode[path[0]], path[1:])
 
-    def get(node_hash,path):
+    def get(node_hash, path):
         path2 = []
         for i in range(len(path)):
             path2.push(int(ord(path[i]) / 16))
             path2.push(ord(path[i]) % 16)
         path2.push(16)
-        return get_helper(node_hash,path2)
+        return get_helper(node_hash, path2)
 ```
 
-### Exemple d'arbre {#example-trie}
+### Exemple de trie {#example-trie}
 
-Supposons que nous voulions un tableau contenant quatre paires chemin/valeur `('do', 'verb')`, `('dog', 'puppy')`, `('doge', 'coins')`, `('horse', 'stallion')`.
+Supposons que nous voulions un trie contenant quatre paires chemin/valeur `('do', 'verb')`, `('dog', 'puppy')`, `('doge', 'coins')`, `('horse', 'stallion')`.
 
-Tout d'abord, nous convertissons les chemins et les valeurs en `bytes` (octets). Ci-dessous, les représentations réelles d'octets pour les _chemins_ sont désignées par `<>`, bien que les _valeurs_ soient toujours représentées sous forme de chaînes, désignées par `''`, pour une compréhension plus facile (elles aussi seraient en fait des `octets`) :
+Tout d'abord, nous convertissons les chemins et les valeurs en `bytes`. Ci-dessous, les représentations d'octets réelles pour les _chemins_ sont indiquées par `<>`, bien que les _valeurs_ soient toujours affichées sous forme de chaînes, indiquées par `''`, pour une meilleure compréhension (elles aussi seraient en fait des `bytes`) :
 
 ```
     <64 6f> : 'verb'
@@ -183,38 +186,38 @@ Nous construisons un tel arbre avec les paires clé/valeur suivantes dans la bas
     hashD:    [ <17>, [ <>, <>, <>, <>, <>, <>, [ <35>, 'coins' ], <>, <>, <>, <>, <>, <>, <>, <>, <>, 'puppy' ] ]
 ```
 
-Lorsqu'un nœud est référencé à l'intérieur d'un autre nœud, ce qui est inclus est `H(rlp.encode(node))`, où `H(x) = keccak256(x) if len(x) >= 32 else x` et `rlp.encode` est la fonction d'encodage [RLP](/developers/docs/data-structures-and-encoding/rlp).
+Lorsqu'un nœud est référencé à l'intérieur d'un autre nœud, ce qui est inclus est `keccak256(rlp.encode(node))`, si `len(rlp.encode(node)) >= 32` sinon `node` où `rlp.encode` est la fonction d'encodage [RLP](/developers/docs/data-structures-and-encoding/rlp).
 
-Notez que lors de la mise à jour d'un arbre, on doit stocker la paire clé/valeur `(keccak256(x), x)`dans une table de consultation persistante _si_ le nœud nouvellement créé a une longueur >= 32. Toutefois, si le nœud est plus court que cela, il n'est pas nécessaire de stocker quoi que ce soit, puisque la fonction f(x) = x est réversible.
+Notez que lors de la mise à jour d'un trie, il faut stocker la paire clé/valeur `(keccak256(x), x)` dans une table de recherche persistante _si_ le nœud nouvellement créé a une longueur >= 32. Toutefois, si le nœud est plus court que cela, il n'est pas nécessaire de stocker quoi que ce soit, puisque la fonction f(x) = x est réversible.
 
-## Les arbres sur Ethereum {#tries-in-ethereum}
+## Tries dans Ethereum {#tries-in-ethereum}
 
 Tous les arbres Merkle dans la couche d'exécution d'Ethereum font appel à un arbre de Merkle Patricia.
 
 L'en-tête d'un bloc comporte trois racines issues de trois de ces arbres.
 
-1.  stateRoot
-2.  transactionsRoot
-3.  receiptsRoot
+1. stateRoot
+2. transactionsRoot
+3. receiptsRoot
 
-### Arbre d'état {#state-trie}
+### Trie d'état {#state-trie}
 
-Il n'existe qu'un seul arbre d'état global, qui est mis à jour à chaque fois qu'un client traite un bloc. Dans celui-ci, un `path` est toujours : `keccak256(ethereumAddress)` et une `value` est toujours : `rlp(ethereumAccount)`. Plus précisément, un `account` ethereum est un tableau de 4 éléments de `[nonce,balance,storageRoot,codeHash]`. À ce stade, il convient de noter que ce `storageRoot` est la racine d'un autre arbre Patricia :
+Il n'existe qu'un seul arbre d'état global, qui est mis à jour à chaque fois qu'un client traite un bloc. Dans celui-ci, un `path` est toujours : `keccak256(ethereumAddress)` et une `value` est toujours : `rlp(ethereumAccount)`. Plus précisément, un `account` Ethereum est un tableau de 4 éléments de `[nonce,solde,storageRoot,codeHash]`. À ce stade, il convient de noter que ce `storageRoot` est la racine d'un autre trie de Patricia :
 
-### Arbre de stockage {#storage-trie}
+### Trie de stockage {#storage-trie}
 
-C'est dans l'arbre de stockage que se situent _toutes_ les données du contrat. Chaque compte dispose d'un arbre de stockage distinct. Pour récupérer des valeurs à des positions de stockage spécifiques et à une adresse donnée, l'adresse de stockage, la position entière des données stockées dans le stockage et l'ID du bloc sont nécessaires. Ceux-ci peuvent ensuite être transmis comme arguments à la fonction `eth_getStorageAt` définie dans l'API JSON-RPC, par exemple pour récupérer les données dans le créneau de stockage 0 pour l'adresse `0x295a70b2de5e3953354a6a8344e616ed314d7251` :
+Le trie de stockage est l'endroit où se trouvent _toutes_ les données de contrat. Chaque compte dispose d'un arbre de stockage distinct. Pour récupérer des valeurs à des positions de stockage spécifiques et à une adresse donnée, l'adresse de stockage, la position entière des données stockées dans le stockage et l'ID du bloc sont nécessaires. Ceux-ci peuvent ensuite être transmis comme arguments à la fonction `eth_getStorageAt` définie dans l'API JSON-RPC, par exemple pour récupérer les données dans le créneau de stockage 0 pour l'adresse `0x295a70b2de5e3953354a6a8344e616ed314d7251` :
 
-```
+```bash
 curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545
 
 {"jsonrpc":"2.0","id":1,"result":"0x00000000000000000000000000000000000000000000000000000000000004d2"}
 
 ```
 
-La récupération d'autres éléments dans le stockage est un peu plus complexe, car il faut d'abord calculer la position dans l'arbre de stockage. La position est calculée comme le hachage `keccak256` de l'adresse et de la position de stockage, toutes deux complétées à gauche par des zéros jusqu'à une longueur de 32 octets. Par exemple, la position des données dans l'emplacement de stockage 1 pour l'adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298` est :
+La récupération d'autres éléments dans le stockage est un peu plus complexe, car il faut d'abord calculer la position dans l'arbre de stockage. La position est calculée comme le hachage `keccak256` de l'adresse et de la position de stockage, tous deux complétés à gauche par des zéros jusqu'à une longueur de 32 octets. Par exemple, la position des données dans le créneau de stockage 1 pour l'adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298` est :
 
-```
+```python
 keccak256(decodeHex("000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001"))
 ```
 
@@ -229,35 +232,35 @@ undefined
 
 Le `path` est donc `keccak256(<6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9>)`. On peut maintenant l'utiliser pour récupérer les données de l'arbre de stockage comme précédemment :
 
-```
+```bash
 curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"], "id": 1}' localhost:8545
 
 {"jsonrpc":"2.0","id":1,"result":"0x000000000000000000000000000000000000000000000000000000000000162e"}
 ```
 
-Note : le `storageRoot` pour un compte Ethereum est vide par défaut s'il ne s'agit pas d'un compte de contrat.
+Remarque : le `storageRoot` d'un compte Ethereum est vide par défaut s'il ne s'agit pas d'un compte de contrat.
 
-### Arbre de transactions {#transaction-trie}
+### Trie de transactions {#transaction-trie}
 
-Il existe un arbre de transactions distinct pour chaque bloc, qui stocke à nouveau les paires `(key, value)` . Un chemin ici est : `rlp(transactionIndex)` qui représente la clé qui correspond à une valeur déterminée par :
+Il existe un trie de transactions distinct pour chaque bloc, qui stocke à nouveau des paires `(clé, valeur)`. Ici, un chemin est : `rlp(transactionIndex)`, qui représente la clé correspondant à une valeur déterminée par :
 
-```
+```python
 if legacyTx:
   value = rlp(tx)
 else:
   value = TxType | encode(tx)
 ```
 
-Plus d'informations à ce sujet peuvent être trouvées dans la documentation [EIP 2718](https://eips.ethereum.org/EIPS/eip-2718).
+De plus amples informations à ce sujet peuvent être trouvées dans la documentation de l'[EIP 2718](https://eips.ethereum.org/EIPS/eip-2718).
 
-### Arbre de reçus {#receipts-trie}
+### Trie des reçus {#receipts-trie}
 
-Chaque bloc a son propre arbre de reçus. Un `path` ici est : `rlp(transactionIndex)`. `transactionIndex` est son indice dans le bloc dans lequel il est inclus. Les arbres de reçus ne sont jamais mis à jour. De la même manière que pour les arbres de transactions, il existe des reçus actuels et des reçus hérités. Pour interroger un reçu spécifique dans la liste des reçus, l'indice de la transaction dans son bloc, les charges du reçu et le type de transaction sont nécessaires. Le reçu retourné peut être de type `Reçu` qui est défini comme la concaténation de `TransactionType` et `ReceiptPayload` ou il peut être de type `LegacyReceipt` qui est défini comme `rlp([statut, cumulativeGasUsed, logsBloom, logs])`.
+Chaque bloc a son propre arbre de reçus. Un `path` ici est : `rlp(transactionIndex)`. `transactionIndex` est son indice dans le bloc où il a été inclus. Les arbres de reçus ne sont jamais mis à jour. De la même manière que pour les arbres de transactions, il existe des reçus actuels et des reçus hérités. Pour interroger un reçu spécifique dans la liste des reçus, l'indice de la transaction dans son bloc, les charges du reçu et le type de transaction sont nécessaires. Le reçu retourné peut être de type `Receipt`, qui est défini comme la concaténation de `TransactionType` et `ReceiptPayload` ou il peut être de type `LegacyReceipt` qui est défini comme `rlp([status, cumulativeGasUsed, logsBloom, logs])`.
 
-Plus d'informations à ce sujet peuvent être trouvées dans la documentation [EIP 2718](https://eips.ethereum.org/EIPS/eip-2718).
+De plus amples informations à ce sujet peuvent être trouvées dans la documentation de l'[EIP 2718](https://eips.ethereum.org/EIPS/eip-2718).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Modification de l'arbre de Merkle Patricia — Comment Ethereum sauvegarde un état](https://medium.com/codechain/modified-merkle-patricia-trie-how-ethereum-saves-a-state-e6d7555078dd)
-- [Le Merkling sur Ethereum](https://blog.ethereum.org/2015/11/15/merkling-in-ethereum)
-- [Comprendre l'arbre Ethereum](https://easythereentropy.wordpress.com/2014/06/04/understanding-the-ethereum-trie/)
+- [Modified Merkle Patricia Trie — Comment Ethereum sauvegarde un état](https://medium.com/codechain/modified-merkle-patricia-trie-how-ethereum-saves-a-state-e6d7555078dd)
+- [Le Merkling dans Ethereum](https://blog.ethereum.org/2015/11/15/merkling-in-ethereum/)
+- [Comprendre le trie d'Ethereum](https://easythereentropy.wordpress.com/2014/06/04/understanding-the-ethereum-trie/)
diff --git a/public/content/translations/fr/developers/docs/data-structures-and-encoding/rlp/index.md b/public/content/translations/fr/developers/docs/data-structures-and-encoding/rlp/index.md
index 863e915fb81..763e7748388 100644
--- a/public/content/translations/fr/developers/docs/data-structures-and-encoding/rlp/index.md
+++ b/public/content/translations/fr/developers/docs/data-structures-and-encoding/rlp/index.md
@@ -1,24 +1,24 @@
 ---
-title: Sérialisation du préfixe de longueur récursive (RLP)
-description: Une définition de l'encodage rlp dans la couche d'exécution d'Ethereum.
+title: "Sérialisation du préfixe de longueur récursive (RLP)"
+description: "Une définition de l'encodage rlp dans la couche d'exécution d'Ethereum."
 lang: fr
 sidebarDepth: 2
 ---
 
-La sérialisation Recursive Length Prefix (RLP) est largement utilisée dans les clients d'exécution d'Ethereum. RLP normalise le transfert de données entre les nœuds dans un format peu encombrant. L'objectif de RLP est d'encoder des tableaux de données binaires arbitrairement imbriqués. RLP est la principale méthode d'encodage utilisée pour sérialiser les objets dans la couche d'exécution d'Ethereum. L'objectif principal du RLP est d'encoder la structure ; à l'exception des entiers positifs, le RLP délègue l'encodage de types de données spécifiques (par exemple, les chaînes, les flottants) à des protocoles d'ordre supérieur. Les nombres entiers positifs doivent être représentés sous forme binaire big-endian sans zéros initiaux (ce qui rend la valeur entière zéro équivalente à un tableau d'octets vide). Les entiers positifs désérialisés avec des zéros en tête doivent être traités comme invalides par tout protocole d'ordre supérieur utilisant RLP.
+La sérialisation Recursive Length Prefix (RLP) est largement utilisée dans les clients d'exécution d'Ethereum. RLP normalise le transfert de données entre les nœuds dans un format peu encombrant. L'objectif de RLP est d'encoder des tableaux de données binaires arbitrairement imbriqués. RLP est la principale méthode d'encodage utilisée pour sérialiser les objets dans la couche d'exécution d'Ethereum. L'objectif principal du RLP est d'encoder la structure ; à l'exception des entiers positifs, le RLP délègue l'encodage de types de données spécifiques (par ex., les chaînes, les flottants) à des protocoles d'ordre supérieur. Les nombres entiers positifs doivent être représentés sous forme binaire big-endian sans zéros initiaux (ce qui rend la valeur entière zéro équivalente à un tableau d'octets vide). Les entiers positifs désérialisés avec des zéros en tête doivent être traités comme invalides par tout protocole d'ordre supérieur utilisant RLP.
 
-Plus d'informations dans [le livre jaune Ethereum (Annexe B)](https://ethereum.github.io/yellowpaper/paper.pdf#page=19).
+Plus d'informations dans [le papier jaune d'Ethereum (Annexe B)](https://ethereum.github.io/yellowpaper/paper.pdf#page=19).
 
 Pour utiliser RLP afin d'encoder un dictionnaire, les deux formes canoniques suggérées sont :
 
-- utiliser `[[k1,v1],[k2,v2]...]` avec des clés rangées en ordre lexicographique
+- utilisez `[[k1,v1],[k2,v2]...]` avec les clés par ordre lexicographique
 - utiliser l'encodage Patricia Tree de haut niveau comme le fait Ethereum
 
 ## Définition {#definition}
 
 La fonction d'encodage RLP prend en charge un item. Un item est défini comme suit：
 
-- une chaîne (c'est-à-dire un tableau d'octets) est un item
+- une chaîne (c.-à-d. un tableau d'octets) est un élément
 - une liste d'items est un item
 - un nombre entier positif est un item
 
@@ -27,7 +27,7 @@ Par exemple, tous les éléments suivants sont des items :
 - une chaîne vide ;
 - la chaîne contenant le mot "cat" ;
 - une liste contenant un nombre quelconque de chaînes ;
-- et une structure de données plus complexe comme `["cat", ["puppy", "cow"], "horse", [[]], "pig", [""], "sheep"]`.
+- et des structures de données plus complexes comme `["cat", ["puppy", "cow"], "horse", [[]], "pig", [""], "sheep"]`.
 - le nombre `100`
 
 Notez que dans le contexte du reste de cette page, "chaîne" signifie "un certain nombre d'octets de données binaires" ; aucun codage spécial n'est utilisé et aucune connaissance du contenu des chaînes n'est impliquée (à l'exception de la règle contre les nombres entiers positifs non minimaux).
@@ -35,12 +35,12 @@ Notez que dans le contexte du reste de cette page, "chaîne" signifie "un certai
 L'encodage RLP est défini comme suit :
 
 - Pour un entier positif, il est converti en tableau d'octets le plus court dont l'interprétation big-endian est l'entier, puis encodé en tant que chaîne de caractères selon les règles ci-dessous.
-- Pour un seul octet dont la valeur se situe dans la plage `[0x00, 0x7f]` (décimal `[0, 127]`), cet octet est son propre codage RLP.
-- Sinon, si une chaîne a une longueur de 0 à 55 octets, le codage RLP consiste en un seul octet de valeur **0x80** (déc. 128) plus la longueur de la chaîne, suivi de la chaîne. La plage du premier octet est donc `[0x80, 0xb7]` (déc. `[128, 183]`).
-- Si une chaîne de caractères a une longueur de plus de 55 octets, le codage RLP consiste en un seul octet ayant la valeur **0xb7** (déc. 183) plus la longueur en octets de la longueur de la chaîne de caractères sous forme binaire, suivie de la longueur de la chaîne de caractères, suivie de la chaîne de caractères. Par exemple, une chaîne de 1024 octets de long sera codée sous la forme `\xb9\x04\x00` (déc. `185, 4, 0`) suivie de la chaîne. Ici, `0xb9` (183 + 2 = 185) comme premier octet, suivi des 2 octets `0x0400` (déc. 1024) qui indiquent la longueur de la chaîne réelle. La plage du premier octet est donc `[0xb8, 0xbf]` (déc. `[184, 191]`).
+- Pour un seul octet dont la valeur se situe dans l'intervalle `[0x00, 0x7f]` (décimal `[0, 127]`), cet octet est son propre codage RLP.
+- Sinon, si une chaîne a une longueur de 0 à 55 octets, le codage RLP consiste en un seul octet de valeur **0x80** (déc. 128) plus la longueur de la chaîne, suivi de la chaîne. L'intervalle du premier octet est donc `[0x80, 0xb7]` (déc. `[128, 183]`).
+- Si une chaîne est plus longue que 55 octets, le codage RLP consiste en un seul octet de valeur **0xb7** (déc. 183) plus la longueur en octets de la longueur de la chaîne sous forme binaire, suivi de la longueur de la chaîne, puis de la chaîne elle-même. Par exemple, une chaîne de 1024 octets de long serait encodée en `\xb9\x04\x00` (déc. `185, 4, 0`) suivi de la chaîne. Ici, `0xb9` (183 + 2 = 185) est le premier octet, suivi des 2 octets `0x0400` (déc. 1024) qui indiquent la longueur de la chaîne réelle. L'intervalle du premier octet est donc `[0xb8, 0xbf]` (déc. `[184, 191]`).
 - Si une chaîne de caractères a une longueur de 2^64 octets ou plus, elle ne peut pas être encodée.
-- Si la charge utile totale d'une liste (c'est-à-dire la longueur combinée de tous ses éléments codés RLP) est de 0 à 55 octets, le codage RLP consiste en un seul octet de valeur **0xc0** plus la longueur de la charge utile, suivi de la concaténation des codages RLP des éléments. La plage du premier octet est donc `[0xc0, 0xf7]` (déc. `[192, 247]`).
-- Si la charge utile totale d'une liste est supérieure à 55 octets, le codage RLP consiste en un seul octet ayant la valeur **0xf7** plus la longueur en octets de la charge utile sous forme binaire, suivie de la longueur de la charge utile, suivie de la concaténation des codages RLP des éléments. La plage du premier octet est donc `[0xf8, 0xff]` (déc. `[248, 255]`).
+- Si la charge utile totale d'une liste (c.-à-d. la longueur combinée de tous ses éléments encodés en RLP) est comprise entre 0 et 55 octets, le codage RLP consiste en un seul octet de valeur **0xc0** plus la longueur de la charge utile, suivi de la concaténation des encodages RLP des éléments. L'intervalle du premier octet est donc `[0xc0, 0xf7]` (déc. `[192, 247]`).
+- Si la charge utile totale d'une liste a une longueur de plus de 55 octets, le codage RLP consiste en un seul octet de valeur **0xf7** plus la longueur en octets de la longueur de la charge utile sous forme binaire, suivi de la longueur de la charge utile, puis de la concaténation des encodages RLP des éléments. L'intervalle du premier octet est donc `[0xf8, 0xff]` (déc. `[248, 255]`).
 
 En matière de code, cela donne :
 
@@ -62,7 +62,7 @@ def encode_length(L, offset):
     elif L < 256**8:
          BL = to_binary(L)
          return chr(len(BL) + offset + 55) + BL
-     raise Exception("input too long")
+    raise Exception("input too long")
 
 def to_binary(x):
     if x == 0:
@@ -74,38 +74,38 @@ def to_binary(x):
 
 - la chaîne de caractères "dog" = [ 0x83, 'd', 'o', 'g' ]
 - la liste [ "cat", "dog" ] = `[ 0xc8, 0x83, 'c', 'a', 't', 0x83, 'd', 'o', 'g' ]`
-- la chaîne de caractères vide ('null') = `[ 0x80 ]`
+- la chaîne vide ('null') = `[ 0x80 ]`
 - la liste vide = `[ 0xc0 ]`
 - l'entier 0 = `[ 0x80 ]`
 - l'octet '\\x00' = `[ 0x00 ]`
 - l'octet '\\x0f' = `[ 0x0f ]`
 - les octets '\\x04\\x00' = `[ 0x82, 0x04, 0x00 ]`
-- la [représentation théorique en théorie des ensembles](https://fr.wikipedia.org/wiki/Construction_des_entiers_naturels) de trois, `[ [], [[]], [ [], [[]] ] ] = [ 0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc0, 0xc1, 0xc0 ]`
-- la chaîne de caractères "Lorem ipsum dolor sit amet, consectetur adipisicing elit" = `[ 0xb8, 0x38, 'L', 'o', 'r', 'e', 'm', ' ', ... , 'e', 'l', 'i', 't' ]`
+- la [représentation en théorie des ensembles](http://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers) de trois, `[ [], [[]], [ [], [[]] ] ] = [ 0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0 ]`
+- la chaîne "Lorem ipsum dolor sit amet, consectetur adipisicing elit" = `[ 0xb8, 0x38, 'L', 'o', 'r', 'e', 'm', ' ', ...` , 'e', 'l', 'i', 't' ]`
 
 ## Décodage RLP {#rlp-decoding}
 
 Selon les règles et le processus d'encodage RLP, l'entrée du décodage RLP est considérée comme un tableau de données binaires. Le processus de décodage RLP est le suivant :
 
-1.  en fonction du premier octet (c'est-à-dire le préfixe) des données d'entrée et du décodage du type de données, de la longueur des données et du décalage ;
+1. en se basant sur le premier octet (c.-à-d. le préfixe) des données d'entrée pour décoder le type de données, la longueur des données réelles et le décalage ;
 
-2.  selon le type et le décalage des données, décoder les données en conséquence, en respectant la règle de codage minimal pour les nombres entiers positifs ;
+2. selon le type et le décalage des données, décoder les données en conséquence, en respectant la règle de codage minimal pour les nombres entiers positifs ;
 
-3.  continue à décoder le reste de l'entrée ;
+3. continue à décoder le reste de l'entrée ;
 
 Parmi elles, les règles de décodage des types de données et du décalage sont les suivantes :
 
-1.  les données sont une chaîne de caractères si le premier octet (c'es-à-dire le préfixe) se trouve dans l'intervalle [0x00, 0x7f] et si la chaîne de caractères est le premier octet lui-même t;
+1. les données correspondent à une chaîne si l'intervalle du premier octet (c.-à-d. le préfixe) est [0x00, 0x7f], et la chaîne est alors exactement le premier octet lui-même ;
 
-2.  les données sont une chaîne de caractères si le premier octet se trouve dans l'intervalle [0x80, 0xb7] et si la chaîne de caractères, dont la longueur est égale au premier octet moins 0x80, suit le premier octet ;
+2. les données sont une chaîne de caractères si le premier octet se trouve dans l'intervalle [0x80, 0xb7] et si la chaîne de caractères, dont la longueur est égale au premier octet moins 0x80, suit le premier octet ;
 
-3.  les données sont une chaîne de caractères si le premier octet se trouve dans l'intervalle [0xb8, 0xbf] et si la longueur de la chaîne de caractères, dont la longueur en octet est égale au premier octet moins 0xb7, suit le premier octet et si la chaîne de caractères suit la longueur de la chaîne ;
+3. les données sont une chaîne de caractères si le premier octet se trouve dans l'intervalle [0xb8, 0xbf] et si la longueur de la chaîne de caractères, dont la longueur en octet est égale au premier octet moins 0xb7, suit le premier octet et si la chaîne de caractères suit la longueur de la chaîne ;
 
-4.  les données sont une liste si l'intervalle du premier octet est [0xc0, 0xf7], et la concaténation des codages RLP de tous les éléments de la liste dont la charge utile totale est égale au premier octet moins 0xc0 suit le premier octet ;
+4. les données sont une liste si l'intervalle du premier octet est [0xc0, 0xf7], et la concaténation des codages RLP de tous les éléments de la liste dont la charge utile totale est égale au premier octet moins 0xc0 suit le premier octet ;
 
-5.  les données sont une liste si l'intervalle du premier octet est [0xf8, 0xff], et la charge utile totale de la liste dont la longueur est égale au premier octet moins 0xf7 suit le premier octet, et la concaténation des codages RLP de tous les éléments de la liste suit la charge utile totale de la liste ;
+5. les données sont une liste si l'intervalle du premier octet est [0xf8, 0xff], et la charge utile totale de la liste dont la longueur est égale au premier octet moins 0xf7 suit le premier octet, et la concaténation des codages RLP de tous les éléments de la liste suit la charge utile totale de la liste ;
 
-Dans le code, c'est :
+En matière de code, cela donne :
 
 ```python
 def rlp_decode(input):
@@ -152,10 +152,10 @@ def to_integer(b):
     return ord(substr(b, -1)) + to_integer(substr(b, 0, -1)) * 256
 ```
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [RLP et Ethereum](https://medium.com/coinmonks/data-structure-in-ethereum-episode-1-recursive-length-prefix-rlp-encoding-decoding-d1016832f919)
-- [Les dessous d'Ethereum : RLP](https://medium.com/coinmonks/ethereum-under-the-hood-part-3-rlp-decoding-df236dc13e58)
+- [Le RLP dans Ethereum](https://medium.com/coinmonks/data-structure-in-ethereum-episode-1-recursive-length-prefix-rlp-encoding-decoding-d1016832f919)
+- [Ethereum sous le capot : RLP](https://medium.com/coinmonks/ethereum-under-the-hood-part-3-rlp-decoding-df236dc13e58)
 - [Coglio, A. (2020). Préfixe de longueur récursive d'Ethereum dans ACL2. arXiv preprint arXiv:2009.13769.](https://arxiv.org/abs/2009.13769)
 
 ## Sujets connexes {#related-topics}
diff --git a/public/content/translations/fr/developers/docs/data-structures-and-encoding/ssz/index.md b/public/content/translations/fr/developers/docs/data-structures-and-encoding/ssz/index.md
index cf1cd509cd2..7cd3193eea6 100644
--- a/public/content/translations/fr/developers/docs/data-structures-and-encoding/ssz/index.md
+++ b/public/content/translations/fr/developers/docs/data-structures-and-encoding/ssz/index.md
@@ -9,14 +9,14 @@ sidebarDepth: 2
 
 ## Comment fonctionne SSZ ? {#how-does-ssz-work}
 
-### La sérialisation {#serialization}
+### Sérialisation {#serialization}
 
 SSZ est un schéma de sérialisation qui n'est pas auto-décrit, mais qui repose sur un schéma qui doit être connu à l'avance. L'objectif de la sérialisation SSZ est de représenter des objets d'une complexité arbitraire sous forme de chaînes d'octets. Il s'agit d'un processus très simple pour les "types de base". L'élément est simplement converti en octets hexadécimaux. Les types de base comprennent :
 
 - Les entiers non signés
 - Les booléens
 
-Pour les types "composites" complexes, la sérialisation est plus compliquée car le type composite contient plusieurs éléments, ces derniers étant susceptibles d'avoir des types différents ou des tailles différentes, ou les deux. Lorsque ces objets ont tous une longueur fixe (c'est-à-dire que la taille des éléments sera toujours constante, quelles que soient leurs valeurs réelles), la sérialisation est simplement une conversion de chaque élément du type composite ordonné en bytestrings little-endian. Ces bytestrings sont liés entre eux. L'objet sérialisé contient la représentation bytelist des éléments de longueur fixe dans le même ordre que celui dans lequel ils apparaissent dans l'objet désérialisé.
+Pour les types "composites" complexes, la sérialisation est plus compliquée car le type composite contient plusieurs éléments, ces derniers étant susceptibles d'avoir des types différents ou des tailles différentes, ou les deux. Lorsque ces objets ont tous une longueur fixe (c'est-à-dire que la taille des éléments sera toujours constante, quelles que soient leurs valeurs réelles), la sérialisation est simplement une conversion de chaque élément du type composite ordonné en chaînes d'octets petit-boutistes. Ces bytestrings sont liés entre eux. L'objet sérialisé contient la représentation bytelist des éléments de longueur fixe dans le même ordre que celui dans lequel ils apparaissent dans l'objet désérialisé.
 
 Pour les types de longueur variable, les données réelles sont remplacées par une valeur "offset" (de décalage) dans la position de cet élément dans l'objet sérialisé. Les données réelles sont ajoutées à un amas à la fin de l'objet sérialisé. La valeur de décalage est l'indice du début des données réelles dans l'amas, agissant comme un pointeur vers les octets concernés.
 
@@ -44,14 +44,14 @@ L'exemple ci-dessous illustre comment le décalage fonctionne pour un conteneur
 
 ```
 
-`serialized` aurait la structure suivante (ici, elle n'est paddée que sur 4 bits, alors qu'elle est paddée sur 32 bits dans la réalité, et en gardant la représentation `int` pour plus de clarté) :
+`serialized` aurait la structure suivante (complétée sur seulement 4 bits ici, mais sur 32 bits en réalité, et en conservant la représentation `int` pour plus de clarté) :
 
 ```
 [37, 0, 0, 0, 55, 0, 0, 0, 16, 0, 0, 0, 22, 0, 0, 0, 1, 2, 3, 4]
 ------------  -----------  -----------  -----------  ----------
       |             |            |           |            |
-   number1       number2    offset for    number 3    value for
-                              vector                   vector
+   number1       number2    décalage pour   number3      valeur pour
+                              vector                     vector
 
 ```
 
@@ -59,11 +59,11 @@ divisé sur différentes lignes pour plus de clarté :
 
 ```
 [
-  37, 0, 0, 0,  # little-endian encoding of `number1`.
-  55, 0, 0, 0,  # little-endian encoding of `number2`.
-  16, 0, 0, 0,  # The "offset" that indicates where the value of `vector` starts (little-endian 16).
-  22, 0, 0, 0,  # little-endian encoding of `number3`.
-  1, 2, 3, 4,   # The actual values in `vector`.
+  37, 0, 0, 0,  # codage petit-boutiste de `number1`.
+  55, 0, 0, 0,  # codage petit-boutiste de `number2`.
+  16, 0, 0, 0,  # Le « décalage » qui indique où commence la valeur de `vector` (petit-boutiste 16).
+  22, 0, 0, 0,  # codage petit-boutiste de `number3`.
+  1, 2, 3, 4,   # Les valeurs réelles dans `vector`.
 ]
 ```
 
@@ -71,54 +71,54 @@ Il s'agit encore d'une simplification - les nombres entiers et les zéros prése
 
 ```
 [
-  10100101000000000000000000000000  # little-endian encoding of `number1`
-  10110111000000000000000000000000  # little-endian encoding of `number2`.
-  10010000000000000000000000000000  # The "offset" that indicates where the value of `vector` starts (little-endian 16).
-  10010110000000000000000000000000  # little-endian encoding of `number3`.
-  10000001100000101000001110000100   # The actual value of the `bytes` field.
+  10100101000000000000000000000000  # codage petit-boutiste de `number1`
+  10110111000000000000000000000000  # codage petit-boutiste de `number2`.
+  10010000000000000000000000000000  # Le « décalage » qui indique où commence la valeur de `vector` (petit-boutiste 16).
+  10010110000000000000000000000000  # codage petit-boutiste de `number3`.
+  10000001100000101000001110000100   # La valeur réelle du champ `bytes`.
 ]
 ```
 
 Ainsi, les valeurs réelles des types à longueur variable sont stockées dans un amas à la fin de l'objet sérialisé, et leurs décalages stockés dans leurs positions correctes dans la liste ordonnée des champs.
 
-Il existe également des cas particuliers qui nécessitent un traitement spécifique, comme le type `BitList` qui nécessite l'ajout d'un plafond de longueur pendant la sérialisation et son retrait pendant la désérialisation. Tous les détails sont disponibles dans le [specSSZ](https://github.com/ethereum/consensus-specs/blob/master/ssz/simple-serialize.md).
+Il existe également des cas particuliers qui nécessitent un traitement spécifique, comme le type `BitList` qui nécessite l'ajout d'un plafond de longueur pendant la sérialisation et son retrait pendant la désérialisation. Tous les détails sont disponibles dans les [spécifications SSZ](https://github.com/ethereum/consensus-specs/blob/master/ssz/simple-serialize.md).
 
-### La désérialisation {#deserialization}
+### Désérialisation {#deserialization}
 
 La désérialisation de cet objet nécessite le <b>schéma</b>. Le schéma définit la disposition précise des données sérialisées afin que chaque élément spécifique puisse être désérialisé à partir d'un blob d'octets en un objet significatif dont les éléments ont le type, la valeur, la taille et la position appropriés. Ce schéma indique au désérialiseur quelles sont les valeurs réelles et quelles sont les valeurs décalées. Tous les noms de champs disparaissent lorsqu'un objet est sérialisé, mais sont réintégrés lors de la désérialisation selon le schéma.
 
-Voir [ssz.dev](https://www.ssz.dev/overview) pour une explication interactive à ce sujet.
+Consultez [ssz.dev](https://www.ssz.dev/overview) pour une explication interactive à ce sujet.
 
-## La Merkleisation {#merkleization}
+## Merkleisation {#merkleization}
 
 Cet objet sérialisé SSZ peut ensuite être merkléisé, c'est-à-dire transformé en une représentation en arbre de Merkle des mêmes données. Pour commencer, on détermine le nombre de morceaux de 32 octets dans l'objet sérialisé. Ce sont les "feuilles" de l'arbre. Le nombre total de feuilles doit être une puissance de 2 pour que le hachage des feuilles produise finalement une racine unique de l'arbre de hachage. Si ce n'est pas naturellement le cas, des feuilles supplémentaires contenant 32 octets de zéros sont ajoutées. De manière schématique :
 
 ```
-        hash tree root
+        racine de l'arbre de hachage
             /     \
            /       \
           /         \
          /           \
-   hash of leaves  hash of leaves
-     1 and 2         3 and 4
+   hachage des feuilles  hachage des feuilles
+      1 et 2             3 et 4
       /   \            /  \
      /     \          /    \
     /       \        /      \
- leaf1     leaf2  leaf3     leaf4
+ feuille1  feuille2  feuille3  feuille4
 ```
 
 Il existe également des cas où les feuilles de l'arbre ne se répartissent pas naturellement de manière égale comme dans l'exemple ci-dessus. Par exemple, la feuille 4 pourrait être un conteneur avec plusieurs éléments qui nécessitent une "profondeur" supplémentaire à ajouter à l'arbre de Merkle, créant ainsi un arbre inégal.
 
-Au lieu de nous référer à ces éléments de l'arbre comme feuille X, nœud X, etc., nous pouvons leur donner des indices généralisés, en commençant par la racine = 1 et en comptant de gauche à droite sur chaque niveau. Il s'agit de l'indice généralisé expliqué ci-dessus. Chaque élément dans la liste sérialisée a un index généralisé égal à `2**profondeur + idx`, où idx est sa position indexée à partir de zéro dans l'objet sérialisé et la profondeur est le nombre de niveaux dans l'arbre de Merkle, qui peut être déterminé comme le logarithme en base deux du nombre d'éléments (feuilles).
+Au lieu de nous référer à ces éléments de l'arbre comme feuille X, nœud X, etc., nous pouvons leur donner des indices généralisés, en commençant par la racine = 1 et en comptant de gauche à droite sur chaque niveau. Il s'agit de l'indice généralisé expliqué ci-dessus. Chaque élément de la liste sérialisée a un index généralisé égal à `2**depth + idx` où `idx` est sa position à indexation nulle dans l'objet sérialisé et `depth` est le nombre de niveaux dans l'arbre de Merkle, qui peut être déterminé comme le logarithme en base deux du nombre d'éléments (feuilles).
 
 ## Indices généralisés {#generalized-indices}
 
-Un indice généralisé est un nombre entier qui représente un nœud dans un arbre de Merkle binaire où chaque nœud a un index généralisé `2 ** depth + index in row`.
+Un index généralisé est un entier qui représente un nœud dans un arbre de Merkle binaire où chaque nœud a un index généralisé `2 ** depth + index in row`.
 
 ```
-        1           --depth = 0  2**0 + 0 = 1
-    2       3       --depth = 1  2**1 + 0 = 2, 2**1+1 = 3
-  4   5   6   7     --depth = 2  2**2 + 0 = 4, 2**2 + 1 = 5...
+        1           --profondeur = 0  2**0 + 0 = 1
+    2       3       --profondeur = 1  2**1 + 0 = 2, 2**1+1 = 3
+  4   5   6   7     --profondeur = 2  2**2 + 0 = 4, 2**2 + 1 = 5...
 
 ```
 
@@ -126,12 +126,13 @@ Cette représentation permet d'obtenir un indice de nœud pour chaque donnée de
 
 ## Preuves multiples {#multiproofs}
 
-Fournir la liste des indices généralisés représentant un élément spécifique nous permet de le vérifier par rapport à la racine de l'arbre de hachage. Cette racine est notre version acceptée de la réalité. Toute donnée qui nous est fournie peut être vérifiée par rapport à cette réalité en l'insérant au bon endroit dans l'arbre de Merkle (déterminé par son index généralisé) et en observant que la racine reste constante. La spécification contient [ici](https://github.com/ethereum/consensus-specs/blob/master/ssz/merkle-proofs.md#merkle-multiproofs) des fonctions qui montrent comment calculer l'ensemble minimal de nœuds requis pour vérifier le contenu d'un ensemble particulier d'indices généralisés.
+Fournir la liste des indices généralisés représentant un élément spécifique nous permet de le vérifier par rapport à la racine de l'arbre de hachage. Cette racine est notre version acceptée de la réalité. Toute donnée qui nous est fournie peut être vérifiée par rapport à cette réalité en l'insérant au bon endroit dans l'arbre de Merkle (déterminé par son index généralisé) et en observant que la racine reste constante. La spécification contient des fonctions [ici](https://github.com/ethereum/consensus-specs/blob/master/ssz/merkle-proofs.md#merkle-multiproofs) qui montrent comment calculer l'ensemble minimal de nœuds requis pour vérifier le contenu d'un ensemble particulier d'indices généralisés.
 
-Par exemple, pour vérifier les données de l'indice 9 dans l'arbre ci-dessous, nous avons besoin du hachage des données aux indices 8, 9, 5, 3, 1. Le hachage de (8,9) devrait être égal au hachage (4), qui est haché avec 5 pour produire 2, qui est haché avec 3 pour produire la racine de l'arbre 1. Si des données incorrectes étaient fournies pour 9, la racine changerait - nous le détecterions et échouerions à vérifier la branche.
+Par exemple, pour vérifier les données de l'indice 9 dans l'arbre ci-dessous, nous avons besoin du hachage des données aux indices 8, 9, 5, 3, 1.
+Le hachage de (8,9) devrait être égal au hachage (4), qui est haché avec 5 pour produire 2, qui est haché avec 3 pour produire la racine de l'arbre 1. Si des données incorrectes étaient fournies pour 9, la racine changerait - nous le détecterions et échouerions à vérifier la branche.
 
 ```
-* = data required to generate proof
+* = données requises pour générer la preuve
 
                     1*
           2                      3*
@@ -140,10 +141,10 @@ Par exemple, pour vérifier les données de l'indice 9 dans l'arbre ci-dessous,
 
 ```
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Mise à jour Ethereum : SSZ](https://eth2book.info/altair/part2/building_blocks/ssz)
-- [Mise à jour Ethereum : Merkleisation](https://eth2book.info/altair/part2/building_blocks/merkleization)
+- [Mise à niveau d'Ethereum : SSZ](https://eth2book.info/altair/part2/building_blocks/ssz)
+- [Mise à niveau d'Ethereum : Merkleisation](https://eth2book.info/altair/part2/building_blocks/merkleization)
 - [Implémentations SSZ](https://github.com/ethereum/consensus-specs/issues/2138)
-- [Calculeur SSZ](https://simpleserialize.com/)
+- [Calculateur SSZ](https://simpleserialize.com/)
 - [SSZ.dev](https://www.ssz.dev/)
diff --git a/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md b/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md
index 2cd63ca5c3d..8376ef8eb5e 100644
--- a/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md
+++ b/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md
@@ -1,6 +1,6 @@
 ---
-title: Définition du stockage secret Web3
-description: Définition formelle du stockage secret Web3
+title: "Définition du stockage secret Web3"
+description: "Définition formelle du stockage secret Web3"
 lang: fr
 sidebarDepth: 2
 ---
diff --git a/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md b/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
new file mode 100644
index 00000000000..4d5bd8f2941
--- /dev/null
+++ b/public/content/translations/fr/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
@@ -0,0 +1,195 @@
+---
+title: "Définition du stockage secret Web3"
+description: "Définition formelle du stockage secret Web3"
+lang: fr
+sidebarDepth: 2
+---
+
+Pour que votre application fonctionne sur Ethereum, vous pouvez utiliser l'objet web3 fourni par la bibliothèque web3.js. Il communique à un nœud local par le biais des appels RPC. [web3](https://github.com/ethereum/web3.js/) fonctionne avec n'importe quel nœud Ethereum qui expose une couche RPC.
+
+`web3` contient l'objet `eth` - web3.eth.
+
+```js
+var fs = require("fs")
+var recognizer = require("ethereum-keyfile-recognizer")
+
+fs.readFile("keyfile.json", (err, data) => {
+  var json = JSON.parse(data)
+  var result = recognizer(json)
+})
+
+/** résultat
+ *               [ 'web3', 3 ]   fichier de clés web3 (v3)
+ *  [ 'ethersale', undefined ]   fichier de clés Ethersale
+ *                        null     fichier de clés invalide
+ */
+```
+
+Ce document présente la **version 3** de la Définition du Stockage Secret Web3.
+
+## Définition {#definition}
+
+L'encodage et le décodage du fichier restent en grande partie inchangés depuis la version 1, sauf que l'algorithme de cryptage n'est plus fixé à AES-128-CBC (AES-128-CTR est maintenant le minimum requis). La plupart des significations/algorithmes sont similaires à la version 1, à l'exception du `mac`, qui correspond au SHA3 (keccak-256) de la concaténation du deuxième bloc de 16 octets de la clé dérivée avec le `ciphertext` complet.
+
+Les fichiers de clés secrètes sont stockés directement dans `~/.web3/keystore` (pour les systèmes de type Unix) et `~/AppData/Web3/keystore` (pour Windows). Leur nom est libre, mais une bonne convention est d'utiliser `<uuid>.json`, où `<uuid>` est l'UUID de 128 bits attribué à la clé secrète (un proxy qui préserve la confidentialité pour l'adresse de la clé secrète).
+
+Tous ces fichiers ont un mot de passe associé. Pour dériver la clé secrète d'un fichier `.json` donné, dérivez d'abord la clé de chiffrement du fichier. Pour ce faire, prenez le mot de passe du fichier et passez-le dans une fonction de dérivation de clé, comme le décrit la clé `kdf`. Les paramètres statiques et dynamiques, dépendants de KDF, de la fonction KDF sont décrits dans la clé `kdfparams`.
+
+PBKDF2 doit cependant être pris en charge par toutes les implémentations minimalement conformes, désignées par :
+
+- `kdf` : `pbkdf2`
+
+Pour PBKDF2, les kdfparams incluent :
+
+- `prf` : Doit être `hmac-sha256` (pourra être étendu à l'avenir) ;
+- `c` : nombre d'itérations ;
+- `salt` : sel passé à PBKDF ;
+- `dklen` : longueur de la clé dérivée. Doit être >= 32.
+
+Une fois que la clé du fichier a été dérivée, elle doit être vérifiée par la dérivation du MAC. Le MAC doit être calculé comme le hachage SHA3 (keccak-256) du tableau d'octets formé par la concaténation du deuxième bloc de 16 octets de la clé dérivée avec le contenu de la clé `ciphertext`, c'est-à-dire :
+
+```js
+KECCAK(DK[16..31] ++ <ciphertext>)
+```
+
+(où `++` est l'opérateur de concaténation)
+
+Cette valeur doit être comparée au contenu de la clé `mac` ; si elles sont différentes, un autre mot de passe doit être demandé (ou l'opération annulée).
+
+Une fois la clé du fichier vérifiée, le texte chiffré (la clé `ciphertext` dans le fichier) peut être déchiffré à l'aide de l'algorithme de chiffrement symétrique spécifié par la clé `cipher` et paramétré par la clé `cipherparams`. Si la taille de la clé dérivée et la taille de la clé de l'algorithme ne correspondent pas, les octets zéro les plus à droite de la clé dérivée doivent être utilisés comme clé de l'algorithme.
+
+Toutes les implémentations minimalement conformes doivent supporter l'algorithme AES-128-CTR, désigné par :
+
+- `cipher` : `aes-128-ctr`
+
+Ce procédé de chiffrement prend les paramètres suivants, donnés comme clés de la clé des paramètres de chiffrement :
+
+- `iv` : vecteur d'initialisation de 128 bits pour le chiffrement.
+
+La clé pour le chiffrement correspond aux 16 premiers octets de la clé dérivée, c'est-à-dire `DK[0..15]`.
+
+La création/Le cryptage d'une clé secrète doit être essentiellement l'inverse de ces instructions. Assurez-vous que l'`uuid`, le `salt` et l'`iv` sont bien aléatoires.
+
+En plus du champ `version`, qui doit servir d'identifiant « en dur » de la version, les implémentations peuvent également utiliser `minorversion` pour suivre les modifications plus petites et sans rupture de compatibilité du format.
+
+## Vecteurs de test {#test-vectors}
+
+Détails :
+
+- `Adresse` : `008aeeda4d805471df9b2a5b0f38a0c3bcba786b`
+- `ICAP` : `XE542A5PZHH8PYIZUBEJEO0MFWRAPPIL67`
+- `UUID` : `3198bc9c-6672-5ab3-d9954942343ae5b6`
+- `Mot de passe` : `testpassword`
+- `Secret` : `7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d`
+
+### PBKDF2-SHA-256 {#PBKDF2-SHA-256}
+
+Vecteur de test utilisant `AES-128-CTR` et `PBKDF2-SHA-256` :
+
+Contenu du fichier `~/.web3/keystore/3198bc9c-6672-5ab3-d9954942343ae5b6.json` :
+
+```json
+{
+  "crypto": {
+    "cipher": "aes-128-ctr",
+    "cipherparams": {
+      "iv": "6087dab2f9fdbbfaddc31a909735c1e6"
+    },
+    "ciphertext": "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46",
+    "kdf": "pbkdf2",
+    "kdfparams": {
+      "c": 262144,
+      "dklen": 32,
+      "prf": "hmac-sha256",
+      "salt": "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd"
+    },
+    "mac": "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2"
+  },
+  "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+  "version": 3
+}
+```
+
+**Intermédiaires** :
+
+`Clé dérivée` : `f06d69cdc7da0faffb1008270bca38f5e31891a3a773950e6d0fea48a7188551`
+`Corps MAC` : `e31891a3a773950e6d0fea48a71885515318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46`
+`MAC` : `517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2`
+`Clé de chiffrement` : `f06d69cdc7da0faffb1008270bca38f5`
+
+### Scrypt {#scrypt}
+
+Test de vecteur en utilisant AES-128-CTR et Scrypt :
+
+```json
+{
+  "crypto": {
+    "cipher": "aes-128-ctr",
+    "cipherparams": {
+      "iv": "740770fce12ce862af21264dab25f1da"
+    },
+    "ciphertext": "dd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2",
+    "kdf": "scrypt",
+    "kdfparams": {
+      "dklen": 32,
+      "n": 262144,
+      "p": 1,
+      "r": 8,
+      "salt": "25710c2ccd7c610b24d068af83b959b7a0e5f40641f0c82daeb1345766191034"
+    },
+    "mac": "337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c"
+  },
+  "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+  "version": 3
+}
+```
+
+**Intermédiaires** :
+
+`Clé dérivée` : `7446f59ecc301d2d79bc3302650d8a5cedc185ccbb4bf3ca1ebd2c163eaa6c2d`
+`Corps MAC` : `edc185ccbb4bf3ca1ebd2c163eaa6c2ddd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2`
+`MAC` : `337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c`
+`Clé de chiffrement` : `7446f59ecc301d2d79bc3302650d8a5c`
+
+## Modifications par rapport à la version 1 {#alterations-from-v2}
+
+Cette version corrige plusieurs incohérences avec la version 1 publiée [ici](https://github.com/ethereum/homestead-guide/blob/master/old-docs-for-reference/go-ethereum-wiki.rst/Passphrase-protected-key-store-spec.rst). En bref, il s'agit de :
+
+- La capitalisation est injustifiée et incohérente (Scrypt minuscule, Kdf mixte, Mac majuscule).
+- Adresse inutile et compromettant la vie privée.
+- `Salt` est intrinsèquement un paramètre de la fonction de dérivation de clé et mérite d'y être associé, et non à la crypto en général.
+- _SaltLen_ inutile (il suffit de le dériver de Salt).
+- La fonction de dérivation de clé est donnée, mais l'algorithme de crypto n'est pas spécifié.
+- `Version` est intrinsèquement numérique, mais c'est une chaîne de caractères (la gestion de versions structurée serait possible avec une chaîne, mais peut être considérée comme hors de portée pour un format de fichier de configuration qui change rarement).
+- `KDF` et `cipher` sont théoriquement des concepts frères, mais ils sont organisés différemment.
+- Le `MAC` est calculé à l'aide d'une donnée insensible aux espaces ( !).
+
+Des modifications ont été apportées au format pour donner le fichier suivant, équivalent sur le plan fonctionnel à l'exemple donné sur la page précédemment citée :
+
+```json
+{
+  "crypto": {
+    "cipher": "aes-128-cbc",
+    "ciphertext": "07533e172414bfa50e99dba4a0ce603f654ebfa1ff46277c3e0c577fdc87f6bb4e4fe16c5a94ce6ce14cfa069821ef9b",
+    "cipherparams": {
+      "iv": "16d67ba0ce5a339ff2f07951253e6ba8"
+    },
+    "kdf": "scrypt",
+    "kdfparams": {
+      "dklen": 32,
+      "n": 262144,
+      "p": 1,
+      "r": 8,
+      "salt": "06870e5e6a24e183a5c807bd1c43afd86d573f7db303ff4853d135cd0fd3fe91"
+    },
+    "mac": "8ccded24da2e99a11d48cda146f9cc8213eb423e2ea0d8427f41c3be414424dd",
+    "version": 1
+  },
+  "id": "0498f19a-59db-4d54-ac95-33901b4f1870",
+  "version": 2
+}
+```
+
+## Modifications par rapport à la version 2 {#alterations-from-v2}
+
+La version 2 était une implémentation précoce C++ comportant un certain nombre d'anomalies. Tous les éléments essentiels restent inchangés.
diff --git a/public/content/translations/fr/developers/docs/design-and-ux/dex-design-best-practice/index.md b/public/content/translations/fr/developers/docs/design-and-ux/dex-design-best-practice/index.md
index 0ff53041b88..c611350092a 100644
--- a/public/content/translations/fr/developers/docs/design-and-ux/dex-design-best-practice/index.md
+++ b/public/content/translations/fr/developers/docs/design-and-ux/dex-design-best-practice/index.md
@@ -1,6 +1,6 @@
 ---
-title: Bonnes pratiques de conception en matière d'échange décentralisé (DEX)
-description: Un guide expliquant les décisions UX/UI pour l'échange de jetons.
+title: "Bonnes pratiques de conception en matière d'échange décentralisé (DEX)"
+description: "Un guide expliquant les décisions UX/UI pour l'échange de jetons."
 lang: fr
 ---
 
@@ -167,7 +167,7 @@ Au final, cela ne fait probablement pas une grande différence en termes de conv
 
 Il a été intéressant de voir la mode changer avec le temps. Uniswap avait initialement placé le jeton à gauche, mais l'a ensuite déplacé à droite. Sushiswap a également fait ce changement lors d'une mise à jour de son design. La plupart des protocoles, mais pas tous, ont suivi cette tendance.
 
-Les conventions en matière financière font que l'on place traditionnellement le symbole monétaire avant le chiffre, par exemple, $50, €50, £50, mais nous disons 50 dollars, 50 euros, 50 livres.
+Les conventions financières placent traditionnellement le symbole de la devise avant le nombre (par exemple, 50 $, 50 €, 50 £), mais nous _disons_ 50 dollars, 50 euros, 50 livres.
 
 Pour l'utilisateur de base, en particulier quelqu'un qui lit de gauche à droite, de haut en bas, un jeton à droite semble probablement plus naturel.
 
@@ -205,7 +205,7 @@ Le bouton peut également être **associé à l'action** qui doit être effectu
 
 ![Message d'erreur affiché dans le principal appel à l'action](./17.png)
 
-### Construisez le vôtre avec ce fichier Figma {#build-your-own-with-this-figma-file}
+## Construisez le vôtre avec ce fichier Figma {#build-your-own-with-this-figma-file}
 
 Grâce au travail acharné de plusieurs protocoles, la conception des DEX s'est beaucoup améliorée. Nous savons de quelles informations l'utilisateur a besoin, de quelle manière nous devons les présenter et comment rendre le flux aussi fluide que possible.
 Nous espérons que cet article vous offrira un aperçu solide des principes UX.
diff --git a/public/content/translations/fr/developers/docs/design-and-ux/heuristics-for-web3/index.md b/public/content/translations/fr/developers/docs/design-and-ux/heuristics-for-web3/index.md
index 3024440ebf3..b4189398b4f 100644
--- a/public/content/translations/fr/developers/docs/design-and-ux/heuristics-for-web3/index.md
+++ b/public/content/translations/fr/developers/docs/design-and-ux/heuristics-for-web3/index.md
@@ -1,6 +1,6 @@
 ---
 title: 7 heuristiques pour la conception d'interfaces Web3
-description: Principes pour améliorer la convivialité du Web3
+description: "Principes pour améliorer la convivialité du Web3"
 lang: fr
 ---
 
diff --git a/public/content/translations/fr/developers/docs/design-and-ux/index.md b/public/content/translations/fr/developers/docs/design-and-ux/index.md
index 67d883cc81c..546636e9705 100644
--- a/public/content/translations/fr/developers/docs/design-and-ux/index.md
+++ b/public/content/translations/fr/developers/docs/design-and-ux/index.md
@@ -1,6 +1,6 @@
 ---
 title: Design et UX dans le web3
-description: Introduction à l'UX design, une méthode de conception centrée sur l'utilisateur et des études sur les développements de l'écosystème du Web3 et l'Ethereum
+description: "Introduction à l'UX design, une méthode de conception centrée sur l'utilisateur et des études sur les développements de l'écosystème du Web3 et l'Ethereum"
 lang: fr
 ---
 
@@ -8,207 +8,62 @@ Vous êtes novice en matière de design sur Ethereum ? Vous êtes au bon endroit
 
 Vous avez d'abord besoin d'une compréhension plus élémentaire du web3 ? Consultez le [**Centre d'apprentissage**](/learn/).
 
-## Commencez par une étude sur les utilisateurs {#start-with-user-research}
+## Commencer par la recherche utilisateur {#start-with-user-research}
 
-Un design efficace va au-delà de la création d'interfaces utilisateur visuellement attrayantes. Il s'agit d'acquérir une compréhension approfondie des besoins, des objectifs et des facteurs déterminants de l'utilisateur. C'est pourquoi nous recommandons vivement à tous les designers d'adopter un processus de design, tel que le [**processus du double diamant**](https://en.wikipedia.org/wiki/Double_Diamond_(design_process_model)), afin de s'assurer que leur travail est délibéré et intentionnel.
+Un design efficace va au-delà de la création d'interfaces utilisateur visuellement attrayantes. Il s'agit d'acquérir une compréhension approfondie des besoins, des objectifs et des facteurs déterminants de l'utilisateur. C'est pourquoi nous recommandons vivement à tous les designers d'adopter un processus de design, tel que le [**processus du double diamant**](https://en.wikipedia.org/wiki/Double_Diamond_\(design_process_model\)), afin de s'assurer que leur travail est délibéré et intentionnel.
 
-- [Le web3 a besoin de plus de chercheurs et de designers UX](https://blog.akasha.org/akasha-conversations-9-web3-needs-more-ux-researchers-and-designers) - Un aperçu de la maturité actuelle du design
-- [Un guide simple sur la recherche sur l'UX dans le web3](https://uxplanet.org/a-complete-guide-to-ux-research-for-web-3-0-products-d6bead20ebb1) - Guide sur comment faire de la recherche
-- [Comment aborder les décisions d'UX dans le Web3](https://archive.devcon.org/archive/watch/6/data-empathy-how-to-approach-ux-decisions-in-web3/) - Un aperçu rapide de la recherche quantitative et qualitative et des différences entre les deux (vidéo, 6 min)
-- [Être un chercheur UX dans le Web3](https://medium.com/@georgia.rakusen/what-its-like-being-a-user-researcher-in-web3-6a4bcc096849) - Un point de vue personnel sur ce que c'est que d'être un chercheur UX dans le Web3
+- [Le Web3 a besoin de plus de chercheurs et de designers UX](https://blog.akasha.org/akasha-conversations-9-web3-needs-more-ux-researchers-and-designers) - Un aperçu de la maturité actuelle du design
+- [Un guide simple pour la recherche UX dans le web3](https://uxplanet.org/a-complete-guide-to-ux-research-for-web-3-0-products-d6bead20ebb1) - Guide simple sur la manière de mener des recherches
+- [Comment aborder les décisions UX dans le Web3](https://archive.devcon.org/archive/watch/6/data-empathy-how-to-approach-ux-decisions-in-web3/) - Un bref aperçu de la recherche quantitative et qualitative et des différences entre les deux (vidéo, 6 min)
+- [Être un chercheur UX dans le web3](https://medium.com/@georgia.rakusen/what-its-like-being-a-user-researcher-in-web3-6a4bcc096849) - Un point de vue personnel sur ce que c'est que d'être un chercheur UX dans le web3
 
-## Études et recherches dans le Web3 {#research-in-web3}
+## Études de recherche dans le web3 {#research-in-web3}
 
 Il s'agit d'une liste organisée de recherches par des utilisateurs sur le Web3 qui peut aider à prendre des décisions de conception de produit ou servir d'inspiration pour mener sa propre étude.
 
-<table spaces-before="0">
-  <tr>
-    <th align="left">
-      Domaine d'intervention
-    </th>
-    
-    <th align="left">
-      Nom
-    </th>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="success">Intégration crypto</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://reown.com/blog/unveiling-walletconnects-consumer-crypto-report">Le Reown Pulse 2024 : Sentiment et utilisation des consommateurs de crypto</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="success">Intégration crypto</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://docs.google.com/presentation/d/1s2OPSH5sMJzxRYaJSSRTe8W2iIoZx0PseIV-WeZWD1s/edit?usp=sharing">CRADL : UX pour crypto-monnaie</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="success">Intégration crypto</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://docs.google.com/presentation/d/1R9nFuzA-R6SxaGCKhoMbE4Vxe0JxQSTiHXind3LVq_w/edit?usp=sharing">CRADL : Intégration vers la crypto-monnaie</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="success">Intégration crypto</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://github.com/patestevao/BitcoinUX-report/blob/master/report.md">Rapport sur l'UX de Bitcoin</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="success">Intégration crypto</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://consensys.io/insight-report/web3-and-crypto-global-survey-2023">ConSensys : L'état de la perception du Web3 dans le monde en 2023</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="success">Intégration crypto</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://drive.google.com/file/d/1VuaQP4QSaQxR5ddQKTMGI0b0rWdP7uGn/view">NEAR : Accélérer le processus d'adoption</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag status="tag">Staking</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://storage.googleapis.com/rocketpool/RocketPool-NodeOperator-UX-Report-Jan-2024.pdf">OpenUX : Expérience utilisateur des opérateurs de nœuds Rocket Pool</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag status="tag">Staking</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://lookerstudio.google.com/u/0/reporting/cafcee00-e1af-4148-bae8-442a88ac75fa/page/p_ja2srdhh2c?s=hmbTWDh9hJo">La mise en jeu : Tendances clés, points à retenir et prédictions - Eth Staker</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag status="tag">Staking</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://github.com/threshold-network/UX-User-Research/blob/main/Multi-App%20Staking%20(MAS)/iterative-user-study/MAS%20Iterative%20User%20Study.pdf">Mise en jeu multi-applications</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="error">DAO</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://blog.aragon.org/2022-dao-research-update/">Mise à jour de la recherche DAO 2022 : Que nécessitent les développeurs de DAO ?</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag status="error">DeFi</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://github.com/threshold-network/UX-User-Research/tree/main/Keep%20Coverage%20Pool">Pools de garanties</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag status="error">DeFi</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://cdn2.hubspot.net/hubfs/4795067/ConsenSys%20Codefi-Defi%20User%20ResearchReport.pdf">ConSensys : Rapport de recherche sur les utilisateurs de DeFi en 2022</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid">Métavers</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://www.politico.com/f/?id=00000187-7685-d820-a7e7-7e85d1420000">Métaverse : Rapport de recherche sur les utilisateurs</a>
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid">Métavers</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://archive.devcon.org/archive/watch/6/going-on-safari-researching-users-in-the-metaverse/?tab=YouTube">Partir en safari : Rechercher des utilisateurs dans le métaverse</a> (vidéo, 27 min)
-    </td>
-  </tr>
-  
-  <tr>
-    <td align="left">
-      <Tag variant="solid" status="tag">Ethereum.org UX stats</Tag>
-    </td>
-    
-    <td align="left">
-      <a href="https://lookerstudio.google.com/reporting/0a189a7c-a890-40db-a5c6-009db52c81c9">Tableau de bord de l'enquête sur la convivialité et la satisfaction des utilisateurs - Ethereum.org</a>
-    </td>
-  </tr>
-</table>
-
-## Conception pour le web3 {#design-for-web3}
-
-- [Manuel de conception UX pour le Web3](https://web3ux.design/) - Guide pratique pour concevoir des applications Web3
-- [Principes de Design Web3](https://medium.com/@lyricalpolymath/web3-design-principles-f21db2f240c1) - Un cadre de règles UX pour les dapps basées sur la blockchain
-- [Principes de Design Blockchain](https://medium.com/design-ibm/blockchain-design-principles-599c5c067b6e) - Leçons apprises par l'équipe de design blockchain chez IBM
+| Domaine d'intervention                                         | Nom                                                                                                                                                                                                                              |
+| :------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <Tag variant="solid" status="success">Intégration crypto</Tag> | [The Reown Pulse 2024 : Sentiment et utilisation des cryptomonnaies par les consommateurs](https://reown.com/blog/unveiling-walletconnects-consumer-crypto-report)                                               |
+| <Tag variant="solid" status="success">Intégration crypto</Tag> | [CRADL : L'UX dans la cryptomonnaie](https://docs.google.com/presentation/d/1s2OPSH5sMJzxRYaJSSRTe8W2iIoZx0PseIV-WeZWD1s/edit?usp=sharing)                                                                       |
+| <Tag variant="solid" status="success">Intégration crypto</Tag> | [CRADL : Intégration à la cryptomonnaie](https://docs.google.com/presentation/d/1R9nFuzA-R6SxaGCKhoMbE4Vxe0JxQSTiHXind3LVq_w/edit?usp=sharing)                                                                   |
+| <Tag variant="solid" status="success">Intégration crypto</Tag> | [Rapport sur l'UX de Bitcoin](https://github.com/patestevao/BitcoinUX-report/blob/master/report.md)                                                                                                                              |
+| <Tag variant="solid" status="success">Intégration crypto</Tag> | [ConSensys : État de la perception du Web3 dans le monde en 2023](https://consensys.io/insight-report/web3-and-crypto-global-survey-2023)                                                                        |
+| <Tag variant="solid" status="success">Intégration crypto</Tag> | [NEAR : Accélérer le parcours vers l'adoption](https://drive.google.com/file/d/1VuaQP4QSaQxR5ddQKTMGI0b0rWdP7uGn/view)                                                                                           |
+| <Tag status="tag">Mise en jeu</Tag>                            | [OpenUX : UX de l'opérateur de nœud Rocket Pool](https://storage.googleapis.com/rocketpool/RocketPool-NodeOperator-UX-Report-Jan-2024.pdf)                                                                       |
+| <Tag status="tag">Mise en jeu</Tag>                            | [Mise en jeu : tendances clés, points à retenir et prédictions - Eth Staker](https://lookerstudio.google.com/u/0/reporting/cafcee00-e1af-4148-bae8-442a88ac75fa/page/p_ja2srdhh2c?s=hmbTWDh9hJo)                 |
+| <Tag status="tag">Mise en jeu</Tag>                            | [Mise en jeu multi-applications](https://github.com/threshold-network/UX-User-Research/blob/main/Multi-App%20Staking%20\(MAS\)/iterative-user-study/MAS%20Iterative%20User%20Study.pdf)                                          |
+| <Tag variant="solid" status="error">DAO</Tag>                  | [Mise à jour de la recherche sur les DAO 2022 : de quoi les constructeurs de DAO ont-ils besoin ?](https://blog.aragon.org/2022-dao-research-update/)                                                            |
+| <Tag status="error">DeFi</Tag>                                 | [Pools de couverture](https://github.com/threshold-network/UX-User-Research/tree/main/Keep%20Coverage%20Pool)                                                                                                                    |
+| <Tag status="error">DeFi</Tag>                                 | [ConSensys : Rapport de recherche sur les utilisateurs de la DeFi 2022](https://cdn2.hubspot.net/hubfs/4795067/ConsenSys%20Codefi-Defi%20User%20ResearchReport.pdf)                                              |
+| <Tag variant="solid">Métavers</Tag>                            | [Métavers : Rapport de recherche sur les utilisateurs](https://www.politico.com/f/?id=00000187-7685-d820-a7e7-7e85d1420000)                                                                                      |
+| <Tag variant="solid">Métavers</Tag>                            | [Partir en safari : rechercher des utilisateurs dans le métavers](https://archive.devcon.org/archive/watch/6/going-on-safari-researching-users-in-the-metaverse/?tab=YouTube) (vidéo, 27 min) |
+
+## Design pour le web3 {#design-for-web3}
+
+- [Manuel de conception UX pour le Web3](https://web3ux.design/) - Guide pratique pour la conception d'applications Web3
+- [Principes de design du Web3](https://medium.com/@lyricalpolymath/web3-design-principles-f21db2f240c1) - Un cadre de règles UX pour les dapps basées sur la blockchain
+- [Principes de design de la blockchain](https://medium.com/design-ibm/blockchain-design-principles-599c5c067b6e) - Leçons apprises par l'équipe de design blockchain d'IBM
 - [Neueux.com](https://neueux.com/apps) - Bibliothèque d'interface utilisateur de flux d'utilisateurs avec diverses options de filtrage
-- [La crise de la convivialité du Web3 : Ce que vous DEVEZ savoir !](https://www.youtube.com/watch?v=oBSXT_6YDzg) - Une table ronde sur les pièges de la construction de projets axés sur les développeurs (vidéo, 34 minutes)
+- [La crise de l'utilisabilité du Web3 : ce que vous DEVEZ savoir !](https://www.youtube.com/watch?v=oBSXT_6YDzg) - Une table ronde sur les pièges de la création de projets axés sur les développeurs (vidéo, 34 min)
 
-## Premiers pas {#getting-started}
+## Pour commencer {#getting-started}
 
 - [Heuristiques pour le Web3](/developers/docs/design-and-ux/heuristics-for-web3/) - 7 heuristiques pour la conception d'interfaces Web3
-- [Conseils pratiques de conception de DEX](/developers/docs/design-and-ux/dex-design-best-practice/) - Un guide pour la conception des échanges décentralisés
+- [Meilleures pratiques de conception des DEX](/developers/docs/design-and-ux/dex-design-best-practice/) - Un guide pour la conception d'échanges décentralisés
 
-## Études de cas dans la conception pour le web3 {#design-case-studies}
+## Études de cas de design Web3 {#design-case-studies}
 
-- [Deep Work Studio](https://deepwork.studio/case-studies/)
+- [Deep Work Studio](https://www.deepwork.studio/case-studies)
 - [Vendre un NFT sur OpenSea](https://builtformars.com/case-studies/opensea)
-- [Analyse UX du portefeuille : comment les portefeuilles doivent changer](https://www.youtube.com/watch?v=oTpuxYj8JWI&ab_channel=ETHDenver) (vidéo, 20 min)
+- [Analyse détaillée de l'UX des portefeuilles : comment les portefeuilles doivent changer](https://www.youtube.com/watch?v=oTpuxYj8JWI&ab_channel=ETHDenver) (vidéo, 20 min)
 
-## Primes pour la conception {#bounties}
+## Primes de design {#bounties}
 
 - [Dework](https://app.dework.xyz/bounties)
-- [Hackathons Buildbox](https://app.buidlbox.io/)
-- [Hackathon ETHGlobal](https://ethglobal.com/)
+- [Hackathons Buidlbox](https://app.buidlbox.io/)
+- [Hackathons ETHGlobal](https://ethglobal.com/)
 
-## Concevoir des DAOs et des communautés {#design-daos-and-communities}
+## DAO et communautés de design {#design-daos-and-communities}
 
 Participez à des organisations professionnelles communautaires ou rejoignez des groupes de designers pour discuter avec d'autres membres de sujets et de tendances liés au design et à la recherche.
 
@@ -217,14 +72,15 @@ Participez à des organisations professionnelles communautaires ou rejoignez des
 - [We3.co](https://we3.co/)
 - [Openux.xyz](https://openux.xyz/)
 
-## Systèmes de design et autres ressources de conception {#design-systems-and-resources}
+## Systèmes de design et autres ressources de design {#design-systems-and-resources}
 
-- [Conception d'Optimism](https://www.figma.com/@optimism) (Figma)
-- [Ethereum.org Conception de system](https://www.figma.com/@ethdotorg) (Figma)
-- [Finity, un système de conception par Polygon](https://www.figma.com/community/file/1073921725197233598/finity-design-system) (Figma)
-- [système de conception Kleros](https://www.figma.com/community/file/999852250110186964/kleros-design-system) (Figma)
-- [système de conception Safe](https://www.figma.com/community/file/1337417127407098506/safe-design-system) (Figma)
-- [Architecture du système ENS](https://thorin.ens.domains/)
-- [Architecture du système Mirror](https://degen-xyz.vercel.app/)
+- [Design d'Optimism](https://www.figma.com/@optimism) (Figma)
+- [Système de design d'Ethereum.org](https://www.figma.com/@ethdotorg) (Figma)
+- [Finity, un système de design par Polygon](https://www.figma.com/community/file/1073921725197233598/finity-design-system) (Figma)
+- [Système de design de Kleros](https://www.figma.com/community/file/999852250110186964/kleros-design-system) (Figma)
+- [Système de design de Safe](https://www.figma.com/community/file/1337417127407098506/safe-design-system) (Figma)
+- [Système de design d'ENS](https://thorin.ens.domains/)
+- [Système de design de Mirror](https://degen-xyz.vercel.app/)
 
-**Les articles et les projets énumérés sur cette page ne sont pas officiellement approuvés** et sont fournis à titre d'information uniquement. Nous ajoutons des liens à cette page en fonction des critères définis dans notre [politique de référencement](/contributing/design/adding-design-resources). Si vous souhaitez que nous ajoutions un projet/article, modifiez cette page sur [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/public/content/developers/docs/design-and-ux/index.md).
+**Les articles et projets listés sur cette page ne constituent pas des approbations officielles et sont fournis à titre informatif uniquement.**
+Nous ajoutons des liens à cette page sur la base des critères de notre [politique de référencement](/contributing/design/adding-design-resources). Si vous souhaitez que nous ajoutions un projet/article, modifiez cette page sur [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/public/content/developers/docs/design-and-ux/index.md).
diff --git a/public/content/translations/fr/developers/docs/development-networks/index.md b/public/content/translations/fr/developers/docs/development-networks/index.md
index 68fc08571bb..cc0d4823184 100644
--- a/public/content/translations/fr/developers/docs/development-networks/index.md
+++ b/public/content/translations/fr/developers/docs/development-networks/index.md
@@ -1,6 +1,8 @@
 ---
-title: Réseaux de développement
-description: "Présentation des réseaux de développement et des outils disponibles pour \nconstruire des applications Ethereum."
+title: "Réseaux de développement"
+description: |-
+  Présentation des réseaux de développement et des outils disponibles pour 
+  construire des applications Ethereum.
 lang: fr
 ---
 
@@ -10,23 +12,23 @@ De la même façon que vous exécuteriez un serveur local sur votre ordinateur p
 
 ## 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.
+Vous devriez 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}
 
 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 ?**
+**Pourquoi ne pas simplement exécuter un nœud Ethereum standard localement ?**
 
-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 :
+Vous _pourriez_ [exécuter un nœud](/developers/docs/nodes-and-clients/#running-your-own-node), mais comme les réseaux de développement sont spécialement conçus pour le développement, ils sont souvent dotés de 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)
+- Alimentation déterministe de votre blockchain locale avec des données (par ex., des comptes avec des soldes en ETH)
 - 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 [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/).
+**Remarque** : La plupart des [cadres de développement](/developers/docs/frameworks/) incluent un réseau de développement intégré. Nous vous recommandons de commencer par un framework pour [configurer votre environnement de développement local](/developers/local-environment/).
 
 ### Réseau Hardhat {#hardhat-network}
 
@@ -35,35 +37,33 @@ Un réseau Ethereum local conçu pour le développement. Il vous permet de dépl
 Le réseau Hardhat est intégré avec Hardhat, un environnement de développement Ethereum pour les professionnels.
 
 - [Site Web](https://hardhat.org/)
-- [GitHub](https://github.com/nomiclabs/hardhat)
+- [GitHub](https://github.com/NomicFoundation/hardhat)
 
-### Chaînes phares locales {#local-beacon-chains}
+### 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/contribution/advanced-topics/setting-up-a-testnet#post-merge-local-testnet/)
 - [Réseau de test local utilisant Lighthouse](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
 
-### Chaînes publiques de test pour Ethereum {#public-beacon-testchains}
+### Chaînes de test Ethereum publiques {#public-beacon-testchains}
 
-Il y a aussi deux implémentations de test publiques maintenues d'Ethereum : Sepolia et Hoodi. Sepolia est le réseau de test standard recommandé pour le développement d'applications, avec un ensemble de validateurs fermé pour une synchronisation rapide. Hoodi est un réseau de test pour la validation et la mise en jeu, qui utilise un ensemble de validateurs ouvert et permet potentiellement à tout le monde de valider.
+Il y a aussi deux implémentations de test publiques maintenues d'Ethereum : Sepolia et Hoodi. Le réseau testnet recommandé avec support à long terme est Hoodi, que tout le monde est libre de valider. Sepolia utilise un ensemble de validateurs avec autorisation, ce qui signifie qu’il n’est pas possible d’ajouter librement de nouveaux validateurs sur cette testnet.
 
-- [Plateforme de lancement de la mise en jeu de Hoodi](https://hoodi.launchpad.ethereum.org/en/)
-- [Site Web de Sepolia](https://sepolia.dev/)
-- [Site Web de Hoodi](https://hoodi.ethpandaops.io/)
+- [Plateforme de lancement de mise en jeu Hoodi](https://hoodi.launchpad.ethereum.org/)
 
-### Pack Ethereum de Kurtosis {#kurtosis}
+### Package Ethereum Kurtosis {#kurtosis}
 
 Kurtosis est un système de construction d'environnements de test multi-conteneurs qui permet aux développeurs de créer localement des instances reproductibles de réseaux de blockchain.
 
 Le pack Ethereum de Kurtosis peut être utilisé pour instancier rapidement un réseau de test Ethereum paramétrable, hautement évolutif, et privé sur Docker ou Kubernetes. Le pack supporte tous les clients majeurs de la couche d'exécution (EL) et de la couche de consensus (CL). Kurtosis gère gracieusement tous les mappages de ports locaux et les connexions de service sur un réseau représentatif à utiliser dans les flux de validation et de test en lien avec l'infrastructure de base d'Ethereum.
 
-- [Pack réseau Ethereum](https://github.com/kurtosis-tech/ethereum-package)
+- [Package réseau Ethereum](https://github.com/kurtosis-tech/ethereum-package)
 - [Site Web](https://www.kurtosis.com/)
 - [GitHub](https://github.com/kurtosis-tech/kurtosis)
 - [Documentation](https://docs.kurtosis.com/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
diff --git a/public/content/translations/fr/developers/docs/ethereum-stack/index.md b/public/content/translations/fr/developers/docs/ethereum-stack/index.md
index 20257e110ac..6390b982dd2 100644
--- a/public/content/translations/fr/developers/docs/ethereum-stack/index.md
+++ b/public/content/translations/fr/developers/docs/ethereum-stack/index.md
@@ -1,50 +1,50 @@
 ---
-title: Introduction à la pile Ethereum
-description: Présentation étape par étape des différentes couches de la pile Ethereum, et comment elles fonctionnent ensemble.
+title: "Introduction à la pile Ethereum"
+description: "Présentation étape par étape des différentes couches de la pile Ethereum, et comment elles fonctionnent ensemble."
 lang: fr
 ---
 
 Comme toute pile logicielle, la pile complète Ethereum varie d'un projet à l'autre en fonction de vos objectifs propres.
 
-Il existe cependant des technologies Ethereum de base qui contribuent à fournir un modèle mental de la façon dont les applications logicielles interagissent avec la blockchain Ethereum. Comprendre les couches de la pile vous permettra d'appréhender les différentes façons d'intégrer Ethereum dans les projets logiciels.
+Il existe cependant des composants de base d'Ethereum qui aident à fournir un modèle mental de la façon dont les applications logicielles interagissent avec la blockchain Ethereum. Comprendre les couches de la pile vous permettra d'appréhender les différentes façons d'intégrer Ethereum dans les projets logiciels.
 
-## Niveau 1: Machine virtuelle Ethereum {#ethereum-virtual-machine}
+## 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 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.
+La [Machine Virtuelle Ethereum (EVM)](/developers/docs/evm/) est l'environnement d'exécution des contrats intelligents sur Ethereum. Tous les contrats intelligents et les changements 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 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.
+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 uniques) codes d'opérations 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, à condition de disposer 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.
+En tant que développeur de dapp, vous n'avez pas besoin d'en savoir beaucoup sur l'EVM, si ce n'est qu'elle existe et qu'elle alimente de manière fiable toutes les applications sur Ethereum sans temps d'arrêt.
 
-## Niveau 2 : Contrats intelligents {#smart-contracts}
+## Niveau 2 : Contrats intelligents {#smart-contracts}
 
-[Les contrats intelligents](/developers/docs/smart-contracts/) sont les programmes exécutables qui tournent sur la blockchain Ethereum.
+Les [contrats intelligents](/developers/docs/smart-contracts/) sont des programmes exécutables qui s'exécutent sur la blockchain Ethereum.
 
-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).
+Les contrats intelligents sont écrits en utilisant 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 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.
+Non seulement les contrats intelligents servent de bibliothèques open source, mais ils sont essentiellement des services d'API ouverts qui fonctionnent en permanence et ne peuvent pas ê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 avoir besoin 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 pour prendre en charge les échanges de jetons. De plus, n'importe qui peut déployer de nouveaux contrats intelligents sur Ethereum afin d'ajouter des fonctionnalités personnalisées pour 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.
 
-## Niveau 3 : Nœuds Ethereum {#ethereum-nodes}
+## Niveau 3 : Nœuds Ethereum {#ethereum-nodes}
 
-Afin qu'une application interagisse avec la blockchain Ethereum, elle doit se connecter à un [nœud Ethereum](/developers/docs/nodes-and-clients/). La connexion à un nœud vous permet de lire les données blockchain et/ou d'envoyer des transactions au réseau.
+Pour qu'une application puisse interagir avec la blockchain Ethereum, elle doit se connecter à un [nœud Ethereum](/developers/docs/nodes-and-clients/). La connexion à un nœud vous permet de lire les données blockchain et/ou d'envoyer des transactions au réseau.
 
-Les nœuds Ethereum sont des ordinateurs exécutant un logiciel : un client Ethereum. Un client est une implémentation d'Ethereum qui vérifie toutes les transactions de chaque bloc, ce qui assure la sécurité du réseau et l'exactitude des données. **Les noeuds Ethereum sont la blockchain Ethereum**. Ils stockent collectivement l'état de la blockchain Ethereum et parviennent à un consensus sur chaque transaction pour faire muter l'état de la blockchain.
+Les nœuds Ethereum sont des ordinateurs exécutant un logiciel : un client Ethereum. Un client est une implémentation d'Ethereum qui vérifie l'ensemble des transactions de chaque bloc, garantissant la sécurité du réseau et l'exactitude des données. **Les noeuds Ethereum sont la blockchain Ethereum**. Ils stockent collectivement l'état de la blockchain Ethereum et parviennent à un consensus sur chaque transaction pour faire muter l'état de la blockchain.
 
-En connectant votre application à un nœud Ethereum (via une spécification [RPC JSON](/developers/docs/apis/json-rpc/)), votre application peut lire les données de la blockchain (comme les soldes de compte utilisateur) et diffuser de nouvelles transactions sur le réseau (comme le transfert d'ETH entre comptes utilisateur ou l'exécution de fonctions de contrats intelligents).
+En connectant votre application à un nœud Ethereum (via [l'API JSON-RPC](/developers/docs/apis/json-rpc/)), votre application peut lire les données de la blockchain (telles que les soldes des comptes utilisateurs) et diffuser de nouvelles transactions sur le réseau (telles que le transfert d'ETH entre les comptes des utilisateurs ou l'exécution de fonctions de contrats intelligents).
 
-## Niveau 4 : API clientes Ethereum {#ethereum-client-apis}
+## Niveau 4 : API des clients Ethereum {#ethereum-client-apis}
 
-De nombreuses bibliothèques pratiques (construites et maintenues par la communauté Open Source Ethereum) permettent à vos applications utilisateur de se connecter à la blockchain Ethereum et de communiquer avec elle.
+De nombreuses bibliothèques pratiques (créées et maintenues par la communauté open source d'Ethereum) permettent à vos applications de se connecter et de communiquer avec la blockchain Ethereum.
 
-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/).
+Si votre application destinée aux utilisateurs est une application Web, vous pouvez choisir d'`npm install` une [API JavaScript](/developers/docs/apis/javascript/) directement dans votre frontend. Ou peut-être choisirez-vous d'implémenter cette fonctionnalité côté serveur, en utilisant 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., la conversion d'ETH en Gwei) afin qu'en tant que développeur, vous puissiez passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous concentrer sur la fonctionnalité spécifique à votre application.
 
-## Niveau 5 : Applications utilisateur {#end-user-applications}
+## Niveau 5 : Applications pour l'utilisateur final {#end-user-applications}
 
 Au niveau supérieur de la pile se trouvent les applications orientées utilisateurs. Ce sont les applications standards que vous utilisez et développez régulièrement : principalement des applis Web et pour mobiles.
 
@@ -52,10 +52,10 @@ Rien ne change dans la façon de développer ces interfaces utilisateur. Souvent
 
 ## Prêt à choisir votre pile ? {#ready-to-choose-your-stack}
 
-Consultez notre guide [Configurer un environnement de développement local](/developers/local-environment/) pour développer votre application Ethereum.
+Consultez notre guide pour [configurer un environnement de développement local](/developers/local-environment/) pour votre application Ethereum.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [L'Architecture d'une application Web 3.0](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
+- [L'architecture d'une application Web 3.0](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/evm/index.md b/public/content/translations/fr/developers/docs/evm/index.md
index 72ebbd90e57..3c03197b2ab 100644
--- a/public/content/translations/fr/developers/docs/evm/index.md
+++ b/public/content/translations/fr/developers/docs/evm/index.md
@@ -1,77 +1,87 @@
 ---
-title: Machine virtuelle Ethereum (EVM)
-description: Introduction à la machine virtuelle Ethereum et en quoi elle concerne l'état, les transactions et les contrats intelligents.
+title: Machine Virtuelle Ethereum (EVM)
+description: "Introduction à la machine virtuelle Ethereum et en quoi elle concerne l'état, les transactions et les contrats intelligents."
 lang: fr
 ---
 
-La machine virtuelle Ethereum (EVM) est un environnement virtuel décentralisé qui exécute le code de manière cohérente et sécurisée sur tous les nœuds Ethereum. Les nœuds exécutent l'EVM qui exécute des contrats intelligents, utilisant du «[gaz](/gas/)» pour mesurer l'effort de calcul requis pour les [opérations](/developers/docs/evm/opcodes/), garantissant une allocation efficace des ressources et la sécurité du réseau.
+La machine virtuelle Ethereum (EVM) est un environnement virtuel décentralisé qui exécute le code de manière cohérente et sécurisée sur tous les nœuds Ethereum. Les nœuds exécutent l'EVM pour exécuter des contrats intelligents, en utilisant le "[gaz](/developers/docs/gas/)" pour mesurer l'effort de calcul requis pour les [opérations](/developers/docs/evm/opcodes/), assurant ainsi une allocation efficace des ressources et la sécurité du réseau.
 
 ## Prérequis {#prerequisites}
 
-Une certaine familiarité avec la terminologie commune en informatique, comme [les octets](https://wikipedia.org/wiki/Byte), [la mémoire](https://wikipedia.org/wiki/Computer_memory), et une [pile](https://wikipedia.org/wiki/Stack_(abstract_data_type)) sont nécessaires pour comprendre l'EVM. Il peut se révéler utile d'être à l'aise avec les concepts de cryptographie/blockchain comme les [fonctions de hachage](https://wikipedia.org/wiki/Cryptographic_hash_function), et [l'arbre de Merkle](https://wikipedia.org/wiki/Merkle_tree).
+Une certaine familiarité avec la terminologie courante en informatique, telle que les [octets](https://wikipedia.org/wiki/Byte), la [mémoire](https://wikipedia.org/wiki/Computer_memory) et une [pile](https://wikipedia.org/wiki/Stack_\(abstract_data_type\)), est nécessaire pour comprendre l'EVM. Il serait également utile d'être à l'aise avec les concepts de la cryptographie et de la blockchain, comme les [fonctions de hachage](https://wikipedia.org/wiki/Cryptographic_hash_function) et l'[arbre de Merkle](https://wikipedia.org/wiki/Merkle_tree).
 
 ## Du registre à la machine d'état {#from-ledger-to-state-machine}
 
 L'analogie avec un « registre distribué » est souvent utilisée pour décrire les blockchains comme Bitcoin, qui permettent l'existence d'une monnaie décentralisée utilisant des outils de cryptographie fondamentaux. Le registre tient un enregistrement des activités devant se conformer à un ensemble de règles, celles-ci régissant ce que quelqu'un peut, ou ne peut pas faire, pour modifier le registre. Par exemple, une adresse Bitcoin ne peut pas dépenser plus de Bitcoin qu'elle n'en a reçu. Ces règles sont appliquées à toutes les transactions sur Bitcoin et de nombreuses autres blockchains.
 
-Alors qu'Ethereum dispose de sa propre cryptomonnaie native (Ether) qui suit presque exactement les mêmes règles intuitives, il offre également une fonction beaucoup plus puissante : [les contrats intelligents](/developers/docs/smart-contracts/). Pour cette fonctionnalité plus complexe, une analogie plus sophistiquée est nécessaire. Au lieu d'un registre distribué, Ethereum est une [machine d'état distribuée](https://wikipedia.org/wiki/Finite-state_machine). L'état d'Ethereum est une grande structure de données qui contient non seulement tous les comptes et tous les soldes, mais aussi une _machine à état_ qui peut changer d'un bloc à l'autre selon un ensemble de règles prédéfinies, et qui peut exécuter du code machine arbitraire. Les règles spécifiques de changement d'état d'un bloc à l'autre sont définies par l'EVM.
+Alors qu'Ethereum dispose de sa propre cryptomonnaie native (l'éther) qui suit presque exactement les mêmes règles intuitives, il offre également une fonction beaucoup plus puissante : les [contrats intelligents](/developers/docs/smart-contracts/). Pour cette fonctionnalité plus complexe, une analogie plus sophistiquée est nécessaire. Au lieu d'être un registre distribué, Ethereum est une [machine d'état](https://wikipedia.org/wiki/Finite-state_machine) distribuée. L'état d'Ethereum est une grande structure de données qui contient non seulement tous les comptes et les soldes, mais aussi un _état de la machine_, qui peut changer de bloc en bloc selon un ensemble de règles prédéfinies, et qui peut exécuter du code machine arbitraire. Les règles spécifiques de changement d'état d'un bloc à l'autre sont définies par l'EVM.
 
-![Schéma montrant la composition d'un compte](./evm.png) _Schéma adapté à partir du document [EVM Ethereum illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Un diagramme montrant la composition de l'EVM](./evm.png)
+_Diagramme adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
-## Fonction de transition d'état Ethereum {#the-ethereum-state-transition-function}
+## La fonction de transition d'état d'Ethereum {#the-ethereum-state-transition-function}
 
-L'EVM se comporte comme une fonction mathématique : avec des données en entrée, elle produit une sortie déterministe. Il est donc très utile de décrire plus formellement Ethereum comme ayant une **fonction de transition d'état** :
+L'EVM se comporte comme une fonction mathématique : avec des données en entrée, elle produit une sortie déterministe. Il est donc très utile de décrire plus formellement Ethereum comme ayant une **fonction de transition d'état** :
 
 ```
 Y(S, T) = S'
 ```
 
-Étant donné un ancien état valide `(S)` et un nouvel ensemble de transactions valides `(T)`, la fonction de transition d'état Ethereum `Y(S, T)` produit un nouvel état de sortie valide `S'`
+Étant donné un ancien état valide `(S)` et un nouvel ensemble de transactions valides `(T)`, la fonction de transition d'état d'Ethereum `Y(S, T)` produit un nouvel état de sortie valide `S'`
 
 ### État {#state}
 
-Dans le contexte d'Ethereum, l'état est une énorme structure de données appelée [arbre de Patricia Merkle modifié](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/), qui conserve tous [les comptes](/developers/docs/accounts/) liés par hachages et réduits à un seul hash racine stocké sur la blockchain.
+Dans le contexte d'Ethereum, l'état est une énorme structure de données appelée [arbre de Merkle-Patricia modifié](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/), qui conserve tous les [comptes](/developers/docs/accounts/) liés par des hachages et réductibles à un unique hachage racine stocké sur la blockchain.
 
 ### Transactions {#transactions}
 
 Les transactions sont des instructions signées cryptographiquement provenant des comptes. Il existe deux types de transactions : celles qui donnent lieu à appels de messages et celles qui débouchent sur la création de contrats.
 
-La création d'un contrat entraîne la création d'un nouveau compte de contrat contenant le bytecode du [contract intelligent](/developers/docs/smart-contracts/anatomy/) compilé. Chaque fois qu'un autre compte effectue un appel de message à ce contrat, il exécute son bytecode.
+La création de contrat entraîne la création d'un nouveau compte de contrat contenant le bytecode du [contrat intelligent](/developers/docs/smart-contracts/anatomy/) compilé. Chaque fois qu'un autre compte effectue un appel de message à ce contrat, il exécute son bytecode.
 
 ## Instructions de l'EVM {#evm-instructions}
 
-L'EVM s'exécute comme une [machine de pile](https://wikipedia.org/wiki/Stack_machine) avec une profondeur de 1 024 éléments. Chaque élément est un mot de 256 bits qui a été choisi pour la facilité d'utilisation avec la cryptographie 256 bits (comme les hachages Keccak-256 ou les signatures secp256k1).
+L'EVM s'exécute comme une [machine à pile](https://wikipedia.org/wiki/Stack_machine) avec une profondeur de 1024 éléments. Chaque élément est un mot de 256 bits qui a été choisi pour la facilité d'utilisation avec la cryptographie 256 bits (comme les hachages Keccak-256 ou les signatures secp256k1).
 
-Lors de l'exécution, l'EVM maintient une _mémoire_ transitoire (en tant que tableau d'octets adressé à un mot) qui ne persiste pas entre les transactions.
+Pendant l'exécution, l'EVM maintient une _mémoire_ transitoire (sous la forme d'un tableau d'octets adressé par mot), qui ne persiste pas entre les transactions.
 
-Cependant, les contrats contiennent un arbre de _stockage_ Merkle Patricia (en tant que tableau de mots adressables à un mot), associé au compte en question et faisant partie de l'état global.
+### Stockage transitoire
 
-Le bytecode du contract intelligent compilé s'exécute comme un certain nombre [de codes d'opérations](/developers/docs/evm/opcodes) EVM, qui effectuent des opérations de pile standards comme `XOR`, `AND`, `ADD`, `SUB`, etc. L'EVM implémente également un certain nombre d'opérations de pile spécifiques à la blockchain, comme `ADDRESS`, `BALANCE`, `BLOCKHASH`, etc.
+Le stockage transitoire est un magasin clé-valeur par transaction accessible via les codes d'opérations `TSTORE` et `TLOAD`. Il persiste à travers tous les appels internes au cours de la même transaction, mais il est effacé à la fin de celle-ci. Contrairement à la mémoire, le stockage transitoire est modélisé comme faisant partie de l'état de l'EVM plutôt que du cadre d'exécution, mais il n'est pas enregistré dans l'état global. Le stockage transitoire permet un partage d'état temporaire économe en gaz entre les appels internes au cours d'une transaction.
 
-![Diagramme indiquant où le gaz est nécessaire dans les opérations de l'EVM](../gas/gas.png) _Schéma adapté à partir du document [EVM Ethereum illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+### Stockage
+
+Les contrats contiennent un arbre de Merkle-Patricia de _stockage_ (sous la forme d'un tableau de mots adressables par mot), associé au compte en question et faisant partie de l'état global. Ce stockage persistant diffère du stockage transitoire, qui n'est disponible que pour la durée d'une seule transaction et ne fait pas partie de l'arbre de stockage persistant du compte.
+
+### Codes d'opérations
+
+Le bytecode de contrat intelligent compilé s'exécute sous la forme d'un certain nombre de [codes d'opérations](/developers/docs/evm/opcodes) de l'EVM, qui effectuent des opérations de pile standard comme `XOR`, `AND`, `ADD`, `SUB`, etc. L'EVM met également en œuvre un certain nombre d'opérations de pile spécifiques à la blockchain, telles que `ADDRESS`, `BALANCE`, `BLOCKHASH`, etc. L'ensemble de codes d'opérations inclut également `TSTORE` et `TLOAD`, qui donnent accès au stockage transitoire.
+
+![Un diagramme montrant où le gaz est nécessaire pour les opérations EVM](../gas/gas.png)
+_Diagrammes adaptés de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 ## Implémentations de l'EVM {#evm-implementations}
 
 Toutes les implémentations de l'EVM doivent respecter les spécifications décrites dans les pages jaunes Ethereum.
 
-Au cours des neuf années d'existence d'Ethereum, l'EVM a fait l'objet de plusieurs révisions, et il existe plusieurs implémentations de l'EVM dans divers langages de programmation.
+Au cours des dix ans d'histoire d'Ethereum, l'EVM a fait l'objet de plusieurs révisions et il existe plusieurs implémentations de l'EVM dans divers langages de programmation.
 
-Les [clients d'exécution Ethereum](/developers/docs/nodes-and-clients/#execution-clients) incluent une implémentation de l'EVM. Il existe également plusieurs implémentations autonomes, telles que :
+Les [clients d'exécution d'Ethereum](/developers/docs/nodes-and-clients/#execution-clients) incluent une implémentation de l'EVM. Il existe également plusieurs implémentations autonomes, telles que :
 
 - [Py-EVM](https://github.com/ethereum/py-evm) - _Python_
 - [evmone](https://github.com/ethereum/evmone) - _C++_
 - [ethereumjs-vm](https://github.com/ethereumjs/ethereumjs-vm) - _JavaScript_
 - [revm](https://github.com/bluealloy/revm) - _Rust_
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Les pages jaunes Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf)
-- [Jellopaper aka KEVM : Sémantique de l'EVM en K](https://jellopaper.org/)
-- [Livre beige Ethereum](https://github.com/chronaeon/beigepaper)
-- [Codes d'opérations de l'EVM](https://www.ethervm.io/)
-- [Documents de Référence aux Codes Opératoires de la Machine Virtuelle Ethereum](https://www.evm.codes/)
-- [Une courte introduction dans la documentation de Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
-- [Maîtriser Ethereum - La Machine Virtuelle Ethereum](https://github.com/ethereumbook/ethereumbook/blob/openedition/13evm.asciidoc)
+- [Le Yellowpaper d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf)
+- [Jellopaper alias KEVM : Sémantique de l'EVM en K](https://jellopaper.org/)
+- [Le Beigepaper](https://github.com/chronaeon/beigepaper)
+- [Codes d'opérations de la Machine Virtuelle Ethereum](https://www.ethervm.io/)
+- [Référence interactive des codes d'opérations de la Machine Virtuelle Ethereum](https://www.evm.codes/)
+- [Une brève introduction dans la documentation de Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
+- [Mastering Ethereum - La Machine Virtuelle Ethereum](https://github.com/ethereumbook/ethereumbook/blob/openedition/13evm.asciidoc)
 
 ## Sujets connexes {#related-topics}
 
diff --git a/public/content/translations/fr/developers/docs/evm/opcodes/index.md b/public/content/translations/fr/developers/docs/evm/opcodes/index.md
index f8fc95e22ce..365dea8871d 100644
--- a/public/content/translations/fr/developers/docs/evm/opcodes/index.md
+++ b/public/content/translations/fr/developers/docs/evm/opcodes/index.md
@@ -1,174 +1,177 @@
 ---
-title: Opcodes pour l'EMV
+title: Opcodes pour l'EVM
 description: Une liste de tous les opcodes disponibles pour la machine virtuelle Ethereum.
 lang: fr
 ---
 
-## Aperçu {#overview}
+## Vue d'ensemble {#overview}
 
-Il s'agit d'une version mise à jour de la page de référence de l'EMV sur [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes). Également tirée du [Yellow Paper,](https://ethereum.github.io/yellowpaper/paper.pdf) du [Jello Paper](https://jellopaper.org/evm/) et de l'implémentation [geth](https://github.com/ethereum/go-ethereum). Ceci est destiné à être une référence accessible, mais ce n'est pas particulièrement rigoureux. Si vous souhaitez être sûr de la précision et conscient de chaque cas limite, il est conseillé d'utiliser le Jello Paper ou une implémentation de client.
+Ceci est une version mise à jour de la page de référence de l'EVM sur [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes).
+Également tiré du [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf), du [Jello Paper](https://jellopaper.org/evm/) et de l'implémentation [geth](https://github.com/ethereum/go-ethereum).
+Ceci est destiné à être une référence accessible, mais ce n'est pas particulièrement rigoureux.
+Si vous souhaitez être sûr de la précision et conscient de chaque cas limite, il est conseillé d'utiliser le Jello Paper ou une implémentation de client.
 
 À la recherche d'une référence interactive ? Consultez [evm.codes](https://www.evm.codes/).
 
-Pour les opérations avec des coûts en gaz dynamiques, consultez [gas.md](https://github.com/wolflo/evm-opcodes/blob/main/gas.md).
+Pour les opérations avec des coûts de gaz dynamiques, voir [gas.md](https://github.com/wolflo/evm-opcodes/blob/main/gas.md).
 
-💡 Conseil rapide : Pour afficher des lignes entières, utilisez `[shift] + défilement` pour faire défiler horizontalement sur ordinateur.
+💡 Astuce : pour voir les lignes entières, utilisez `[shift] + scroll` pour faire défiler horizontalement sur un ordinateur.
 
-| Base  | Nom            |                                               Gaz                                               | Base                                             | Résultat                                     | Mémoire                                                                       | Notes                                                                                                                                                                 |
-|:-----:|:-------------- |:-----------------------------------------------------------------------------------------------:|:------------------------------------------------ |:-------------------------------------------- |:----------------------------------------------------------------------------- |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-|  00   | STOP           |                                                0                                                |                                                  |                                              |                                                                               | halt execution                                                                                                                                                        |
-|  01   | ADD            |                                                3                                                | `a, b`                                           | `a + b`                                      |                                                                               | (u)int256 addition modulo 2\*\*256                                                                                                                                |
-|  02   | MUL            |                                                5                                                | `a, b`                                           | `a * b`                                      |                                                                               | (u)int256 multiplication modulo 2\*\*256                                                                                                                          |
-|  03   | SUB            |                                                3                                                | `a, b`                                           | `a - b`                                      |                                                                               | (u)int256 addition modulo 2\*\*256                                                                                                                                |
-|  04   | DIV            |                                                5                                                | `a, b`                                           | `a // b`                                     |                                                                               | uint256 division                                                                                                                                                      |
-|  05   | SDIV           |                                                5                                                | `a, b`                                           | `a // b`                                     |                                                                               | int256 division                                                                                                                                                       |
-|  06   | MOD            |                                                5                                                | `a, b`                                           | `a % b`                                      |                                                                               | uint256 modulus                                                                                                                                                       |
-|  07   | SMOD           |                                                5                                                | `a, b`                                           | `a % b`                                      |                                                                               | int256 modulus                                                                                                                                                        |
-|  08   | ADDMOD         |                                                8                                                | `a, b, N`                                        | `(a + b) % N`                                |                                                                               | (u)int256 addition modulo N                                                                                                                                           |
-|  09   | MULMOD         |                                                8                                                | `a, b, N`                                        | `(a * b) % N`                                |                                                                               | (u)int256 multiplication modulo N                                                                                                                                     |
-|  0A   | EXP            |               [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp)               | `a, b`                                           | `a ** b`                                     |                                                                               | uint256 exponentiation modulo 2\*\*256                                                                                                                            |
-|  0B   | SIGNEXTEND     |                                                5                                                | `b, x`                                           | `SIGNEXTEND(x, b)`                           |                                                                               | [sign extend](https://wikipedia.org/wiki/Sign_extension) `x` from `(b+1)` bytes to 32 bytes                                                                           |
-| 0C-0F | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  10   | LT             |                                                3                                                | `a, b`                                           | `a < b`                                   |                                                                               | uint256 less-than                                                                                                                                                     |
-|  11   | GT             |                                                3                                                | `a, b`                                           | `a > b`                                   |                                                                               | uint256 greater-than                                                                                                                                                  |
-|  12   | SLT            |                                                3                                                | `a, b`                                           | `a < b`                                   |                                                                               | int256 less-than                                                                                                                                                      |
-|  13   | SGT            |                                                3                                                | `a, b`                                           | `a > b`                                   |                                                                               | int256 greater-than                                                                                                                                                   |
-|  14   | EQ             |                                                3                                                | `a, b`                                           | `a == b`                                     |                                                                               | (u)int256 equality                                                                                                                                                    |
-|  15   | ISZERO         |                                                3                                                | `a`                                              | `a == 0`                                     |                                                                               | (u)int256 iszero                                                                                                                                                      |
-|  16   | AND            |                                                3                                                | `a, b`                                           | `a && b`                             |                                                                               | bitwise AND                                                                                                                                                           |
-|  17   | OR             |                                                3                                                | `a, b`                                           | `a \|\| b`                                 |                                                                               | bitwise OR                                                                                                                                                            |
-|  18   | XOR            |                                                3                                                | `a, b`                                           | `a ^ b`                                      |                                                                               | bitwise XOR                                                                                                                                                           |
-|  19   | NOT            |                                                3                                                | `a`                                              | `~a`                                         |                                                                               | bitwise NOT                                                                                                                                                           |
-|  1A   | BYTE           |                                                3                                                | `i, x`                                           | `(x >> (248 - i * 8)) && 0xFF` |                                                                               | `i`th byte of (u)int256 `x`, from the left                                                                                                                            |
-|  1B   | SHL            |                                                3                                                | `shift, val`                                     | `val << shift`                         |                                                                               | shift left                                                                                                                                                            |
-|  1C   | SHR            |                                                3                                                | `shift, val`                                     | `val >> shift`                         |                                                                               | logical shift right                                                                                                                                                   |
-|  1D   | SAR            |                                                3                                                | `shift, val`                                     | `val >> shift`                         |                                                                               | arithmetic shift right                                                                                                                                                |
-| 1E-1F | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  20   | KECCAK256      |              [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3)               | `ost, len`                                       | `keccak256(mem[ost:ost+len-1])`              |                                                                               | keccak256                                                                                                                                                             |
-| 21-2F | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  30   | ADDRESS        |                                                2                                                | `.`                                              | `address(this)`                              |                                                                               | address of executing contract                                                                                                                                         |
-|  31   | BALANCE        | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr`                                           | `addr.balance`                               |                                                                               | balance, in wei                                                                                                                                                       |
-|  32   | ORIGIN         |                                                2                                                | `.`                                              | `tx.origin`                                  |                                                                               | address that originated the tx                                                                                                                                        |
-|  33   | CALLER         |                                                2                                                | `.`                                              | `msg.sender`                                 |                                                                               | address of msg sender                                                                                                                                                 |
-|  34   | CALLVALUE      |                                                2                                                | `.`                                              | `msg.value`                                  |                                                                               | msg value, in wei                                                                                                                                                     |
-|  35   | CALLDATALOAD   |                                                3                                                | `idx`                                            | `msg.data[idx:idx+32]`                       |                                                                               | read word from msg data at index `idx`                                                                                                                                |
-|  36   | CALLDATASIZE   |                                                2                                                | `.`                                              | `len(msg.data)`                              |                                                                               | length of msg data, in bytes                                                                                                                                          |
-|  37   | CALLDATACOPY   |         [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations)         | `dstOst, ost, len`                               | `.`                                          | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1]                           | copy msg data                                                                                                                                                         |
-|  38   | CODESIZE       |                                                2                                                | `.`                                              | `len(this.code)`                             |                                                                               | length of executing contract's code, in bytes                                                                                                                         |
-|  39   | CODECOPY       |         [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations)         | `dstOst, ost, len`                               | `.`                                          |                                                                               | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1]                                                                             | copy executing contract's bytecode |
-|  3A   | GASPRICE       |                                                2                                                | `.`                                              | `tx.gasprice`                                |                                                                               | gas price of tx, in wei per unit gas [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice)                                                                     |
-|  3B   | EXTCODESIZE    | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr`                                           | `len(addr.code)`                             |                                                                               | size of code at addr, in bytes                                                                                                                                        |
-|  3C   | EXTCODECOPY    |           [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy)           | `addr, dstOst, ost, len`                         | `.`                                          | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1]                          | copy code from `addr`                                                                                                                                                 |
-|  3D   | RETURNDATASIZE |                                                2                                                | `.`                                              | `size`                                       |                                                                               | size of returned data from last external call, in bytes                                                                                                               |
-|  3E   | RETURNDATACOPY |         [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations)         | `dstOst, ost, len`                               | `.`                                          | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1]                         | copy returned data from last external call                                                                                                                            |
-|  3F   | EXTCODEHASH    | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr`                                           | `Empreinte numérique`                        |                                                                               | hash = addr.exists ? keccak256(addr.code) : 0                                                                                                                         |
-|  40   | BLOCKHASH      |                                               20                                                | `blockNum`                                       | `blockHash(blockNum)`                        |                                                                               |                                                                                                                                                                       |
-|  41   | COINBASE       |                                                2                                                | `.`                                              | `block.coinbase`                             |                                                                               | adresse du proposant du bloc actuel                                                                                                                                   |
-|  42   | TIMESTAMP      |                                                2                                                | `.`                                              | `block.timestamp`                            |                                                                               | timestamp of current block                                                                                                                                            |
-|  43   | NUMBER         |                                                2                                                | `.`                                              | `block.number`                               |                                                                               | number of current block                                                                                                                                               |
-|  44   | PREVRANDAO     |                                                2                                                | `.`                                              | `randomness beacon`                          |                                                                               | randomness beacon                                                                                                                                                     |
-|  45   | GASLIMIT       |                                                2                                                | `.`                                              | `block.gaslimit`                             |                                                                               | gas limit of current block                                                                                                                                            |
-|  46   | CHAINID        |                                                2                                                | `.`                                              | `chain_id`                                   |                                                                               | push current [chain id](https://eips.ethereum.org/EIPS/eip-155) onto stack                                                                                            |
-|  47   | SELFBALANCE    |                                                5                                                | `.`                                              | `address(this).balance`                      |                                                                               | balance of executing contract, in wei                                                                                                                                 |
-|  48   | BASEFEE        |                                                2                                                | `.`                                              | `block.basefee`                              |                                                                               | base fee of current block                                                                                                                                             |
-|  49   | BLOBHASH       |                                                3                                                | `idx`                                            | `tx.blob_versioned_hashes[idx]`              |                                                                               | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844)                                                                                                                   |
-|  4A   | BLOBBASEFEE    |                                                2                                                | `.`                                              | `block.blobbasefee`                          |                                                                               | frais de base du block actuel ([EIP-7516](https://eips.ethereum.org/EIPS/eip-7516))                                                                                   |
-| 4B-4F | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  50   | POP            |                                                2                                                | `_anon`                                          | `.`                                          |                                                                               | remove item from top of stack and discard it                                                                                                                          |
-|  51   | MLOAD          |      3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)      | `ost`                                            | `mem[ost:ost+32]`                            |                                                                               | read word from memory at offset `ost`                                                                                                                                 |
-|  52   | MSTORE         |      3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)      | `ost, val`                                       | `.`                                          | mem[ost:ost+32] := val                                                        | write a word to memory                                                                                                                                                |
-|  53   | MSTORE8        |      3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)      | `ost, val`                                       | `.`                                          | mem[ost] := val && 0xFF                                                       | write a single byte to memory                                                                                                                                         |
-|  54   | SLOAD          |              [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload)              | `key`                                            | `storage[key]`                               |                                                                               | read word from storage                                                                                                                                                |
-|  55   | SSTORE         |             [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore)              | `key, val`                                       | `.`                                          | storage[key] := val                                                           | write word to storage                                                                                                                                                 |
-|  56   | JUMP           |                                                8                                                | `dst`                                            | `.`                                          |                                                                               | `$pc := dst` mark that `pc` is only assigned if `dst` is a valid jumpdest                                                                                             |
-|  57   | JUMPI          |                                               10                                                | `dst, condition`                                 | `.`                                          |                                                                               | `$pc := condition ? dst : $pc + 1`                                                                                                                                    |
-|  58   | PC             |                                                2                                                | `.`                                              | `$pc`                                        |                                                                               | program counter                                                                                                                                                       |
-|  59   | MSIZE          |                                                2                                                | `.`                                              | `len(mem)`                                   |                                                                               | size of memory in current execution context, in bytes                                                                                                                 |
-|  5A   | GAS            |                                                2                                                | `.`                                              | `gasRemaining`                               |                                                                               |                                                                                                                                                                       |
-|  5B   | JUMPDEST       |                                                1                                                |                                                  |                                              | mark valid jump destination                                                   | a valid jump destination for example a jump destination not inside the push data                                                                                      |
-|  5C   | TLOAD          |                                               100                                               | `key`                                            | `tstorage[key]`                              |                                                                               | read word from transient storage ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153))                                                                                |
-|  5D   | TSTORE         |                                               100                                               | `key, val`                                       | `.`                                          | tstorage[key] := val                                                          | write word to transient storage ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153))                                                                                 |
-|  5E   | MCOPY          | 3+3\*words+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `dstOst, ost, len`                               | `.`                                          | mem[dstOst] := mem[ost:ost+len]                                               | copy memory from one area to another ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656))                                                                            |
-|  5F   | PUSH0          |                                                2                                                | `.`                                              | `uint8`                                      |                                                                               | push the constant value 0 onto stack                                                                                                                                  |
-|  60   | PUSH1          |                                                3                                                | `.`                                              | `uint8`                                      |                                                                               | push 1-byte value onto stack                                                                                                                                          |
-|  61   | PUSH2          |                                                3                                                | `.`                                              | `uint16`                                     |                                                                               | push 2-byte value onto stack                                                                                                                                          |
-|  62   | PUSH3          |                                                3                                                | `.`                                              | `uint24`                                     |                                                                               | push 3-byte value onto stack                                                                                                                                          |
-|  63   | PUSH4          |                                                3                                                | `.`                                              | `uint32`                                     |                                                                               | push 4-byte value onto stack                                                                                                                                          |
-|  64   | PUSH5          |                                                3                                                | `.`                                              | `uint40`                                     |                                                                               | push 5-byte value onto stack                                                                                                                                          |
-|  65   | PUSH6          |                                                3                                                | `.`                                              | `uint48`                                     |                                                                               | push 6-byte value onto stack                                                                                                                                          |
-|  66   | PUSH7          |                                                3                                                | `.`                                              | `uint56`                                     |                                                                               | push 7-byte value onto stack                                                                                                                                          |
-|  67   | PUSH8          |                                                3                                                | `.`                                              | `uint64`                                     |                                                                               | push 8-byte value onto stack                                                                                                                                          |
-|  68   | PUSH9          |                                                3                                                | `.`                                              | `uint72`                                     |                                                                               | push 9-byte value onto stack                                                                                                                                          |
-|  69   | PUSH10         |                                                3                                                | `.`                                              | `uint80`                                     |                                                                               | push 10-byte value onto stack                                                                                                                                         |
-|  6A   | PUSH11         |                                                3                                                | `.`                                              | `uint88`                                     |                                                                               | push 11-byte value onto stack                                                                                                                                         |
-|  6B   | PUSH12         |                                                3                                                | `.`                                              | `uint96`                                     |                                                                               | push 12-byte value onto stack                                                                                                                                         |
-|  6C   | PUSH13         |                                                3                                                | `.`                                              | `uint104`                                    |                                                                               | push 13-byte value onto stack                                                                                                                                         |
-|  6D   | PUSH14         |                                                3                                                | `.`                                              | `uint112`                                    |                                                                               | push 14-byte value onto stack                                                                                                                                         |
-|  6E   | PUSH15         |                                                3                                                | `.`                                              | `uint120`                                    |                                                                               | push 15-byte value onto stack                                                                                                                                         |
-|  6F   | PUSH16         |                                                3                                                | `.`                                              | `uint128`                                    |                                                                               | push 16-byte value onto stack                                                                                                                                         |
-|  70   | PUSH17         |                                                3                                                | `.`                                              | `uint136`                                    |                                                                               | push 17-byte value onto stack                                                                                                                                         |
-|  71   | PUSH18         |                                                3                                                | `.`                                              | `uint144`                                    |                                                                               | push 18-byte value onto stack                                                                                                                                         |
-|  72   | PUSH19         |                                                3                                                | `.`                                              | `uint152`                                    |                                                                               | push 19-byte value onto stack                                                                                                                                         |
-|  73   | PUSH20         |                                                3                                                | `.`                                              | `uint160`                                    |                                                                               | push 20-byte value onto stack                                                                                                                                         |
-|  74   | PUSH21         |                                                3                                                | `.`                                              | `uint168`                                    |                                                                               | push 21-byte value onto stack                                                                                                                                         |
-|  75   | PUSH22         |                                                3                                                | `.`                                              | `uint176`                                    |                                                                               | push 22-byte value onto stack                                                                                                                                         |
-|  76   | PUSH23         |                                                3                                                | `.`                                              | `uint184`                                    |                                                                               | push 23-byte value onto stack                                                                                                                                         |
-|  77   | PUSH24         |                                                3                                                | `.`                                              | `uint192`                                    |                                                                               | push 24-byte value onto stack                                                                                                                                         |
-|  78   | PUSH25         |                                                3                                                | `.`                                              | `uint200`                                    |                                                                               | push 25-byte value onto stack                                                                                                                                         |
-|  79   | PUSH26         |                                                3                                                | `.`                                              | `uint208`                                    |                                                                               | push 26-byte value onto stack                                                                                                                                         |
-|  7A   | PUSH27         |                                                3                                                | `.`                                              | `uint216`                                    |                                                                               | push 27-byte value onto stack                                                                                                                                         |
-|  7B   | PUSH28         |                                                3                                                | `.`                                              | `uint224`                                    |                                                                               | push 28-byte value onto stack                                                                                                                                         |
-|  7C   | PUSH29         |                                                3                                                | `.`                                              | `uint232`                                    |                                                                               | push 29-byte value onto stack                                                                                                                                         |
-|  7D   | PUSH30         |                                                3                                                | `.`                                              | `uint240`                                    |                                                                               | push 30-byte value onto stack                                                                                                                                         |
-|  7E   | PUSH31         |                                                3                                                | `.`                                              | `uint248`                                    |                                                                               | push 31-byte value onto stack                                                                                                                                         |
-|  7F   | PUSH32         |                                                3                                                | `.`                                              | `uint256`                                    |                                                                               | push 32-byte value onto stack                                                                                                                                         |
-|  80   | DUP1           |                                                3                                                | `a`                                              | `a, a`                                       |                                                                               | clone 1st value on stack                                                                                                                                              |
-|  81   | DUP2           |                                                3                                                | `_, a`                                           | `a, _, a`                                    |                                                                               | clone 2nd value on stack                                                                                                                                              |
-|  82   | DUP3           |                                                3                                                | `_, _, a`                                        | `a, _, _, a`                                 |                                                                               | clone 3rd value on stack                                                                                                                                              |
-|  83   | DUP4           |                                                3                                                | `_, _, _, a`                                     | `a, _, _, _, a`                              |                                                                               | clone 4th value on stack                                                                                                                                              |
-|  84   | DUP5           |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 5th value on stack                                                                                                                                              |
-|  85   | DUP6           |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 6th value on stack                                                                                                                                              |
-|  86   | DUP7           |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 7th value on stack                                                                                                                                              |
-|  87   | DUP8           |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 8th value on stack                                                                                                                                              |
-|  88   | DUP9           |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 9th value on stack                                                                                                                                              |
-|  89   | DUP10          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 10th value on stack                                                                                                                                             |
-|  8A   | DUP11          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 11th value on stack                                                                                                                                             |
-|  8B   | DUP12          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 12th value on stack                                                                                                                                             |
-|  8C   | DUP13          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 13th value on stack                                                                                                                                             |
-|  8D   | DUP14          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 14th value on stack                                                                                                                                             |
-|  8E   | DUP15          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 15th value on stack                                                                                                                                             |
-|  8F   | DUP16          |                                                3                                                | `..., a`                                         | `a, ..., a`                                  |                                                                               | clone 16th value on stack                                                                                                                                             |
-|  90   | SWAP1          |                                                3                                                | `a, b`                                           | `b, a`                                       |                                                                               |                                                                                                                                                                       |
-|  91   | SWAP2          |                                                3                                                | `a, _, b`                                        | `b, _, a`                                    |                                                                               |                                                                                                                                                                       |
-|  92   | SWAP3          |                                                3                                                | `a, _, _, b`                                     | `b, _, _, a`                                 |                                                                               |                                                                                                                                                                       |
-|  93   | SWAP4          |                                                3                                                | `a, _, _, _, b`                                  | `b, _, _, _, a`                              |                                                                               |                                                                                                                                                                       |
-|  94   | SWAP5          |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  95   | SWAP6          |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  96   | SWAP7          |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  97   | SWAP8          |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  98   | SWAP9          |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  99   | SWAP10         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  9A   | SWAP11         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  9B   | SWAP12         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  9C   | SWAP13         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  9D   | SWAP14         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  9E   | SWAP15         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  9F   | SWAP16         |                                                3                                                | `a, ..., b`                                      | `b, ..., a`                                  |                                                                               |                                                                                                                                                                       |
-|  A0   | LOG0           |         [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)          | `ost, len`                                       | `.`                                          |                                                                               | LOG0(memory[ost:ost+len-1])                                                                                                                                           |
-|  A1   | LOG1           |         [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)          | `ost, len, topic0`                               | `.`                                          |                                                                               | LOG1(memory[ost:ost+len-1], topic0)                                                                                                                                   |
-|  A2   | LOG2           |         [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)          | `ost, len, topic0, topic1`                       | `.`                                          |                                                                               | LOG2(memory[ost:ost+len-1], topic0, topic1)                                                                                                                           |
-|  A3   | LOG3           |         [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)          | `ost, len, topic0, topic1, topic2`               | `.`                                          |                                                                               | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2)                                                                                                                   |
-|  A4   | LOG4           |         [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)          | `ost, len, topic0, topic1, topic2, topic3`       | `.`                                          |                                                                               | LOG4(memory[ost:ost+len-1],&#160;topic0,&#160;topic1,&#160;topic2,&#160;topic3)                                                                                       |
-| A5-EF | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  F0   | CREATE         |        [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations)        | `val, ost, len`                                  | `addr`                                       |                                                                               | addr = keccak256(rlp([address(this), this.nonce]))                                                                                                                    |
-|  F1   | CALL           |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | <code>gas,&#160;addr,&#160;val,&#160;argOst,&#160;argLen,&#160;retOst,&#160;retLen</code>                        | `success`                                    | mem[retOst:retOst+retLen-1] := returndata                                     |                                                                                                                                                                       |
-|  F2   | CALLCODE       |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | `gas, addr, val, argOst, argLen, retOst, retLen` | `success`                                    | mem[retOst:retOst+retLen-1]&#160;=&#160;returndata                            | same&#160;as&#160;DELEGATECALL,&#160;but&#160;does&#160;not&#160;propagate&#160;original&#160;msg.sender&#160;and&#160;msg.value                                      |
-|  F3   | RETOUR         |      0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)      | `ost, len`                                       | `.`                                          |                                                                               | return mem[ost:ost+len-1]                                                                                                                                             |
-|  F4   | DELEGATECALL   |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | `gas, addr, argOst, argLen, retOst, retLen`      | `success`                                    | mem[retOst:retOst+retLen-1] := returndata                                     |                                                                                                                                                                       |
-|  F5   | CREATE2        |        [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations)        | `val, ost, len, salt`                            | `addr`                                       |                                                                               | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:]                                                                                 |
-| F6-F9 | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  FA   | STATICCALL     |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | `gas, addr, argOst, argLen, retOst, retLen`      | `success`                                    | mem[retOst:retOst+retLen-1] := returndata                                     |                                                                                                                                                                       |
-| FB-FC | _invalid_      |                                                                                                 |                                                  |                                              |                                                                               |                                                                                                                                                                       |
-|  FD   | REVERT         |      0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)      | `ost, len`                                       | `.`                                          |                                                                               | revert(mem[ost:ost+len-1])                                                                                                                                            |
-|  FE   | INVALID        |             [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid)             |                                                  |                                              | designated invalid opcode - [EIP-141](https://eips.ethereum.org/EIPS/eip-141) |                                                                                                                                                                       |
-|  FF   | SELFDESTRUCT   |          [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct)           | `addr`                                           | `.`                                          |                                                                               | envoie tous les ETH vers l'adresse `addr`; si exécuté dans la même transaction qu'un contrat a été créé, détruit le contrat                                           |
+|  Base | Nom            |                                               Gaz                                               | Base                                                                                                                                                                                                              | Résultat                        | Mémoire                                                                                                                                                                                                                      | Notes                                                                                                                                                                                                                                                                                                                                                                                                  |                                                    |
+| :---: | :------------- | :---------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
+|   00  | STOP           |                                                0                                                |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              | arrêter l'exécution                                                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   01  | ADD            |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a + b`                         |                                                                                                                                                                                                                              | addition (u)int256 modulo 2\*\*256                                                                                                                                                                                                                                                                                                                                                  |                                                    |
+|   02  | MUL            |                                                5                                                | `a, b`                                                                                                                                                                                                            | `a * b`                         |                                                                                                                                                                                                                              | multiplication (u)int256 modulo 2\*\*256                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   03  | SUB            |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a - b`                         |                                                                                                                                                                                                                              | soustraction (u)int256 modulo 2\*\*256                                                                                                                                                                                                                                                                                                                                              |                                                    |
+|   04  | DIV            |                                                5                                                | `a, b`                                                                                                                                                                                                            | `a // b`                        |                                                                                                                                                                                                                              | division uint256                                                                                                                                                                                                                                                                                                                                                                                       |                                                    |
+|   05  | SDIV           |                                                5                                                | `a, b`                                                                                                                                                                                                            | `a // b`                        |                                                                                                                                                                                                                              | division int256                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   06  | MOD            |                                                5                                                | `a, b`                                                                                                                                                                                                            | `a % b`                         |                                                                                                                                                                                                                              | modulo uint256                                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   07  | SMOD           |                                                5                                                | `a, b`                                                                                                                                                                                                            | `a % b`                         |                                                                                                                                                                                                                              | modulo int256                                                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   08  | ADDMOD         |                                                8                                                | `a, b, N`                                                                                                                                                                                                         | `(a + b) % N`                   |                                                                                                                                                                                                                              | addition (u)int256 modulo N                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   09  | MULMOD         |                                                8                                                | `a, b, N`                                                                                                                                                                                                         | `(a * b) % N`                   |                                                                                                                                                                                                                              | multiplication (u)int256 modulo N                                                                                                                                                                                                                                                                                                                                                   |                                                    |
+|   0A  | EXP            |               [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp)               | `a, b`                                                                                                                                                                                                            | `a ** b`                        |                                                                                                                                                                                                                              | exponentiation uint256 modulo 2\*\*256                                                                                                                                                                                                                                                                                                                                                                 |                                                    |
+|   0B  | SIGNEXTEND     |                                                5                                                | `b, x`                                                                                                                                                                                                            | `SIGNEXTEND(x, b)`              |                                                                                                                                                                                                                              | [extension de signe](https://wikipedia.org/wiki/Sign_extension) de `x` de `(b+1)` octets à 32 octets                                                                                                                                                                                                                                                                                                   |                                                    |
+| 0C-0F | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   10  | LT             |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a < b`                         |                                                                                                                                                                                                                              | uint256 inférieur à                                                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   11  | GT             |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a > b`                         |                                                                                                                                                                                                                              | uint256 supérieur à                                                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   12  | SLT            |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a < b`                         |                                                                                                                                                                                                                              | int256 inférieur à                                                                                                                                                                                                                                                                                                                                                                                     |                                                    |
+|   13  | SGT            |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a > b`                         |                                                                                                                                                                                                                              | int256 supérieur à                                                                                                                                                                                                                                                                                                                                                                                     |                                                    |
+|   14  | EQ             |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a == b`                        |                                                                                                                                                                                                                              | égalité (u)int256                                                                                                                                                                                                                                                                                                                                                                   |                                                    |
+|   15  | ISZERO         |                                                3                                                | `a`                                                                                                                                                                                                               | `a == 0`                        |                                                                                                                                                                                                                              | (u)int256 iszero                                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   16  | AND            |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a && b`                        |                                                                                                                                                                                                                              | ET bit à bit                                                                                                                                                                                                                                                                                                                                                                                           |                                                    |
+|   17  | OR             |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a \\|\\| b`                  |                                                                                                                                                                                                                              | OU bit à bit                                                                                                                                                                                                                                                                                                                                                                                           |                                                    |
+|   18  | XOR            |                                                3                                                | `a, b`                                                                                                                                                                                                            | `a ^ b`                         |                                                                                                                                                                                                                              | XOR bit à bit                                                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   19  | NOT            |                                                3                                                | `a`                                                                                                                                                                                                               | `~a`                            |                                                                                                                                                                                                                              | NON bit à bit                                                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   1A  | BYTE           |                                                3                                                | `i, x`                                                                                                                                                                                                            | `(x >> (248 - i * 8)) && 0xFF`  |                                                                                                                                                                                                                              | le `i`-ème octet de (u)int256 `x`, en partant de la gauche                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   1B  | SHL            |                                                3                                                | `shift, val`                                                                                                                                                                                                      | `val << shift`                  |                                                                                                                                                                                                                              | décalage à gauche                                                                                                                                                                                                                                                                                                                                                                                      |                                                    |
+|   1C  | SHR            |                                                3                                                | `shift, val`                                                                                                                                                                                                      | `val >> shift`                  |                                                                                                                                                                                                                              | décalage logique à droite                                                                                                                                                                                                                                                                                                                                                                              |                                                    |
+|   1D  | SAR            |                                                3                                                | `shift, val`                                                                                                                                                                                                      | `val >> shift`                  |                                                                                                                                                                                                                              | décalage arithmétique à droite                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+| 1E-1F | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   20  | KECCAK256      |               [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3)              | `ost, len`                                                                                                                                                                                                        | `keccak256(mem[ost:ost+len-1])` |                                                                                                                                                                                                                              | keccak256                                                                                                                                                                                                                                                                                                                                                                                              |                                                    |
+| 21-2F | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   30  | ADDRESS        |                                                2                                                | `.`                                                                                                                                                                                                               | `address(this)`                 |                                                                                                                                                                                                                              | adresse du contrat en cours d'exécution                                                                                                                                                                                                                                                                                                                                                                |                                                    |
+|   31  | BALANCE        | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr`                                                                                                                                                                                                            | `addr.balance`                  |                                                                                                                                                                                                                              | solde, en wei                                                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   32  | ORIGIN         |                                                2                                                | `.`                                                                                                                                                                                                               | `tx.origin`                     |                                                                                                                                                                                                                              | adresse à l'origine de la transaction                                                                                                                                                                                                                                                                                                                                                                  |                                                    |
+|   33  | CALLER         |                                                2                                                | `.`                                                                                                                                                                                                               | `msg.sender`                    |                                                                                                                                                                                                                              | adresse de l'expéditeur du message                                                                                                                                                                                                                                                                                                                                                                     |                                                    |
+|   34  | CALLVALUE      |                                                2                                                | `.`                                                                                                                                                                                                               | `msg.value`                     |                                                                                                                                                                                                                              | valeur du message, en wei                                                                                                                                                                                                                                                                                                                                                                              |                                                    |
+|   35  | CALLDATALOAD   |                                                3                                                | `idx`                                                                                                                                                                                                             | `msg.data[idx:idx+32]`          |                                                                                                                                                                                                                              | lire le mot à partir des données du message à l'index `idx`                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   36  | CALLDATASIZE   |                                                2                                                | `.`                                                                                                                                                                                                               | `len(msg.data)`                 |                                                                                                                                                                                                                              | longueur des données du message, en octets                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   37  | CALLDATACOPY   |         [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations)         | `dstOst, ost, len`                                                                                                                                                                                                | `.`                             | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1]  | copier les données du message                                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   38  | CODESIZE       |                                                2                                                | `.`                                                                                                                                                                                                               | `len(this.code)`                |                                                                                                                                                                                                                              | longueur du code du contrat en cours d'exécution, en octets                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   39  | CODECOPY       |         [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations)         | `dstOst, ost, len`                                                                                                                                                                                                | `.`                             |                                                                                                                                                                                                                              | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1]                                                                                                                                                                           | copier le bytecode du contrat en cours d'exécution |
+|   3A  | GASPRICE       |                                                2                                                | `.`                                                                                                                                                                                                               | `tx.gasprice`                   |                                                                                                                                                                                                                              | prix du gaz de la transaction, en wei par unité de gaz [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice)                                                                                                                                                                                                                                                                                        |                                                    |
+|   3B  | EXTCODESIZE    | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr`                                                                                                                                                                                                            | `len(addr.code)`                |                                                                                                                                                                                                                              | taille du code à l'adresse, en octets                                                                                                                                                                                                                                                                                                                                                                  |                                                    |
+|   3C  | EXTCODECOPY    |           [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy)           | `addr, dstOst, ost, len`                                                                                                                                                                                          | `.`                             | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | copier le code depuis `addr`                                                                                                                                                                                                                                                                                                                                                                           |                                                    |
+|   3D  | RETURNDATASIZE |                                                2                                                | `.`                                                                                                                                                                                                               | `size`                          |                                                                                                                                                                                                                              | taille des données renvoyées par le dernier appel externe, en octets                                                                                                                                                                                                                                                                                                                                   |                                                    |
+|   3E  | RETURNDATACOPY |         [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations)         | `dstOst, ost, len`                                                                                                                                                                                                | `.`                             | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1]                | copier les données renvoyées par le dernier appel externe                                                                                                                                                                                                                                                                                                                                              |                                                    |
+|   3F  | EXTCODEHASH    | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr`                                                                                                                                                                                                            | `empreinte numérique`           |                                                                                                                                                                                                                              | hachage = addr.exists ? keccak256(addr.code) : 0                                                                                                                                                                                                                                                                                    |                                                    |
+|   40  | BLOCKHASH      |                                                20                                               | `blockNum`                                                                                                                                                                                                        | `blockHash(blockNum)`           |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   41  | COINBASE       |                                                2                                                | `.`                                                                                                                                                                                                               | `block.coinbase`                |                                                                                                                                                                                                                              | adresse du proposant du bloc actuel                                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   42  | TIMESTAMP      |                                                2                                                | `.`                                                                                                                                                                                                               | `block.timestamp`               |                                                                                                                                                                                                                              | horodatage du bloc actuel                                                                                                                                                                                                                                                                                                                                                                              |                                                    |
+|   43  | NUMBER         |                                                2                                                | `.`                                                                                                                                                                                                               | `block.number`                  |                                                                                                                                                                                                                              | numéro du bloc actuel                                                                                                                                                                                                                                                                                                                                                                                  |                                                    |
+|   44  | PREVRANDAO     |                                                2                                                | `.`                                                                                                                                                                                                               | `randomness beacon`             |                                                                                                                                                                                                                              | balise d'aléa                                                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   45  | GASLIMIT       |                                                2                                                | `.`                                                                                                                                                                                                               | `block.gaslimit`                |                                                                                                                                                                                                                              | limite de gaz du bloc actuel                                                                                                                                                                                                                                                                                                                                                                           |                                                    |
+|   46  | CHAINID        |                                                2                                                | `.`                                                                                                                                                                                                               | `chain_id`                      |                                                                                                                                                                                                                              | empiler l'[ID de chaîne](https://eips.ethereum.org/EIPS/eip-155) actuel sur la pile                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   47  | SELFBALANCE    |                                                5                                                | `.`                                                                                                                                                                                                               | `address(this).balance`         |                                                                                                                                                                                                                              | solde du contrat en cours d'exécution, en wei                                                                                                                                                                                                                                                                                                                                                          |                                                    |
+|   48  | BASEFEE        |                                                2                                                | `.`                                                                                                                                                                                                               | `block.basefee`                 |                                                                                                                                                                                                                              | frais de base du bloc actuel                                                                                                                                                                                                                                                                                                                                                                           |                                                    |
+|   49  | BLOBHASH       |                                                3                                                | `idx`                                                                                                                                                                                                             | `tx.blob_versioned_hashes[idx]` |                                                                                                                                                                                                                              | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844)                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   4A  | BLOBBASEFEE    |                                                2                                                | `.`                                                                                                                                                                                                               | `block.blobbasefee`             |                                                                                                                                                                                                                              | frais de base des blobs du bloc actuel ([EIP-7516](https://eips.ethereum.org/EIPS/eip-7516))                                                                                                                                                                                                                                                                                        |                                                    |
+| 4B-4F | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   50  | POP            |                                                2                                                | `_anon`                                                                                                                                                                                                           | `.`                             |                                                                                                                                                                                                                              | retirer l'élément du sommet de la pile et l'ignorer                                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   51  | MLOAD          |       3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)       | `ost`                                                                                                                                                                                                             | `mem[ost:ost+32]`               |                                                                                                                                                                                                                              | lire un mot de la mémoire au décalage `ost`                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   52  | MSTORE         |       3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)       | `ost, val`                                                                                                                                                                                                        | `.`                             | mem[ost:ost+32] := val                                                                                                                   | écrire un mot en mémoire                                                                                                                                                                                                                                                                                                                                                                               |                                                    |
+|   53  | MSTORE8        |       3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)       | `ost, val`                                                                                                                                                                                                        | `.`                             | mem[ost] := val && 0xFF                                                                                          | écrire un seul octet en mémoire                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   54  | SLOAD          |              [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload)              | `key`                                                                                                                                                                                                             | `storage[key]`                  |                                                                                                                                                                                                                              | lire un mot depuis le stockage                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   55  | SSTORE         |              [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore)             | `key, val`                                                                                                                                                                                                        | `.`                             | storage[key] := val                                                                                                                                      | écrire un mot dans le stockage                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   56  | JUMP           |                                                8                                                | `dst`                                                                                                                                                                                                             | `.`                             |                                                                                                                                                                                                                              | `$pc := dst` marque que `pc` n'est attribué que si `dst` est une destination de saut valide                                                                                                                                                                                                                                                                                                            |                                                    |
+|   57  | JUMPI          |                                                10                                               | `dst, condition`                                                                                                                                                                                                  | `.`                             |                                                                                                                                                                                                                              | `$pc := condition ?` dst : $pc + 1`                                                                                                                                                                                                                                                                                                                                                   |                                                    |
+|   58  | PC             |                                                2                                                | `.`                                                                                                                                                                                                               | `$pc`                           |                                                                                                                                                                                                                              | compteur de programme                                                                                                                                                                                                                                                                                                                                                                                  |                                                    |
+|   59  | MSIZE          |                                                2                                                | `.`                                                                                                                                                                                                               | `len(mem)`                      |                                                                                                                                                                                                                              | taille de la mémoire dans le contexte d'exécution actuel, en octets                                                                                                                                                                                                                                                                                                                                    |                                                    |
+|   5A  | GAS            |                                                2                                                | `.`                                                                                                                                                                                                               | `gasRemaining`                  |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   5B  | JUMPDEST       |                                                1                                                |                                                                                                                                                                                                                   |                                 | marquer une destination de saut valide                                                                                                                                                                                       | une destination de saut valide, par exemple une destination de saut qui n'est pas à l'intérieur des données push                                                                                                                                                                                                                                                                                       |                                                    |
+|   5C  | TLOAD          |                                               100                                               | `key`                                                                                                                                                                                                             | `tstorage[key]`                 |                                                                                                                                                                                                                              | lire un mot depuis le stockage transitoire ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153))                                                                                                                                                                                                                                                                                    |                                                    |
+|   5D  | TSTORE         |                                               100                                               | `key, val`                                                                                                                                                                                                        | `.`                             | tstorage[key] := val                                                                                                                                     | écrire un mot dans le stockage transitoire ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153))                                                                                                                                                                                                                                                                                    |                                                    |
+|   5E  | MCOPY          |  3+3\*words+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)  | `dstOst, ost, len`                                                                                                                                                                                                | `.`                             | mem[dstOst] := mem[ost:ost+len]                                                      | copier la mémoire d'une zone à une autre ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656))                                                                                                                                                                                                                                                                                      |                                                    |
+|   5F  | PUSH0          |                                                2                                                | `.`                                                                                                                                                                                                               | `uint8`                         |                                                                                                                                                                                                                              | push the constant value 0 onto stack                                                                                                                                                                                                                                                                                                                                                                   |                                                    |
+|   60  | PUSH1          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint8`                         |                                                                                                                                                                                                                              | empiler une valeur de 1 octet sur la pile                                                                                                                                                                                                                                                                                                                                                              |                                                    |
+|   61  | PUSH2          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint16`                        |                                                                                                                                                                                                                              | empiler une valeur de 2 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   62  | PUSH3          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint24`                        |                                                                                                                                                                                                                              | empiler une valeur de 3 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   63  | PUSH4          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint32`                        |                                                                                                                                                                                                                              | empiler une valeur de 4 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   64  | PUSH5          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint40`                        |                                                                                                                                                                                                                              | empiler une valeur de 5 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   65  | PUSH6          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint48`                        |                                                                                                                                                                                                                              | empiler une valeur de 6 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   66  | PUSH7          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint56`                        |                                                                                                                                                                                                                              | empiler une valeur de 7 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   67  | PUSH8          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint64`                        |                                                                                                                                                                                                                              | empiler une valeur de 8 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   68  | PUSH9          |                                                3                                                | `.`                                                                                                                                                                                                               | `uint72`                        |                                                                                                                                                                                                                              | empiler une valeur de 9 octets sur la pile                                                                                                                                                                                                                                                                                                                                                             |                                                    |
+|   69  | PUSH10         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint80`                        |                                                                                                                                                                                                                              | empiler une valeur de 10 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   6A  | PUSH11         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint88`                        |                                                                                                                                                                                                                              | empiler une valeur de 11 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   6B  | PUSH12         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint96`                        |                                                                                                                                                                                                                              | empiler une valeur de 12 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   6C  | PUSH13         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint104`                       |                                                                                                                                                                                                                              | empiler une valeur de 13 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   6D  | PUSH14         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint112`                       |                                                                                                                                                                                                                              | empiler une valeur de 14 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   6E  | PUSH15         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint120`                       |                                                                                                                                                                                                                              | empiler une valeur de 15 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   6F  | PUSH16         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint128`                       |                                                                                                                                                                                                                              | empiler une valeur de 16 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   70  | PUSH17         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint136`                       |                                                                                                                                                                                                                              | empiler une valeur de 17 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   71  | PUSH18         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint144`                       |                                                                                                                                                                                                                              | empiler une valeur de 18 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   72  | PUSH19         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint152`                       |                                                                                                                                                                                                                              | empiler une valeur de 19 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   73  | PUSH20         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint160`                       |                                                                                                                                                                                                                              | empiler une valeur de 20 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   74  | PUSH21         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint168`                       |                                                                                                                                                                                                                              | empiler une valeur de 21 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   75  | PUSH22         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint176`                       |                                                                                                                                                                                                                              | empiler une valeur de 22 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   76  | PUSH23         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint184`                       |                                                                                                                                                                                                                              | empiler une valeur de 23 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   77  | PUSH24         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint192`                       |                                                                                                                                                                                                                              | empiler une valeur de 24 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   78  | PUSH25         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint200`                       |                                                                                                                                                                                                                              | empiler une valeur de 25 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   79  | PUSH26         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint208`                       |                                                                                                                                                                                                                              | empiler une valeur de 26 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   7A  | PUSH27         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint216`                       |                                                                                                                                                                                                                              | empiler une valeur de 27 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   7B  | PUSH28         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint224`                       |                                                                                                                                                                                                                              | empiler une valeur de 28 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   7C  | PUSH29         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint232`                       |                                                                                                                                                                                                                              | empiler une valeur de 29 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   7D  | PUSH30         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint240`                       |                                                                                                                                                                                                                              | empiler une valeur de 30 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   7E  | PUSH31         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint248`                       |                                                                                                                                                                                                                              | empiler une valeur de 31 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   7F  | PUSH32         |                                                3                                                | `.`                                                                                                                                                                                                               | `uint256`                       |                                                                                                                                                                                                                              | empiler une valeur de 32 octets sur la pile                                                                                                                                                                                                                                                                                                                                                            |                                                    |
+|   80  | DUP1           |                                                3                                                | `a`                                                                                                                                                                                                               | `a, a`                          |                                                                                                                                                                                                                              | cloner la 1ère valeur de la pile                                                                                                                                                                                                                                                                                                                                                                       |                                                    |
+|   81  | DUP2           |                                                3                                                | `_, a`                                                                                                                                                                                                            | `a, _, a`                       |                                                                                                                                                                                                                              | cloner la 2e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   82  | DUP3           |                                                3                                                | `_, _, a`                                                                                                                                                                                                         | `a, _, _, a`                    |                                                                                                                                                                                                                              | cloner la 3e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   83  | DUP4           |                                                3                                                | `_, _, _, a`                                                                                                                                                                                                      | `a, _, _, _, a`                 |                                                                                                                                                                                                                              | cloner la 4e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   84  | DUP5           |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 5e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   85  | DUP6           |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 6e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   86  | DUP7           |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 7e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   87  | DUP8           |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 8e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   88  | DUP9           |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 9e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                         |                                                    |
+|   89  | DUP10          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 10e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   8A  | DUP11          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 11e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   8B  | DUP12          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 12e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   8C  | DUP13          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 13e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   8D  | DUP14          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 14e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   8E  | DUP15          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 15e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   8F  | DUP16          |                                                3                                                | `..., a`                                                                                                                                                                                                          | `a, ..., a`                     |                                                                                                                                                                                                                              | cloner la 16e valeur de la pile                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   90  | SWAP1          |                                                3                                                | `a, b`                                                                                                                                                                                                            | `b, a`                          |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   91  | SWAP2          |                                                3                                                | `a, _, b`                                                                                                                                                                                                         | `b, _, a`                       |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   92  | SWAP3          |                                                3                                                | `a, _, _, b`                                                                                                                                                                                                      | `b, _, _, a`                    |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   93  | SWAP4          |                                                3                                                | `a, _, _, _, b`                                                                                                                                                                                                   | `b, _, _, _, a`                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   94  | SWAP5          |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   95  | SWAP6          |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   96  | SWAP7          |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   97  | SWAP8          |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   98  | SWAP9          |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   99  | SWAP10         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   9A  | SWAP11         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   9B  | SWAP12         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   9C  | SWAP13         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   9D  | SWAP14         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   9E  | SWAP15         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   9F  | SWAP16         |                                                3                                                | `a, ..., b`                                                                                                                                                                                                       | `b, ..., a`                     |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   A0  | LOG0           |          [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)         | `ost, len`                                                                                                                                                                                                        | `.`                             |                                                                                                                                                                                                                              | LOG0(memory[ost:ost+len-1])                                                                                                                                                                                                                                                                                     |                                                    |
+|   A1  | LOG1           |          [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)         | `ost, len, topic0`                                                                                                                                                                                                | `.`                             |                                                                                                                                                                                                                              | LOG1(memory[ost:ost+len-1], topic0)                                                                                                                                                                                                                                                                             |                                                    |
+|   A2  | LOG2           |          [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)         | `ost, len, topic0, topic1`                                                                                                                                                                                        | `.`                             |                                                                                                                                                                                                                              | LOG2(memory[ost:ost+len-1], topic0, topic1)                                                                                                                                                                                                                                                                     |                                                    |
+|   A3  | LOG3           |          [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)         | `ost, len, topic0, topic1, topic2`                                                                                                                                                                                | `.`                             |                                                                                                                                                                                                                              | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2)                                                                                                                                                                                                                                                             |                                                    |
+|   A4  | LOG4           |          [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations)         | `ost, len, topic0, topic1, topic2, topic3`                                                                                                                                                                        | `.`                             |                                                                                                                                                                                                                              | LOG4(memory[ost:ost+len-1],&#160;topic0,&#160;topic1,&#160;topic2,&#160;topic3)                                                                                                                                                 |                                                    |
+| A5-EF | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   F0  | CREATE         |        [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations)        | `val, ost, len`                                                                                                                                                                                                   | `addr`                          |                                                                                                                                                                                                                              | addr = keccak256(rlp([address(this), this.nonce]))                                                                                                                                                                                                                        |                                                    |
+|   F1  | CALL           |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | <code>gas,&#160;addr,&#160;val,&#160;argOst,&#160;argLen,&#160;retOst,&#160;retLen</code> | `success`                       | mem[retOst:retOst+retLen-1] := returndata                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   F2  | CALLCODE       |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | `gas, addr, val, argOst, argLen, retOst, retLen`                                                                                                                                                                  | `success`                       | mem[retOst:retOst+retLen-1]&#160;=&#160;returndata                                                               | identique&#160;à&#160;DELEGATECALL,&#160;mais&#160;ne&#160;propage&#160;pas&#160;les&#160;msg.sender&#160;et&#160;msg.value&#160;d'origine |                                                    |
+|   F3  | RETOUR         |       0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)       | `ost, len`                                                                                                                                                                                                        | `.`                             |                                                                                                                                                                                                                              | retourner mem[ost:ost+len-1]                                                                                                                                                                                                                                                                                                       |                                                    |
+|   F4  | DELEGATECALL   |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | `gas, addr, argOst, argLen, retOst, retLen`                                                                                                                                                                       | `success`                       | mem[retOst:retOst+retLen-1] := returndata                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   F5  | CREATE2        |        [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations)        | `val, ost, len, salt`                                                                                                                                                                                             | `addr`                          |                                                                                                                                                                                                                              | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:]                                                                                                                 |                                                    |
+| F6-F9 | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   FA  | STATICCALL     |         [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations)         | `gas, addr, argOst, argLen, retOst, retLen`                                                                                                                                                                       | `success`                       | mem[retOst:retOst+retLen-1] := returndata                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+| FB-FC | _invalide_     |                                                                                                 |                                                                                                                                                                                                                   |                                 |                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   FD  | REVERT         |       0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion)       | `ost, len`                                                                                                                                                                                                        | `.`                             |                                                                                                                                                                                                                              | revert(mem[ost:ost+len-1])                                                                                                                                                                                                                                                                                      |                                                    |
+|   FE  | INVALID        |             [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid)             |                                                                                                                                                                                                                   |                                 | opcode invalide désigné - [EIP-141](https://eips.ethereum.org/EIPS/eip-141)                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                        |                                                    |
+|   FF  | SELFDESTRUCT   |           [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct)          | `addr`                                                                                                                                                                                                            | `.`                             |                                                                                                                                                                                                                              | envoie tous les ETH à `addr` ; si cette instruction est exécutée dans la même transaction que celle de la création d'un contrat, elle détruit ce dernier.                                                                                                                                                                                                                              |                                                    |
diff --git a/public/content/translations/fr/developers/docs/frameworks/index.md b/public/content/translations/fr/developers/docs/frameworks/index.md
index f5be52657d8..66be95de15d 100644
--- a/public/content/translations/fr/developers/docs/frameworks/index.md
+++ b/public/content/translations/fr/developers/docs/frameworks/index.md
@@ -1,10 +1,10 @@
 ---
-title: Infrastructures de développement des dApps
+title: "Infrastructures de développement des dApps"
 description: Explorez les avantages des frameworks et comparez les options disponibles.
 lang: fr
 ---
 
-## Introduction aux infrastructures {#introduction-to-frameworks}
+## Introduction aux frameworks {#introduction-to-frameworks}
 
 La construction d'une dApp complète nécessite différentes technologies. Les infrastructures logiciels incluent de nombreuses fonctionnalités ou fournissent des systèmes de plugin pour choisir les outils que vous voulez.
 
@@ -12,60 +12,64 @@ Ces infrastructures sont livrés avec de nombreuses fonctionnalités prêtes à
 
 - Fonctionnalités pour faire tourner une instance locale de la blockchain.
 - 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.
+- 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 d'Ethereum.
+- Distribution d'applications décentralisées : intégrations avec des options de
+  stockage comme IPFS.
 
 ## 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/).
+Avant de plonger dans les frameworks, nous vous recommandons de lire d'abord notre introduction aux [dapps](/developers/docs/dapps/) et à la [pile Ethereum](/developers/docs/ethereum-stack/).
 
-## Infrastructures disponibles {#available-frameworks}
+## Frameworks disponibles {#available-frameworks}
 
-**Foundry -** - **_Foundry est une boîte à outils rapide, portable et modulaire pour le développement d'applications Ethereum_**
+**Foundry** - **_Foundry est une boîte à outils ultra-rapide, portable et modulaire pour le développement d'applications Ethereum_**
 
 - [Installer Foundry](https://book.getfoundry.sh/)
-- [Livre sur Foundry](https://book.getfoundry.sh/)
-- [Discussions de la communauté sur le Telegram de Foundry](https://t.me/foundry_support)
-- [L'incroyable Foundry](https://github.com/crisgarner/awesome-foundry)
+- [Livre Foundry](https://book.getfoundry.sh/)
+- [Chat de la communauté Foundry sur Telegram](https://t.me/foundry_support)
+- [Awesome Foundry](https://github.com/crisgarner/awesome-foundry)
 
 **Hardhat -** **_Environnement de développement Ethereum pour les professionnels._**
 
 - [hardhat.org](https://hardhat.org)
 - [GitHub](https://github.com/nomiclabs/hardhat)
 
-**Ape -** **_L'outil de développement des contrats intelligents pour les spécialistes Python, les scientifiques des données et les professionnels de la sécurité._**
+**Ape -** **_L'outil de développement de contrats intelligents pour les pythonistes, les data scientists et les professionnels de la sécurité._**
 
 - [Documentation](https://docs.apeworx.io/ape/stable/)
 - [GitHub](https://github.com/ApeWorX/ape)
 
-**Web3j -** **_Une plateforme pour le développement d'applications blockchain sur JVM._**
+**Web3j -** **_Une plateforme pour développer des applications blockchain sur la JVM._**
 
 - [Page d'accueil](https://www.web3labs.com/web3j-sdk)
 - [Documentation](https://docs.web3j.io)
 - [GitHub](https://github.com/web3j/web3j)
 
-**ethers-kt** - **_Librairie Kotlin/Java/Andoid asynchrone et haute performance pour les blockchains basées sur l'EVM_**
+**ethers-kt -** **_Bibliothèque Kotlin/Java/Android asynchrone et très performante pour les blockchains basées sur l'EVM._**
 
 - [GitHub](https://github.com/Kr1ptal/ethers-kt)
 - [Exemples](https://github.com/Kr1ptal/ethers-kt/tree/master/examples)
 - [Discord](https://discord.gg/rx35NzQGSb)
 
-**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éez 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._**
 
 - [GitHub](https://github.com/paulrberg/create-eth-app)
-- [Modèles (Templates)](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates)
+- [Modèles](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._**
+**Scaffold-Eth -** **_Ethers.js + Hardhat + composants et hooks React pour le web3 : tout ce dont vous avez besoin pour commencer à créer des applications décentralisées basées sur des contrats intelligents._**
 
 - [GitHub](https://github.com/scaffold-eth/scaffold-eth-2)
 
-**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._**
+**Tenderly -** **_Plateforme de développement Web3 qui permet aux développeurs blockchain de créer, tester, déboguer, surveiller et exploiter des contrats intelligents et d'améliorer l'UX des dapps._**
 
 - [Site Web](https://tenderly.co/)
 - [Documentation](https://docs.tenderly.co/)
 
-**The Graph -** **_Le graphique pour interroger efficacement les données de la blockchain._**
+**The Graph -** **_The Graph pour interroger efficacement les données de la blockchain._**
 
 - [Site Web](https://thegraph.com/)
 - [Tutoriel](/developers/tutorials/the-graph-fixing-web3-data-querying/)
@@ -82,7 +86,7 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p
 - [GitHub](https://github.com/node-real)
 - [Discord](https://discord.gg/V5k5gsuE)
 
-**thirdweb SDK -** **_Créez des applications web3 capables d'interagir avec vos contrats intelligents à l'aide de nos puissants SDK et CLI._**
+**thirdweb SDK -** **_Créez des applications web3 qui peuvent interagir avec vos contrats intelligents à l'aide de nos puissants SDK et CLI._**
 
 - [Documentation](https://portal.thirdweb.com/sdk/)
 - [GitHub](https://github.com/thirdweb-dev/)
@@ -93,52 +97,52 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p
 - [GitHub](https://github.com/chainstack)
 - [Discord](https://discord.gg/BSb5zfp9AT)
 
-**Crossmint -** **_Plateforme de développement Web3 de niveau entreprise, qui vous permet de créer des applications NFT sur toutes les principales chaînes de l'EVM (et autres)._**
+**Crossmint -** **_Plateforme de développement web3 de niveau entreprise, qui vous permet de créer des applications NFT sur toutes les principales chaînes EVM (et autres)._**
 
 - [Site Web](https://www.crossmint.com)
 - [Documentation](https://docs.crossmint.com)
 - [Discord](https://discord.com/invite/crossmint)
 
-**Brownie -** **_Environnement de développement en Python et infrastructure de test_**
+**Brownie -** **_Environnement de développement et framework de test basé sur Python._**
 
 - [Documentation](https://eth-brownie.readthedocs.io/en/latest/)
 - [GitHub](https://github.com/eth-brownie/brownie)
 - **Brownie n'est plus développé actuellement**
 
-**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 -** **_La boîte à outils ultime pour contrats intelligents : une suite d'outils pour vous aider à développer, compiler, mettre à jour, déployer et interagir avec des contrats intelligents._**
 
-- [OpenZeppelin SDK](https://openzeppelin.com/sdk/)
+- [OpenZeppelin Defender SDK](https://docs.openzeppelin.com/defender/sdk)
 - [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk)
-- [Forum communautaire](https://forum.openzeppelin.com/c/support/17)
+- [Forum de la communauté](https://forum.openzeppelin.com/c/support/17)
 - **Le développement de OpenZeppelin SDK a été arrêté**
 
-**Catapulta -** **_Outil de déploiement de contrats intelligents multi-chaînes, automatisation des vérifications dans les explorateurs de blocs, suivi des contrats intelligents déployés et partage des rapports de déploiement, plug-n-play pour les projets Foundry et Hardhat._**
+**Catapulta -** **_Outil de déploiement de contrats intelligents multi-chaînes, automatise les vérifications dans les explorateurs de blocs, assure le suivi des contrats intelligents déployés et partage les rapports de déploiement, plug-and-play pour les projets Foundry et Hardhat._**
 
-- [Github](https://github.com/catapulta-sh)
+- [GitHub](https://github.com/catapulta-sh)
 
-**Covalent** - **_APIs blockchain enrichie pour plus de 200 chaines._**
+**GoldRush (par Covalent) -** **_GoldRush propose la suite d'API de données blockchain la plus complète pour les développeurs, les analystes et les entreprises. Que vous construisiez un tableau de bord DeFi, un portefeuille, un robot de trading, un agent d'IA ou une plateforme de conformité, les API de données fournissent un accès rapide, précis et convivial pour les développeurs aux données essentielles en chaîne dont vous avez besoin_**
 
-- [covalenthq.com](https://www.covalenthq.com/)
-- [Documentation](https://www.covalenthq.com/docs/api/)
+- [Site Web](https://goldrush.dev/)
+- [Documentation](https://goldrush.dev/docs/chains/ethereum)
 - [GitHub](https://github.com/covalenthq)
 - [Discord](https://www.covalenthq.com/discord/)
 
-**Wake -** **_Cadre Python tout-en-un pour les tests de contrats, le fuzzing, le déploiement, l'analyse de vulnérabilité et la navigation dans le code._**
+**Wake -** **_Framework Python tout-en-un pour le test de contrats, le fuzzing, le déploiement, l'analyse de vulnérabilités et la navigation dans le code._**
 
 - [Page d'accueil](https://getwake.io/)
 - [Documentation](https://ackeeblockchain.com/wake/docs/latest/)
 - [GitHub](https://github.com/Ackee-Blockchain/wake)
 - [Extension VS Code](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity)
 
-****Veramo -**** **_Un cadre open source, modulaire et agnostique qui facilite l'intégration des identités décentralisées et des justificatifs vérifiables dans les applications pour les développeurs d'applications décentralisées._**
+**Veramo -** **_Framework open source, modulaire et agnostique qui permet aux développeurs d'applications décentralisées d'intégrer facilement des identités décentralisées et des justificatifs vérifiables dans leurs applications._**
 
 - [Page d'accueil](https://veramo.io/)
 - [Documentation](https://veramo.io/docs/basics/introduction)
 - [GitHub](https://github.com/uport-project/veramo)
 - [Discord](https://discord.com/invite/FRRBdjemHV)
-- [Package NPM](https://www.npmjs.com/package/@veramo/core)
+- [Paquet NPM](https://www.npmjs.com/package/@veramo/core)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
diff --git a/public/content/translations/fr/developers/docs/gas/index.md b/public/content/translations/fr/developers/docs/gas/index.md
index 3c405a2a881..e430bc6889d 100644
--- a/public/content/translations/fr/developers/docs/gas/index.md
+++ b/public/content/translations/fr/developers/docs/gas/index.md
@@ -1,7 +1,7 @@
 ---
 title: Gaz et frais
 metaTitle: "Gaz et frais Ethereum : aperçu technique"
-description:
+description: "En savoir plus sur les frais de gaz Ethereum, comment ils sont calculés et leur rôle dans la sécurité du réseau et le traitement des transactions."
 lang: fr
 ---
 
@@ -9,7 +9,7 @@ Le gaz est un élément essentiel du réseau Ethereum. Il lui permet de fonction
 
 ## Prérequis {#prerequisites}
 
-Pour mieux comprendre cette page, nous vous recommandons de commencer par lire celles sur les [transactions](/developers/docs/transactions/) et sur l'[EVM](/developers/docs/evm/).
+Pour mieux comprendre cette page, nous vous recommandons de vous informer d'abord sur les [transactions](/developers/docs/transactions/) et [l'EVM](/developers/docs/evm/).
 
 ## Qu'est-ce que le gaz ? {#what-is-gas}
 
@@ -17,25 +17,26 @@ Le gaz est l'unité qui mesure la quantité d'efforts de calculs requis pour ex
 
 Étant donné que l'exécution de chaque transaction Ethereum nécessite des ressources informatiques, ces ressources doivent être payées pour garantir qu'Ethereum ne soit pas vulnérable au spam et ne reste pas bloqué dans des boucles de calcul infinies. Le paiement concernant le calcul se fait sous forme de frais de gaz.
 
-Les frais de gaz** correspondent à la somme de gaz utilisé pour effectuer une opération, multiplié au coût par unité de gaz**. Les frais sont payés, que la transaction réussisse ou échoue.
+Les frais de gaz correspondent à **la quantité de gaz utilisée pour effectuer une opération, multipliée par le coût par unité de gaz**. Les frais sont payés, que la transaction réussisse ou échoue.
 
-![Diagramme indiquant où le gaz est nécessaire dans les opérations EVM](./gas.png) _Schéma adapté à partir du document [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Un diagramme montrant où le gaz est nécessaire dans les opérations de l'EVM](./gas.png)
+_Diagramme adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 Les frais de gaz doivent être payés dans la monnaie native d'Ethereum, l'éther (ETH). Le prix du gaz est généralement indiqué en gwei, qui est une dénomination de l'ETH. Chaque gwei est égal à un milliardième d'ETH (0,000000001 ETH ou 10<sup>-9</sup> ETH).
 
 Par exemple, au lieu de dire que votre gaz coûte 0,000000001 Ether, vous pouvez dire qu'il coûte 1 gwei.
 
-Le mot "gwei" est une contraction de "giga-wei", qui signifie "milliard de wei". Un gwei est égal à un milliard de wei. « Wei » (qui porte le nom de [Wei Dai](https://wikipedia.org/wiki/Wei_Dai), le créateur de [b-money](https://www.investopedia.com/terms/b/bmoney.asp)), est la plus petite unité d'ETH.
+Le mot "gwei" est une contraction de "giga-wei", qui signifie "milliard de wei". Un gwei est égal à un milliard de wei. Le Wei lui-même (nommé d'après [Wei Dai](https://wikipedia.org/wiki/Wei_Dai), créateur de [b-money](https://www.investopedia.com/terms/b/bmoney.asp)) est la plus petite unité d'ETH.
 
 ## Comment sont calculées les frais de gaz ? {#how-are-gas-fees-calculated}
 
 Vous pouvez fixer le montant du gaz que vous êtes prêt à payer lorsque vous soumettez une transaction. En choissisant une certaine quantité de gaz, vous faites une offre pour que votre transaction soit incluse dans le bloc suivant. Si votre offre est insuffisante, les validateurs seront moins enclins à choisir votre transaction pour l'inclure, ce qui signifie que votre transaction risque d'être exécutée tardivement ou de ne pas être exécutée du tout. Si vous en offrez trop, vous risquez de gaspiller de l'ETH. Alors, comment savoir combien payer ?
 
-Le montant total du gaz que vous payez est divisé en deux parties : `frais de base` et `frais de priorité` (pourboire).
+Le gaz total que vous payez est divisé en deux composantes : les `frais de base` et les `frais de priorité` (pourboire).
 
-Les `frais de base` sont fixés par le protocole - vous devez payer au moins ce montant pour que votre transaction soit considérée comme valide. Les `frais de priorité ` sont un pourboire que vous ajoutez aux frais de base pour rendre votre transaction attrayante aux yeux des validateurs afin qu'ils la choisissent pour l'inclure dans le bloc suivant.
+Les `frais de base` sont définis par le protocole — vous devez payer au moins ce montant pour que votre transaction soit considérée comme valide. Les `frais de priorité` sont un pourboire que vous ajoutez aux frais de base pour rendre votre transaction attrayante pour les validateurs afin qu'ils la choisissent pour l'inclure dans le bloc suivant.
 
-Une transaction qui ne paie que les `frais de base` est techniquement valable, mais il est peu probable qu'elle soit incluse parce qu'elle n'incite pas les validateurs à la choisir plutôt qu'une autre transaction. Les frais de `priority` (priorité) "corrects" sont déterminés par l'utilisation du réseau au moment où vous émettez votre transaction. Si la demande est importante, vous devrez peut-être augmenter vos frais de `priority` ; dans le cas contraire, vous pourriez payer moins.
+Une transaction qui ne paie que les `frais de base` est techniquement valide, mais il est peu probable qu'elle soit incluse, car elle n'offre aucune incitation aux validateurs pour la choisir par rapport à toute autre transaction. Les frais de `priorité` "corrects" sont déterminés par l'utilisation du réseau au moment où vous envoyez votre transaction — s'il y a beaucoup de demande, vous devrez peut-être fixer vos frais de `priorité` plus haut, mais lorsqu'il y a moins de demande, vous pouvez payer moins.
 
 Par exemple, disons que Jordan doit payer 1 ETH à Taylor. Un transfert d'ETH nécessite 21 000 unités de gaz et les frais de base sont de 10 gwei. Jordan y ajoute un pourboire de 2 gwei.
 
@@ -43,54 +44,58 @@ Le montant total des frais s'élèverait alors à :
 
 `unités de gaz utilisées * ( frais de base + frais de priorité)`
 
-où les `frais de base` sont une valeur fixée par le protocole et les `frais de priorité` sont une valeur fixée par l'utilisateur en guise de pourboire au validateur.
+où les `frais de base` sont une valeur définie par le protocole et les `frais de priorité` une valeur définie par l'utilisateur en guise de pourboire au validateur.
 
-ex. `21,000 * (10 + 2) = 252,000 gwei` (0.000252 ETH).
+par ex., `21,000 * (10 + 2) = 252,000 gwei` (0,000252 ETH).
 
 Lorsque Jordan enverra de l'argent, 1,000252 ETH sera déduit du compte de Jordan. Thierry sera crédité de 1,0000 ETH. Le validateur reçoit un pourboire de 0,000042 ETH. Les `frais de base` de 0,00021 ETH sont brûlés.
 
 ### Frais de base {#base-fee}
 
-Chaque bloc a des frais de base qui servent de prix de réserve. Pour être éligible à l'inclusion dans un bloc, le prix proposé en gaz doit être au moins égal aux frais de base. Les frais de base sont calculés indépendamment du bloc actuel et sont déterminés par les blocs qui le précèdent, ce qui rend les frais de transaction plus prévisibles pour les utilisateurs. Lors de la création du bloc, les **frais de base sont "brûlés"**, ce qui les retire de la circulation.
+Chaque bloc a des frais de base qui servent de prix de réserve. Pour être éligible à l'inclusion dans un bloc, le prix proposé en gaz doit être au moins égal aux frais de base. Les frais de base sont calculés indépendamment du bloc actuel et sont plutôt déterminés par les blocs qui le précèdent, ce qui rend les frais de transaction plus prévisibles pour les utilisateurs. Lors de la création du bloc, ces **frais de base sont "brûlés"**, ce qui les retire de la circulation.
 
-Les frais de base sont calculés par une formule qui compare la taille du bloc précédent (la quantité de gaz utilisée pour toutes les transactions) avec la taille cible. Les frais de base augmenteront d'un maximum de 12,5 % par bloc si la taille du bloc cible est dépassée. D'un point de vue économique, cette croissance exponentielle ne permet pas de garder indéfiniment des blocs de grande taille.
+Les frais de base sont calculés par une formule qui compare la taille du bloc précédent (la quantité de gaz utilisée pour toutes les transactions) avec la taille cible (la moitié de la limite de gaz). Les frais de base augmenteront ou diminueront d'un maximum de 12,5 % par bloc si la taille du bloc cible est respectivement supérieure ou inférieure à la cible. D'un point de vue économique, cette croissance exponentielle ne permet pas de garder indéfiniment des blocs de grande taille.
 
 | Numéro de bloc | Gaz inclus | Augmentation des frais | Frais de base actuels |
-| -------------- | ----------:| ----------------------:| ---------------------:|
-| 1              |       15 M |                    0 % |              100 gwei |
-| 2              |        30M |                    0 % |              100 gwei |
-| 3              |       30 M |                 12,5 % |            112,5 gwei |
-| 4              |       30 M |                 12,5 % |            126,6 gwei |
-| 5              |       30 M |                 12,5 % |            142,4 gwei |
-| 6              |       30 M |                 12,5 % |            160,2 gwei |
-| 7              |       30 M |                 12,5 % |            180,2 gwei |
-| 8              |       30 M |                 12,5 % |            202,7 gwei |
-
-D'apres la table ci-dessus - afin de créer une transaction sur le bloc numéro 9, un portefeuille pourra faire savoir à l'utilisateur avec certitude que les **frais de base maximum** à ajouter au bloc suivant sont `les frais de base actuels * 112,5 %` ou `202,8 gwei * 112,5 % = 228,1 gwei`.
+| -------------- | ---------: | ---------------------: | --------------------: |
+| 1              |        18M |                    0 % |              100 gwei |
+| 2              |        36M |                    0 % |              100 gwei |
+| 3              |        36M |                 12,5 % |            112,5 gwei |
+| 4              |        36M |                 12,5 % |            126,6 gwei |
+| 5              |        36M |                 12,5 % |            142,4 gwei |
+| 6              |        36M |                 12,5 % |            160,2 gwei |
+| 7              |        36M |                 12,5 % |            180,2 gwei |
+| 8              |        36M |                 12,5 % |            202,7 gwei |
+
+Dans le tableau ci-dessus, un exemple est présenté utilisant 36 millions comme limite de gaz. En suivant cet exemple, pour créer une transaction sur le bloc numéro 9, un portefeuille informera l'utilisateur avec certitude que les **frais de base maximum** à ajouter au bloc suivant sont de `frais de base actuels * 112.5%` ou `202.7 gwei * 112.5% = 228.1 gwei`.
 
 Il est également important de noter qu'il est peu probable que nous assistions à des pics prolongés de blocs complets en raison de la vitesse à laquelle les frais de base augmentent avant un bloc complet.
 
-| Numéro de bloc | Gaz inclus | Augmentation des frais | Frais de base actuels |
-| -------------- | ----------:| ----------------------:| ---------------------:|
-| 30             |       30 M |                 12,5 % |          2 705,6 gwei |
-| ...            |        ... |                 12,5 % |                   ... |
-| 50             |       30 M |                 12,5 % |         28 531,3 gwei |
-| ...            |        ... |                 12,5 % |                   ... |
-| 100            |       30 M |                 12,5 % |     10 302 608,6 gwei |
+| Numéro de bloc                                      |                                          Gaz inclus | Augmentation des frais |                               Frais de base actuels |
+| --------------------------------------------------- | --------------------------------------------------: | ---------------------: | --------------------------------------------------: |
+| 30                                                  |                                                 36M |                 12,5 % |                                        2 705,6 gwei |
+| ... | ... |                 12,5 % | ... |
+| 50                                                  |                                                 36M |                 12,5 % |                                       28 531,3 gwei |
+| ... | ... |                 12,5 % | ... |
+| 100                                                 |                                                 36M |                 12,5 % |                                   10 302 608,6 gwei |
 
 ### Frais de priorité (pourboires) {#priority-fee}
 
-Les frais de priorité (pourboire) incitent les validateurs à inclure une transaction dans le bloc. En l'absence de pourboires, les validateurs trouveraient économiquement viable de miner des blocs vides, puisqu'ils recevraient la même récompense pour les blocs. Les petits pourboires n'incitent que très peu les validateurs à inclure une transaction. Pour que les transactions soient exécutées de préférence à d'autres transactions dans le même bloc, un pourboire plus élevé peut être ajouté pour tenter de surenchérir sur les transactions concurrentes.
+Les frais de priorité (pourboire) incitent les validateurs à maximiser le nombre de transactions dans un bloc, limité uniquement par la limite de gaz du bloc. Sans pourboires, un validateur rationnel pourrait inclure moins — voire aucune — transaction sans aucune pénalité directe de la couche d'exécution ou de la couche de consensus, car les récompenses de staking sont indépendantes du nombre de transactions dans un bloc. De plus, les pourboires permettent aux utilisateurs de surenchérir sur les autres pour la priorité au sein du même bloc, signalant ainsi une urgence.
+
+### Frais maximum {#maxfee}
 
-### Frais maximums {#maxfee}
+Pour exécuter une transaction sur le réseau, les utilisateurs peuvent spécifier une limite maximale qu'ils sont prêts à payer pour que leur transaction soit exécutée. Ce paramètre facultatif est connu sous le nom de `maxFeePerGas`. Pour qu'une transaction soit exécutée, les frais max doivent dépasser la somme des frais de base et du pourboire. La différence entre les frais maximums et la somme des frais de base et du pourboire est remboursée à l'émetteur de la transaction.
 
-Pour exécuter une transaction sur le réseau, les utilisateurs peuvent spécifier une limite maximale qu'ils sont prêts à payer pour que leur transaction soit exécutée. Ce paramètre optionnel est connu sous le nom de `maxFeePerGas`. Pour qu'une transaction soit exécutée, les frais max doivent dépasser la somme des frais de base et du pourboire. La différence entre les frais maximums et la somme des frais de base et du pourboire est remboursée à l'émetteur de la transaction.
+### Taille de bloc {#block-size}
 
-### Taille des blocs {#block-size}
+Chaque bloc a une taille cible correspondant à la moitié de la limite de gaz actuelle, mais la taille des blocs augmentera ou diminuera en fonction de la demande du réseau, jusqu'à ce que la limite du bloc soit atteinte (2x la taille cible du bloc). Le protocole atteint en moyenne une taille de bloc d'équilibre à la cible par le processus de _tâtonnement_. Cela signifie que si la taille du bloc est plus importante que la taille cible du bloc, le protocole augmentera les frais de base pour le bloc suivant. De même, le protocole diminuera les frais de base si la taille du bloc est inférieure à la taille cible du bloc.
 
-Chaque bloc vise une taille cible de 30 millions de gaz, mais leur taille s'adapte aux exigences du réseau, jusqu'à une limite de 60 millions de gaz (deux fois la taille cible de bloc). Le protocole atteint une taille d'équilibre de bloc de 15 millions en moyenne grâce au processus de _tâtonnement_. Cela signifie que si la taille du bloc est plus importante que la taille cible du bloc, le protocole augmentera les frais de base pour le bloc suivant. De même, le protocole diminuera les frais de base si la taille du bloc est inférieure à la taille cible du bloc. Le montant par lequel les frais de base sont ajustés est proportionnel à l'écart entre la taille actuelle et la taille cible du bloc. [En savoir plus sur les blocs](/developers/docs/blocks/).
+Le montant par lequel les frais de base sont ajustés est proportionnel à l'écart entre la taille actuelle et la taille cible du bloc. Il s'agit d'un calcul linéaire de -12,5 % pour un bloc vide, 0 % à la taille cible, jusqu'à +12,5 % pour un bloc atteignant la limite de gaz. La limite de gaz peut fluctuer dans le temps en fonction de la signalisation des validateurs, ainsi que via les mises à niveau du réseau. Vous pouvez [voir l'évolution de la limite de gaz dans le temps ici](https://eth.blockscout.com/stats/averageGasLimit?interval=threeMonths).
 
-### Calculer les frais de gaz dans la pratique {#calculating-fees-in-practice}
+[En savoir plus sur les blocs](/developers/docs/blocks/)
+
+### Calculer les frais de gaz en pratique {#calculating-fees-in-practice}
 
 Vous pouvez indiquer explicitement le montant que vous êtes prêt à payer pour que votre transaction soit exécutée. Cependant, la plupart des fournisseurs de portefeuilles fixent automatiquement des frais de transaction recommandés (frais de base + frais de priorité recommandés) afin de réduire la complexité imposée à leurs utilisateurs.
 
@@ -98,43 +103,50 @@ Vous pouvez indiquer explicitement le montant que vous êtes prêt à payer pour
 
 En résumé, les frais de gaz aident à sécuriser le réseau Ethereum. En exigeant des frais pour chaque calcul exécuté sur le réseau, nous empêchons les acteurs malveillants de spammer le réseau. Afin d'éviter les boucles infinies accidentelles ou hostiles ou d'autres gaspillages de calcul dans le code, chaque transaction doit limiter le nombre d'étapes de calcul dans l'exécution du code. L'unité fondamentale de calcul est le « gaz ».
 
-Bien qu'une transaction comprenne une limite, tout gaz inutilisé dans une transaction est retourné à l'utilisateur (ex. `Frais maximum - (frais de base + pourboire)` est retourné).
+Bien qu'une transaction comprenne une limite, tout gaz non utilisé dans une transaction est retourné à l'utilisateur (par ex., `frais max - (frais de base + pourboire)` est retourné).
 
-![Diagramme montrant comment le gaz non utilisé est remboursé](../transactions/gas-tx.png) _Schéma adapté à partir du document [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Diagramme montrant comment le gaz non utilisé est remboursé](../transactions/gas-tx.png)
+_Diagramme adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 ## Qu'est-ce que la limite de gaz ? {#what-is-gas-limit}
 
-La limite de gaz correspond à la quantité maximale de gaz que vous êtes prêt à consommer lors d'une transaction. Les transactions plus compliquées impliquant des [contrats intelligents](/developers/docs/smart-contracts/) nécessitent plus de travail de calcul, et donc une limite de gaz supérieure à celle d'un simple paiement. Un transfert standard d'ETH nécessite une limite de gaz de 21 000 unités de gaz.
+La limite de gaz correspond à la quantité maximale de gaz que vous êtes prêt à consommer lors d'une transaction. Les transactions plus compliquées impliquant des [contrats intelligents](/developers/docs/smart-contracts/) nécessitent plus de travail de calcul, elles exigent donc une limite de gaz plus élevée qu'un simple paiement. Un transfert standard d'ETH nécessite une limite de gaz de 21 000 unités de gaz.
 
-Par exemple, si vous définissez votre limite de gaz à 50 000 pour un simple transfert ETH, l'EVM en consommera 21 000 et vous récupérerez les 29 000 restants. Cependant, si vous fixez un montant de gaz trop faible, par exemple une limite de gaz de 20 000 pour un simple transfert ETH, l'EVM consommera vos 20 000 unités de gaz en essayant de réaliser la transaction, mais celle-ci ne sera pas complète. L'EVM annule alors toute modification, mais comme le validateur a déjà effectué un travail d'une valeur de 20 000 unités de gaz, ce gaz est consommé.
+Par exemple, si vous définissez votre limite de gaz à 50 000 pour un simple transfert ETH, l'EVM en consommera 21 000 et vous récupérerez les 29 000 restants. Cependant, si vous spécifiez trop peu de gaz, par exemple une limite de gaz de 20 000 pour un simple transfert d’ETH, la transaction échouera lors de la phase de validation. Elle sera rejetée avant d’être incluse dans un bloc, et aucun gaz ne sera consommé. En revanche, si une transaction épuise tout son gaz pendant l'exécution (par exemple, un contrat intelligent utilise tout le gaz à mi-parcours), l'EVM
+annulera toutes les modifications effectuées, mais tout le gaz fourni sera tout de même consommé pour le travail accompli.
 
 ## Pourquoi les frais de gaz peuvent-ils devenir si élevés ? {#why-can-gas-fees-get-so-high}
 
 Les frais élevés de gaz sont le fruit de la popularité d'Ethereum. Si la demande est trop forte, les utilisateurs doivent proposer des pourboires plus élevés pour tenter de surenchérir sur les transactions des autres utilisateurs. Un pourboire plus élevé augmentera la possibilité que votre transaction soit intégrée au prochain bloc. De plus, les applications de contrats intelligents plus complexes peuvent effectuer de nombreuses opérations pour assurer leurs fonctions, ce qui leur fait consommer beaucoup de gaz.
 
-## Initiatives mises en œuvre pour réduire les coûts du gaz {#initiatives-to-reduce-gas-costs}
+## Initiatives pour réduire les coûts du gaz {#initiatives-to-reduce-gas-costs}
+
+Les [mises à niveau de la scalabilité](/roadmap/) d'Ethereum devraient à terme résoudre certains des problèmes de frais de gaz, ce qui, à son tour, permettra à la plateforme de traiter des milliers de transactions par seconde et de s'adapter à l'échelle mondiale.
 
-[Les mises à jour d'évolutivité](/roadmap/) d'Ethereum devraient en fin de compte résoudre certains problèmes liés aux frais de gaz et permettra à la plate-forme de traiter des milliers de transactions par seconde et à l'échelle mondiale.
+La mise à l'échelle de la couche 2 est une initiative primordiale pour améliorer considérablement les coûts de gaz, l'expérience utilisateur et l'évolutivité.
 
-La mise à l'échelle de la couche 2 est une initiative primordiale pour améliorer considérablement les coûts de gaz, l'expérience utilisateur et l'évolutivité. [En savoir plus sur la mise à l'échelle de la couche 2](/developers/docs/scaling/#layer-2-scaling).
+[En savoir plus sur la mise à l'échelle de couche 2](/developers/docs/scaling/#layer-2-scaling)
 
-## Suivi des frais de gaz {#monitoring-gas-fees}
+## Surveillance des frais de gaz {#monitoring-gas-fees}
 
 Si vous voulez surveiller les prix du gaz et pouvoir envoyer votre ETH à moindre coût, vous pouvez utiliser différents outils comme :
 
-- [Etherscan](https://etherscan.io/gastracker) _- Évaluateur du prix du gaz pour une transaction_
-- [Suivi du gaz ETH](https://www.ethgastracker.com/) _Surveillez et suivez les prix du gaz sur Ethereum et des solutions de niveau 2 pour réduire les frais de transaction et économiser de l'argent_
-- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _Extension Chrome pour estimer le gaz à la fois pour les transactions de Type 0 et les transactions de Type 2 EIP-1559 ._
-- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _Calculez les frais de gaz dans votre devise locale pour différents types de transaction sur le réseau principal, Arbitrum et Polygon._
+- [Etherscan](https://etherscan.io/gastracker) _Estimateur du prix du gaz de transaction_
+- [Blockscout](https://eth.blockscout.com/gas-tracker) _Estimateur open source du prix du gaz de transaction_
+- [ETH Gas Tracker](https://www.ethgastracker.com/) _Surveillez et suivez les prix du gaz d'Ethereum et de L2 pour réduire les frais de transaction et économiser de l'argent_
+- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _Extension Chrome d'estimation du gaz prenant en charge à la fois les transactions héritées de Type 0 et les transactions de Type 2 EIP-1559._
+- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _Calculez les frais de gaz dans votre devise locale pour différents types de transactions sur le réseau principal (Mainnet), Arbitrum et Polygon._
 
 ## Outils connexes {#related-tools}
 
-- [Blocknative's Gas Platform](https://www.blocknative.com/gas) _API d'estimation de gaz propulsé par la plate-forme globale Blocknative de données mempool_
+- [Plateforme Gas de Blocknative](https://www.blocknative.com/gas) _API d'estimation du gaz alimentée par la plateforme mondiale de données mempool de Blocknative_
+- [Gas Network](https://gas.network) Oracles de gaz en chaîne. Prise en charge de plus de 35 chaînes.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Explication du gaz sur Ethereum](https://defiprime.com/gas)
+- [Le gaz d'Ethereum expliqué](https://defiprime.com/gas)
 - [Réduire la consommation de gaz de vos contrats intelligents](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
-- [Des Stratégies pour Optimiser la Consommation de Gas, pour les Développeurs](https://www.alchemy.com/overviews/solidity-gas-optimization)
-- [documentation EIP-1559](https://eips.ethereum.org/EIPS/eip-1559).
-- [Ressources EIP-1559 de Tim Beiko](https://hackmd.io/@timbeiko/1559-resources).
+- [Stratégies d'optimisation du gaz pour les développeurs](https://www.alchemy.com/overviews/solidity-gas-optimization)
+- [Documentation EIP-1559](https://eips.ethereum.org/EIPS/eip-1559).
+- [Ressources EIP-1559 de Tim Beiko](https://hackmd.io/@timbeiko/1559-resources)
+- [EIP-1559 : séparer les mécanismes des mèmes](https://web.archive.org/web/20241126205908/https://research.2077.xyz/eip-1559-separating-mechanisms-from-memes)
diff --git a/public/content/translations/fr/developers/docs/ides/index.md b/public/content/translations/fr/developers/docs/ides/index.md
index d5921288ca1..784158de32f 100644
--- a/public/content/translations/fr/developers/docs/ides/index.md
+++ b/public/content/translations/fr/developers/docs/ides/index.md
@@ -1,6 +1,6 @@
 ---
-title: Environnements de développement intégrés (IDE)
-description:
+title: "Environnements de développement intégrés (IDE)"
+description: Learn about web-based and desktop IDEs for Ethereum development, including Remix, VS Code, and popular plugins.
 lang: fr
 ---
 
@@ -10,31 +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](https://remix.ethereum.org/)** - **_IDE basé sur le Web avec une analyse statique, et une machine virtuelle de test de la blockchain_**
+**[Remix](https://remix.ethereum.org/)** – **_IDE basé sur le Web avec une analyse statique intégrée et une machine virtuelle de blockchain de test_**
 
 - [Documentation](https://remix-ide.readthedocs.io/en/latest/#)
 - [Gitter](https://gitter.im/ethereum/remix)
 
-**[ChainIDE](https://chainide.com/)** - **_Un IDE multichaîne basée sur le cloud_**
+**[ChainIDE](https://chainide.com/)** – **_Un IDE multichaîne basé sur le cloud_**
 
 - [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._**
+**[Replit (Solidity Starter - Beta)](https://replit.com/@replit/Solidity-starter-beta)** – **_Un environnement de développement personnalisable pour Ethereum avec rechargement à chaud, vérification des erreurs et un support de premier ordre pour les réseaux de test_**
 
 - [Documentation](https://docs.replit.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_**
+**[Tenderly Sandbox](https://sandbox.tenderly.co/)** – **_Un environnement de prototypage rapide où vous pouvez écrire, exécuter et déboguer des contrats intelligents dans le navigateur en utilisant Solidity et JavaScript_**
 
-**[EthFiddle](https://ethfiddle.com/)** - **_IDE basé sur le Web qui vous permet d'écrire, de compiler et de déboguer votre contrat intelligent._**
+**[EthFiddle](https://ethfiddle.com/)** – **_IDE Web qui vous permet d'écrire, de compiler et de déboguer votre contrat intelligent_**
 
 - [Gitter](https://gitter.im/loomnetwork/ethfiddle)
 
 ## IDE de bureau {#desktop-ides}
 
-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/).
+La plupart des IDE ont permis de construire des plugins pour améliorer l'expérience de développement Ethereum. Au minimum, ils fournissent la coloration syntaxique pour les [langages de contrats intelligents](/developers/docs/smart-contracts/languages/).
 
-**Visual Studio Code -** **_IDE professionnel multiplateforme avec le support officiel d'Ethereum._**
+**Visual Studio Code –** **_IDE professionnel multiplateforme avec un support officiel pour Ethereum_**
 
 - [Visual Studio Code](https://code.visualstudio.com/)
 - [Exemples de code](https://github.com/Azure-Samples/blockchain/blob/master/blockchain-workbench/application-and-smart-contract-samples/readme.md)
@@ -46,19 +46,19 @@ La plupart des IDE ont permis de construire des plugins pour améliorer l'expér
 - [GitHub](https://github.com/JetBrains)
 - [IntelliJ Solidity](https://github.com/intellij-solidity/intellij-solidity/)
 
-**Remix Desktop -** **_Essayez Remix IDE sur votre machine locale._**
+**Remix Desktop –** **_Essayez l'IDE Remix sur votre machine locale_**
 
-- [Téléchargement](https://github.com/ethereum/remix-desktop/releases)
+- [Télécharger](https://github.com/ethereum/remix-desktop/releases)
 - [GitHub](https://github.com/ethereum/remix-desktop)
 
 ## 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
+- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) – Langage Ethereum Solidity pour Visual Studio Code
+- [Solidity + Hardhat for VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) – Support 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}
+## En savoir plus {#further-reading}
 
-- [ IDEs pour Ethereum](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _- Liste d'IDEs pour Ethereum par Alchemy_
+- [IDE Ethereum](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _– La liste d'IDE Ethereum d'Alchemy_
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/index.md b/public/content/translations/fr/developers/docs/index.md
index 89789225a04..8410d5b0400 100644
--- a/public/content/translations/fr/developers/docs/index.md
+++ b/public/content/translations/fr/developers/docs/index.md
@@ -1,6 +1,6 @@
 ---
-title: Documentation sur le développement Ethereum
-description: Introduction à la documentation d'ethereum.org.
+title: "Documentation sur le développement Ethereum"
+description: "Introduction à la documentation d'ethereum.org."
 lang: fr
 ---
 
@@ -20,6 +20,6 @@ S'il s'agit de votre première tentative de développement pour Ethereum, nous v
 
 <DeveloperDocsLinks headerId="ethereum-stack" />
 
-### Sujets avancés {#advanced}
+### Avancé {#advanced}
 
 <DeveloperDocsLinks headerId="advanced" />
diff --git a/public/content/translations/fr/developers/docs/intro-to-ether/index.md b/public/content/translations/fr/developers/docs/intro-to-ether/index.md
index 79d9e3bd9be..0d3ca63b986 100644
--- a/public/content/translations/fr/developers/docs/intro-to-ether/index.md
+++ b/public/content/translations/fr/developers/docs/intro-to-ether/index.md
@@ -1,12 +1,12 @@
 ---
-title: Introduction à l'ether
-description: Une introduction pour développeur à la cryptomonnaie ether.
+title: "Introduction technique à l’ether"
+description: "Une introduction pour développeur à la cryptomonnaie ether."
 lang: fr
 ---
 
 ## Prérequis {#prerequisites}
 
-Pour vous aider à mieux comprendre cette page, nous vous recommandons de commencer par lire cette [introduction à Ethereum](/developers/docs/intro-to-ethereum/).
+Pour vous aider à mieux comprendre cette page, nous vous recommandons de lire d'abord l'[Introduction à Ethereum](/developers/docs/intro-to-ethereum/).
 
 ## Qu'est-ce qu'une cryptomonnaie ? {#what-is-a-cryptocurrency}
 
@@ -18,35 +18,35 @@ La première cryptomonnaie a été le Bitcoin, créé par Satoshi Nakamoto. Depu
 
 ## Qu'est-ce-que l'ether ? {#what-is-ether}
 
-**Ether (ETH)** est la cryptomonnaie utilisée pour de multiples choses sur le réseau Ethereum. Fondamentalement, il s'agit de la seule forme de paiement valide pour les frais de transaction, et depuis [la fusion](/roadmap/merge), l'ether est nécessaire pour valider et proposer des blocs sur le réseau principal. L'Ether est également utilisé comme principale forme de garantie dans les marchés de prêts [DeFi](/defi), en tant qu'unité de compte sur les places de marché NFT, comme paiement gagné pour l'exécution de services ou la vente de biens réels, et bien plus encore.
+**L'ether (ETH)** est la cryptomonnaie utilisée pour de nombreuses choses sur le réseau Ethereum. Fondamentalement, c'est la seule forme de paiement acceptable pour les frais de transaction et, après [La Fusion](/roadmap/merge), l'ether est requis pour valider et proposer des blocs sur le réseau principal. L'ether est également utilisé comme principale forme de garantie sur les marchés de prêts [DeFi](/defi), en tant qu'unité de compte sur les places de marché NFT, comme paiement perçu pour des prestations de services ou la vente de biens réels, et plus encore.
 
-Ethereum permet aux développeurs de créer des [**applications décentralisées (dApps)**](/developers/docs/dapps), qui partagent toutes une réserve de puissance informatique. Ce pool partagé est fini ainsi, Ethereum a besoin d'un mécanisme pour déterminer qui peut l'utiliser. Dans le cas contraire, une dapp pourrait consommer accidentellement ou de manière malveillante toutes les ressources du réseau, ce qui empêcherait les autres d'y accéder.
+Ethereum permet aux développeurs de créer des [**applications décentralisées (dapps)**](/developers/docs/dapps), qui partagent toutes une réserve de puissance de calcul. Ce pool partagé est fini ainsi, Ethereum a besoin d'un mécanisme pour déterminer qui peut l'utiliser. Dans le cas contraire, une dapp pourrait consommer accidentellement ou de manière malveillante toutes les ressources du réseau, ce qui empêcherait les autres d'y accéder.
 
-La cryptomonnaie ether prend en charge un mécanisme de tarification de la puissance informatique d'Ethereum. Lorsque les utilisateurs veulent faire une transaction, ils doivent payer un certain montant en ether pour que leur transaction soit reconnue sur la blockchain. Ces coûts d'utilisation sont connus sous le nom de [frais de gaz](/developers/docs/gas/) qui varient en fonction de la quantité de puissance de calcul nécessaire pour exécuter la transaction et de la demande de puissance informatique à l'échelle du réseau à ce même moment.
+La cryptomonnaie ether prend en charge un mécanisme de tarification de la puissance informatique d'Ethereum. Lorsque les utilisateurs veulent faire une transaction, ils doivent payer un certain montant en ether pour que leur transaction soit reconnue sur la blockchain. Ces coûts d'utilisation sont connus sous le nom de [frais de gaz](/developers/docs/gas/), et les frais de gaz dépendent de la quantité de puissance de calcul requise pour exécuter la transaction et de la demande de puissance de calcul à l'échelle du réseau à ce moment-là.
 
 Par conséquent, même si une dapp malveillante a soumis une boucle infinie, la transaction finirait par être à court d'ether et donc par se terminer, permettant au réseau de revenir à la normale.
 
-Il est [courant de confondre](https://abcnews.go.com/Business/bitcoin-slumps-week-low-amid-renewed-worries-chinese/story?id=78399845) Ethereum et ether — lorsque les gens font référence au « prix de l'Ethereum », ils décrivent le prix de l'ether.
+Il est [courant de confondre](https://abcnews.go.com/Business/bitcoin-slumps-week-low-amid-renewed-worries-chinese/story?id=78399845) Ethereum et l'ether — lorsque les gens font référence au "prix d'Ethereum", ils décrivent le prix de l'ether.
 
-## Frapper de l'ether {#minting-ether}
+## Frappe d'ether {#minting-ether}
 
 Frapper de l'ether est le processus par lequel de nouveaux éther sont créés sur le registre Ethereum. Le protocole Ethereum sous-jacent crée le nouvel éther. Il est impossible pour un utilisateur de créer de l'éther.
 
 L'Ether est frappé comme une récompense pour chaque bloc proposé et à chaque point de contrôle de période pour les autres activités du validateur liées à l'obtention d'un consensus. Le montant total émis dépend du nombre de validateurs et de la quantité d'Ether qu'ils ont misé. Cette émission totale est répartie équitablement entre les validateurs dans le cas idéal où tous les validateurs sont honnêtes et en ligne, mais en réalité, il varie en fonction de la performance du validateur. Environ 1/8ème de l'émission totale va à la personne proposant le bloc ; le reste est réparti entre les autres validateurs. Les proposants de blocs reçoivent également des pourboires provenant des frais de transaction et des revenus liés au MEV, mais ceux-ci proviennent de l'Ether recyclé, et non d'une nouvelle émission.
 
-## Brûler de l'ether {#burning-ether}
+## Brûlage d'ether {#burning-ether}
 
 L'éther peut être créé par le biais de récompenses en bloc. Il peut aussi être détruit par un processus appelé « burn ». Quand l'ether est brûlé, il est retiré de la circulation de façon permanente.
 
-Le brûlage d'ether se produit pour chaque transaction sur Ethereum. Lorsque les utilisateurs paient pour leurs transactions, des frais de base de gaz fixés par le réseau en fonction de la demande transactionnelle, sont détruits. Ceci, couplé à des tailles variables de blocs et à des frais de gaz maximaux, simplifie l'estimation des frais de transaction sur Ethereum. Lorsque la demande du réseau est élevée, les [blocs](https://etherscan.io/block/12965263) peuvent brûler plus d'ether qu'ils n'en frappent, compensant ainsi efficacement la création d'ether.
+Le brûlage d'ether se produit pour chaque transaction sur Ethereum. Lorsque les utilisateurs paient pour leurs transactions, des frais de base de gaz fixés par le réseau en fonction de la demande transactionnelle, sont détruits. Ceci, couplé à des tailles variables de blocs et à des frais de gaz maximaux, simplifie l'estimation des frais de transaction sur Ethereum. Lorsque la demande du réseau est élevée, les [blocs](https://eth.blockscout.com/block/22580057) peuvent brûler plus d'ether qu'ils n'en frappent, compensant ainsi efficacement l'émission d'ether.
 
-Brûler les frais de base entrave la capacité des producteurs de blocs à manipuler les transactions. Par exemple, si les créateurs de blocs obtiennent les frais de base, ils pourraient inclure leurs propres transactions gratuitement et augmenter les frais de base pour tous les autres. Ils pourraient également rembourser les frais de base à certains utilisateurs hors chaîne, engendrant un marché des frais de transaction plus opaque et plus complexe.
+Brûler les frais de base entrave la capacité d'un producteur de blocs à manipuler les transactions. Par exemple, si les créateurs de blocs obtiennent les frais de base, ils pourraient inclure leurs propres transactions gratuitement et augmenter les frais de base pour tous les autres. Ils pourraient également rembourser les frais de base à certains utilisateurs hors chaîne, engendrant un marché des frais de transaction plus opaque et plus complexe.
 
-## Dénominations d'ether {#denominations}
+## Dénominations de l'ether {#denominations}
 
 Étant donné que de nombreuses transactions sur Ethereum sont d'un faible montant, l'éther dispose de plusieurs unités de valeur qui peuvent être référencées pour de plus petites sommes. Parmi ces unités, le wei et le gwei sont particulièrement importantes.
 
-Le Wei est la plus petite quantité possible d'éther, et par conséquent, de nombreuses implémentations techniques, comme le [livre jaune d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf), baseront tous leurs calculs sur le Wei.
+Le wei est la plus petite quantité possible d'ether et, par conséquent, de nombreuses implémentations techniques, telles que le [Livre jaune d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf), baseront tous les calculs sur le wei.
 
 Le Gwei, abrégé de giga-wei, est souvent utilisé pour décrire les frais de gaz sur Ethereum.
 
@@ -55,24 +55,24 @@ Le Gwei, abrégé de giga-wei, est souvent utilisé pour décrire les frais de g
 | Wei          | 10<sup>-18</sup> | Implémentations techniques        |
 | Gwei         | 10<sup>-9</sup>  | Frais de gaz lisibles par l'homme |
 
-## Transférer de l'ether {#transferring-ether}
+## Transfert d'ether {#transferring-ether}
 
-Chaque transaction sur Ethereum contient un champ `valeur` , qui spécifie le montant d'éther à transférer, libellé en wei, à envoyer de l'adresse de l'expéditeur à celle du destinataire.
+Chaque transaction sur Ethereum contient un champ `value`, qui spécifie le montant d'ether à transférer, libellé en wei, à envoyer de l'adresse de l'expéditeur à l'adresse du destinataire.
 
-Quand l'adresse du destinataire est un [contrat intelligent](/developers/docs/smart-contracts/), cet ether transféré peut être utilisé pour payer du gaz lorsque le contrat intelligent exécute son code.
+Lorsque l'adresse du destinataire est un [contrat intelligent](/developers/docs/smart-contracts/), cet ether transféré peut être utilisé pour payer le gaz lorsque le contrat intelligent exécute son code.
 
-[Plus d'infos sur les transactions](/developers/docs/transactions/)
+[En savoir plus sur les transactions](/developers/docs/transactions/)
 
-## Interrogation de l'ether {#querying-ether}
+## Consulter le solde d'ether {#querying-ether}
 
-Les utilisateurs peuvent interroger le solde en ether de n'importe quel [compte](/developers/docs/accounts/) en inspectant son champ du `balance`, qui indique la quantité d'ether possédée en wei.
+Les utilisateurs peuvent consulter le solde d'ether de n'importe quel [compte](/developers/docs/accounts/) en inspectant le champ `balance` du compte, qui indique les avoirs en ether libellés en wei.
 
-[Etherscan](https://etherscan.io) est un outil populaire pour inspecter les soldes d'adresses via une application basée sur le Web. Par exemple, [cette page Etherscan](https://etherscan.io/address/0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae) affiche le solde de l'Ethereum Foundation. Les soldes du compte peuvent également être interrogés en utilisant des portefeuilles ou directement, en faisant des requêtes aux nœuds.
+[Etherscan](https://etherscan.io) et [Blockscout](https://eth.blockscout.com) sont des outils populaires pour inspecter les soldes d'adresses via des applications Web. Par exemple, [cette page Blockscout](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe) montre le solde de la Ethereum Foundation. Les soldes du compte peuvent également être interrogés en utilisant des portefeuilles ou directement, en faisant des requêtes aux nœuds.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Définition d'Ether et d'Ethereum](https://www.cmegroup.com/education/courses/introduction-to-ether/defining-ether-and-ethereum.html) – _Groupe CME_
-- [Livre blanc Ethereum](/whitepaper/): La proposition originale pour Ethereum. Ce document contient une description de l'ether et les motivations de sa création.
-- [Calculatrice de Gwei](https://www.alchemy.com/gwei-calculator) : Utilisez cette calculatrice de Gwei pour facilement convertir Wei, Gwei et Ether. Il vous suffit d'introduire n'importe quelle quantité de Wei, Gwei ou ETH et de calculer automatiquement la conversion.
+- [Définition de l'ether et d'Ethereum](https://www.cmegroup.com/education/courses/introduction-to-ether/defining-ether-and-ethereum.html) – _CME Group_
+- [Livre blanc d'Ethereum](/whitepaper/) : La proposition originale pour Ethereum. Ce document contient une description de l'ether et les motivations de sa création.
+- [Calculateur de Gwei](https://www.alchemy.com/gwei-calculator) : Utilisez ce calculateur de gwei pour convertir facilement du wei, du gwei et de l'ether. Il vous suffit d'introduire n'importe quelle quantité de Wei, Gwei ou ETH et de calculer automatiquement la conversion.
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/intro-to-ethereum/index.md b/public/content/translations/fr/developers/docs/intro-to-ethereum/index.md
index bfb6c9aa3a7..8618b155df6 100644
--- a/public/content/translations/fr/developers/docs/intro-to-ethereum/index.md
+++ b/public/content/translations/fr/developers/docs/intro-to-ethereum/index.md
@@ -1,28 +1,28 @@
 ---
-title: Introduction à Ethereum
-description: Introduction aux concepts fondamentaux d'Ethereum pour les développeurs de DApp.
+title: "Introduction technique à Ethereum"
+description: "Introduction aux concepts fondamentaux d'Ethereum pour les développeurs de DApp."
 lang: fr
 ---
 
 ## Qu'est-ce qu'une blockchain ? {#what-is-a-blockchain}
 
-Une blockchain est une base de données publique qui est mise à jour et partagée entre les nombreux ordinateurs d'un réseau.
+Une blockchain est une base de données publique qui est mise à jour et partagée entre de nombreux ordinateurs sur un réseau.
 
-« Block » fait référence au fait que les données et l'état sont stockés dans des lots séquentiels ou « blocs ». Si vous envoyez de l'ETH à quelqu'un, les données de la transaction doivent être ajoutées à un bloc pour que cette dernière réussisse.
+« Block » fait référence au fait que les données et l'état sont stockés dans des lots séquentiels ou « blocs ». Si vous envoyez de l'ETH à quelqu'un d'autre, les données de la transaction doivent être ajoutées à un bloc pour que cette dernière réussisse.
 
 « Chain » désigne le fait que chaque bloc fait cryptographiquement référence à son parent. En d'autres termes, les blocs sont enchaînés. Les données d'un bloc ne peuvent pas être modifiées sans changer tous les blocs suivants, ce qui nécessiterait le consensus de l'ensemble du réseau.
 
 Chaque ordinateur du réseau doit accepter chaque nouveau bloc, ainsi que la chaîne dans son intégralité. Ces ordinateurs sont appelés des « nœuds ». Les nœuds garantissent que toutes les personnes qui interagissent avec la blockchain disposent des mêmes données. Pour assurer que tous les nœuds soient d'accord, les blockchains ont besoin d'un mécanisme de consensus.
 
-Ethereum utilise un mécanisme de consensus basé sur [la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Quiconque souhaite ajouter de nouveaux blocs à la chaîne, doit staker de l'ETH - la monnaie native d'Ethereum - qui pourra être utilisée en tant que collatéral et logiciel de validation. Ces "validateurs" peuvent ensuite être sélectionnés aléatoirement pour soumettre des blocs, lesquels seront envoyés à d'autres validateurs pour vérification et ajoutés à la chaîne de blocs. Il existe un système de récompenses et de pénalités qui incite fortement les participants à être honnêtes et disponibles en ligne autant que possible.
+Ethereum utilise un [mécanisme de consensus basé sur la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Quiconque souhaite ajouter de nouveaux blocs à la chaîne, doit staker de l'ETH - la monnaie native d'Ethereum - qui pourra être utilisée en tant que collatéral et logiciel de validation. Ces "validateurs" peuvent ensuite être sélectionnés aléatoirement pour soumettre des blocs, lesquels seront envoyés à d'autres validateurs pour vérification et ajoutés à la chaîne de blocs. Il existe un système de récompenses et de pénalités qui incite fortement les participants à être honnêtes et disponibles en ligne autant que possible.
 
-Si vous souhaitez voir comment les données de la blockchain sont hachées puis ajoutées à l'historique des références des blocs, consultez [cette démo](https://andersbrownworth.com/blockchain/blockchain) d'Anders Brownworth et regardez la vidéo d'accompagnement ci-dessous.
+Si vous souhaitez voir comment les données de la blockchain sont hachées et ensuite ajoutées à l'historique des références de blocs, ne manquez pas de consulter [cette démo](https://andersbrownworth.com/blockchain/blockchain) d'Anders Brownworth et de regarder la vidéo d'accompagnement ci-dessous.
 
 Regardez Anders expliquer le hachage dans les blockchains :
 
 <YouTube id="_160oMzblY8" />
 
-## Qu'est-ce qu'Ethereum ? {#what-is-ethereum}
+## Qu'est-ce qu'Ethereum ? {#what-is-ethereum}
 
 Ethereum est une blockchain avec un ordinateur intégré. C'est la base pour élaborer des applications et des organisations d'une manière décentralisée, sans demande de permission et en résistant à la censure.
 
@@ -34,17 +34,17 @@ Les mécanismes cryptographiques garantissent qu'une fois que les transactions s
 
 ## Qu'est-ce-que l'ether ? {#what-is-ether}
 
-**Ether (ETH)** est la cryptomonnaie native d'Ethereum. L'objectif de l'ETH est de créer un marché du calcul. Un tel marché incite économiquement les participants à vérifier/exécuter les demandes de transaction et à fournir des ressources informatiques au réseau.
+**L'Ether (ETH)** est la cryptomonnaie native d'Ethereum. L'objectif de l'ETH est de créer un marché du calcul. Un tel marché incite économiquement les participants à vérifier/exécuter les demandes de transaction et à fournir des ressources informatiques au réseau.
 
 Tout participant qui diffuse une demande de transaction doit également offrir une certaine quantité d'ETH au réseau comme prime. Le réseau brule une partie de cette prime et versera le reste à quiconque effectuera le travail de vérification de la transaction, l'exécutera, l'enregistrera dans la blockchain et la diffusera sur le réseau.
 
 La quantité d'ETH payée correspond aux ressources nécessaires pour effectuer les calculs. Ces primes empêchent également les participants malveillants de bloquer intentionnellement le réseau en demandant l'exécution de boucles infinies ou d'autres scripts gourmands en ressources, dans la mesure où ces participants doivent payer les ressources de calcul qu'ils réquisitionnent.
 
-L'ETH est également utilisé pour fournir une sécurité crypto-économique au réseau de trois manières principales : 1 - il est utilisé comme moyen de récompenser les validateurs qui proposent des blocs ou encore empêcher des appels aux comportements malhonnêtes par d'autres validateurs ; 2 - il est misé par des validateurs, agissant ainsi comme collatéral contre un comportement malhonnête — si les validateurs tentent de mal se comporter, leur ETH peut être détruit ; 3 - il est utilisé pour pondérer les « votes » pour les blocs nouvellement proposés, en alimentant la partie de fourche du mécanisme de consensus.
+L'ETH est également utilisé pour fournir une sécurité crypto-économique au réseau de trois manières principales : 1) il est utilisé comme moyen de récompenser les validateurs qui proposent des blocs ou qui dénoncent le comportement malhonnête d'autres validateurs ; 2) il est mis en jeu par les validateurs, agissant comme collatéral contre un comportement malhonnête — si les validateurs tentent de se comporter de manière malhonnête, leurs ETH peuvent être détruits ; 3) il est utilisé pour pondérer les « votes » pour les blocs nouvellement proposés, alimentant la partie du mécanisme de consensus relative au choix de la fourche.
 
-## Qu'est-ce qu'un contrat intelligent ? {#what-are-smart-contracts}
+## Qu'est-ce qu'un contrat intelligent ? Que sont les contrats intelligents ? {#what-are-smart-contracts}
 
-En pratique, les participants n'écrivent pas de nouveau code chaque fois qu'ils veulent demander un calcul sur l'EVM. À la place, les développeurs d'applications téléchargent des programmes (extraits de code réutilisables) dans la mémoire de l'EVM et les utilisateurs exécutent des requêtes pour exécuter ces extraits de codes selon des paramètres variables. On appelle « contrats intelligents » les programmes téléchargés sur le réseau et exécutés par celui-ci.
+En pratique, les participants n'écrivent pas de nouveau code chaque fois qu'ils veulent demander un calcul sur l'EVM. À la place, les développeurs d'applications téléchargent des programmes (extraits de code réutilisables) dans la mémoire de l'EVM et les utilisateurs exécutent des requêtes pour exécuter ces extraits de codes selon des paramètres variables. On appelle "contrats intelligents" les programmes téléversés sur le réseau et exécutés par celui-ci.
 
 Pour faire simple, vous pouvez imaginer qu'un contrat intelligent est une sorte de distributeur automatique : un script qui, lorsqu'il est appelé selon certains paramètres, effectue des actions ou des calculs si certaines conditions sont réunies. Par exemple, un simple contrat intelligent de vendeur pourrait créer et assigner la propriété d'un actif numérique lorsque l'appelant envoie de l'ETH à un destinataire spécifique.
 
@@ -60,27 +60,27 @@ L'ensemble des blocs engagés sur le réseau Ethereum depuis le début de son hi
 
 ### ETH {#eth}
 
-**Ether (ETH)** est la cryptomonnaie native d'Ethereum. Les utilisateurs payent les autres utilisateurs en ETH afin que leurs demandes d'exécution de code soient satisfaites.
+**L'Ether (ETH)** est la cryptomonnaie native d'Ethereum. Les utilisateurs payent les autres utilisateurs en ETH afin que leurs demandes d'exécution de code soient satisfaites.
 
-[Autres informations sur ETH](/developers/docs/intro-to-ether/)
+[En savoir plus sur l'ETH](/developers/docs/intro-to-ether/)
 
 ### EVM {#evm}
 
 La machine virtuelle Ethereum est l’ordinateur virtuel mondial dont chaque participant du réseau Ethereum stocke et approuve l'état. N'importe quel participant peut demander une exécution de code arbitraire sur l'EVM. Une exécution de code modifie l'état de l'EVM.
 
-[Plus d'infos sur l'EVM](/developers/docs/evm/)
+[En savoir plus sur l'EVM](/developers/docs/evm/)
 
 ### Nœuds {#nodes}
 
 Les machines réelles qui stockent l'état de l'EVM. Les nœuds communiquent les uns avec les autres pour propager les informations sur l'état de l'EVM et les nouveaux changements d'état. N'importe quel utilisateur peut également demander une exécution de code en diffusant une demande d'exécution de code depuis un nœud. Le réseau Ethereum lui-même est le regroupement de tous les nœuds Ethereum et de leurs communications.
 
-[Plus d'infos sur les nœuds](/developers/docs/nodes-and-clients/)
+[En savoir plus sur les nœuds](/developers/docs/nodes-and-clients/)
 
 ### Comptes {#accounts}
 
 Où est stocké ETH ? Les utilisateurs peuvent initialiser des comptes, y déposer des ETH et en transférer à d'autres utilisateurs. Les comptes et les soldes des comptes sont stockés dans une grande table au sein de l’EVM. Ils font partie de l’état global de l’EVM.
 
-[Plus d'infos sur les comptes](/developers/docs/accounts/)
+[En savoir plus sur les comptes](/developers/docs/accounts/)
 
 ### Transactions {#transactions}
 
@@ -90,27 +90,35 @@ Une « demande de transaction » est le terme officiel pour une demande d'exécu
 - Publier un code de contrat intelligent dans l'état de l'EVM.
 - Exécuter le code du contrat intelligent à l'adresse X dans l'EVM, avec les arguments Y.
 
-[Plus d'infos sur les transactions](/developers/docs/transactions/)
+[En savoir plus sur les transactions](/developers/docs/transactions/)
 
 ### Blocs {#blocks}
 
 Le volume des transactions est très élevé, les transactions sont donc « engagées » en lots, ou en « blocs ». Les blocs contiennent généralement des dizaines à des centaines de transactions.
 
-[Plus d'infos sur les blocs](/developers/docs/blocks/)
+[En savoir plus sur les blocs](/developers/docs/blocks/)
 
 ### Contrats intelligents {#smart-contracts}
 
-Extraits de code réutilisables (un programme) qu'un développeur publie dans l'état de l'EVM. N'importe qui peut demander l'exécution du code d'un contrat intelligent en faisant une demande de transaction. Étant donné que les développeurs peuvent écrire des applications exécutables arbitraires dans l'EVM (jeux, places de marché, instruments financiers, etc.) en publiant des contrats intelligents, ceux-ci sont aussi souvent appelés [dApps, ou Applications décentralisées](/developers/docs/dapps/).
+Extraits de code réutilisables (un programme) qu'un développeur publie dans l'état de l'EVM. N'importe qui peut demander l'exécution du code d'un contrat intelligent en faisant une demande de transaction. Parce que les développeurs peuvent écrire des applications exécutables arbitraires dans l'EVM (jeux, places de marché, instruments financiers, etc.) en publiant des contrats intelligents, celles-ci sont souvent aussi appelées [dapps, ou applications décentralisées](/developers/docs/dapps/).
 
-[Plus d'infos sur les contrats intelligents](/developers/docs/smart-contracts/)
+[En savoir plus sur les contrats intelligents](/developers/docs/smart-contracts/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Livre blanc Ethereum](/whitepaper/)
-- [Comment fonctionne Ethereum, en fait ?](https://medium.com/@preethikasireddy/how-does-ethereum-work-anyway-22d1df506369) - _Preethi Kasireddy_ (**NB** cette ressource est toujours utile mais sachez qu'elle est antérieure à [La Fusion](/roadmap/merge) et fait donc toujours référence au mécanisme de preuve de travail d'Ethereum - Ethereum est désormais sécurisé par la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos))
+- [Livre blanc d'Ethereum](/whitepaper/)
+- [Comment fonctionne Ethereum, au fait ?](https://medium.com/@preethikasireddy/how-does-ethereum-work-anyway-22d1df506369) - _Preethi Kasireddy_ (**NB :** cette ressource est toujours utile, mais sachez qu'elle est antérieure à [La Fusion](/roadmap/merge) et fait donc toujours référence au mécanisme de preuve de travail d'Ethereum. Ethereum est désormais sécurisé par la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos)).
+
+### Davantage qu'un apprenant visuel ? {#visual-learner}
+
+Cette série de vidéos propose une exploration approfondie des sujets fondamentaux :
+
+<YouTube id="j78ZcIIpi0Q"/>
+
+[Playlist des bases d'Ethereum](https://youtube.com/playlist?list=PLqgutSGloqiJyyoL0zvLVFPS-GMD2wKa5&si=kZTf5I7PKGTXDsOZ)
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Guide du développeur pour Ethereum, partie 1](/developers/tutorials/a-developers-guide-to-ethereum-part-one/) _ - Une exploration d'Ethereum utilisant Python et Web3.py pour les grands débutants_
+- [Guide du développeur pour Ethereum, partie 1](/developers/tutorials/a-developers-guide-to-ethereum-part-one/) _– Une exploration d'Ethereum utilisant Python et web3.py pour les grands débutants_
diff --git a/public/content/translations/fr/developers/docs/layer-2-scaling/index.md b/public/content/translations/fr/developers/docs/layer-2-scaling/index.md
index 4ab2d3a43d0..f3d7c61a1e6 100644
--- a/public/content/translations/fr/developers/docs/layer-2-scaling/index.md
+++ b/public/content/translations/fr/developers/docs/layer-2-scaling/index.md
@@ -1,6 +1,6 @@
 ---
-title: Évolutivité vers la couche 2
-description: Introduction aux différentes options d'évolutivité actuellement en cours de développement par la communauté Ethereum.
+title: "Évolutivité vers la couche 2"
+description: "Introduction aux différentes options d'évolutivité actuellement en cours de développement par la communauté Ethereum."
 lang: fr
 incomplete: true
 sidebarDepth: 3
diff --git a/public/content/translations/fr/developers/docs/mev/index.md b/public/content/translations/fr/developers/docs/mev/index.md
index f93832d3576..ea5a568d9cc 100644
--- a/public/content/translations/fr/developers/docs/mev/index.md
+++ b/public/content/translations/fr/developers/docs/mev/index.md
@@ -1,34 +1,34 @@
 ---
-title: Valeur Extractible Maximale (Maximal extractable value - MEV)
-description: Une introduction à la Valeur Extractible Maximale (Maximal extractable value - MEV)
+title: Valeur Extractible Maximale (Maximal Extractable Value - MEV)
+description: "Une introduction à la Valeur Extractible Maximale (Maximal extractable value - MEV)"
 lang: fr
 ---
 
 La Valeur Extractible Maximale (MEV) représente la valeur maximale qui peut être extraite de la production d'un bloc au-delà de la récompense standard du bloc et des frais de gaz, en incluant, en excluant ou en modifiant l'ordre des transactions au sein d'un bloc.
 
-## Valeur maximale extractible {#maximal-extractable-value}
+## Valeur extractible maximale {#maximal-extractable-value}
 
-La valeur extractible maximale a été appliquée pour la première fois dans le contexte de [preuve de travail](/developers/docs/consensus-mechanisms/pow/), et initialement appelée « valeur extractible par les mineurs ». Ceci est dû au fait que dans la preuve de travail, les mineurs contrôlent les inclusions, exclusions et l'ordre des transactions. Cependant, depuis le passage à la preuve d'enjeu via [La Fusion](/roadmap/merge), les validateurs sont responsables de ces rôles, et le minage ne fait plus partie du protocole Ethereum. Les méthodes d'extraction de valeurs existent toujours, donc le terme « valeur extractible maximale » est maintenant utilisé à la place.
+La valeur extractible maximale a été appliquée pour la première fois dans le contexte de la [preuve de travail](/developers/docs/consensus-mechanisms/pow/) et était initialement appelée \ Ceci est dû au fait que dans la preuve de travail, les mineurs contrôlent les inclusions, exclusions et l'ordre des transactions. Cependant, depuis la transition vers la preuve d'enjeu via [La Fusion](/roadmap/merge), les validateurs sont responsables de ces rôles et le minage ne fait plus partie du protocole Ethereum. Les méthodes d'extraction de valeurs existent toujours, donc le terme « valeur extractible maximale » est maintenant utilisé à la place.
 
 ## Prérequis {#prerequisites}
 
-Assurez-vous d'être à l'aise avec les concepts de [transactions](/developers/docs/transactions/), [blocs](/developers/docs/blocks/), [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) ainsi que [de gaz](/developers/docs/gas/). Se familiariser avec les [applications décentralisées (dApps)](/apps/) et la [finance décentralisée (DeFi)](/defi/) peut également être utile.
+Assurez-vous que vous êtes familier avec les [transactions](/developers/docs/transactions/), les [blocs](/developers/docs/blocks/), la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) et le [gaz](/developers/docs/gas/). Une familiarité avec les [dapps](/apps/) et la [DeFi](/defi/) est également utile.
 
-## Extraction MEV {#mev-extraction}
+## Extraction de MEV {#mev-extraction}
 
 En théorie, la MEV revient entièrement aux validateurs parce qu'ils sont la seule partie à pouvoir garantir l'exécution d'une MEV rentable. Cependant, en pratique, une grande partie des MEV est extraite par des participants indépendants du réseau qui sont appelés les « chercheurs ». Les chercheurs exécutent des algorithmes complexes sur les données de la blockchain pour détecter les opportunités MEV rentables et soumettent automatiquement au réseau ces transactions rentables via des programmes informatiques automatisés.
 
 Les validateurs obtiennent dans tous les cas une partie du montant total des MEV, puisque les chercheurs sont prêts à payer des frais de gaz élevés (revenant au validateur) en échange d'une plus grande probabilité d'inclure leurs transactions rentables dans un bloc. En supposant que les chercheurs soient économiquement rationnels, les frais de gaz qu'un chercheur est prêt à payer pourront atteindre 100 % du MEV du chercheur (parce que si les frais de carburant étaient plus élevés, le chercheur perdrait de l'argent).
 
-Ainsi, pour certaines opportunités MEV hautement compétitives, telles que [l'arbitrage DEX](#mev-examples-dex-arbitrage), les chercheurs devront parfois payer au validateur des frais de gaz, s'élevant à 90 % (ou même davantage) de leurs MEV totaux, car un grand nombre de personnes souhaitent utiliser le même négoce d'arbitrage. En effet, la seule façon de garantir que leur transaction d'arbitrage soit exécutée est de soumettre la transaction avec le prix de gaz le plus élevé.
+Ainsi, pour certaines opportunités de MEV très compétitives, comme [l'arbitrage DEX](#mev-examples-dex-arbitrage), les chercheurs peuvent être amenés à payer 90 % ou plus de leurs revenus totaux de MEV en frais de gaz au validateur, car de nombreuses personnes veulent exécuter la même transaction d'arbitrage rentable. En effet, la seule façon de garantir que leur transaction d'arbitrage soit exécutée est de soumettre la transaction avec le prix de gaz le plus élevé.
 
-### Le gas-golfing {#mev-extraction-gas-golfing}
+### Gas golfing {#mev-extraction-gas-golfing}
 
-Cette dynamique a fait du « gas-golfing » — le fait de programmer des transactions pour qu'elles utilisent le moins de gaz possible — un avantage concurrentiel, parce qu'il permet aux chercheurs de fixer un prix de gaz plus élevé tout en gardant leurs frais totaux constants (puisque les frais de gaz = prix du gaz * gaz utilisé).
+Cette dynamique a fait du « gas-golfing » — le fait de programmer des transactions pour qu'elles utilisent le moins de gaz possible — un avantage concurrentiel, parce qu'il permet aux chercheurs de fixer un prix de gaz plus élevé tout en gardant leurs frais totaux constants (puisque les frais de gaz = prix du gaz \* gaz utilisé).
 
-Quelques techniques de gas-golfing bien connues consistent à : utiliser des adresses commençant par une longue chaîne de zéros (p. ex. [0x000000C521824EaFf97Eac7B73B084ef9306](https://etherscan.io/address/0x0000000000c521824eaff97eac7b73b084ef9306)) puisqu'elles occupent moins de place (et donc de gaz); ou bien laisser volontairement de petits soldes de jetons [ERC-20](/developers/docs/standards/tokens/erc-20/) dans les contrats, car il est plus cher d'initialiser un emplacement de stockage (ce qui se passe lorsque le solde est 0) que de le mettre à jour. Trouver de nouvelles techniques pour réduire la consommation de gaz est un domaine de recherche actif parmi les chercheurs.
+Quelques techniques de « gas golfing » bien connues consistent à : utiliser des adresses qui commencent par une longue chaîne de zéros (par exemple, [0x0000000000C521824EaFf97Eac7B73B084ef9306](https://eth.blockscout.com/address/0x0000000000C521824EaFf97Eac7B73B084ef9306)) car elles prennent moins de place (et donc de gaz) à stocker ; et laisser de petits soldes de jetons [ERC-20](/developers/docs/standards/tokens/erc-20/) dans les contrats, car il coûte plus de gaz d'initialiser un emplacement de stockage (le cas si le solde est de 0) que de mettre à jour un emplacement de stockage. Trouver de nouvelles techniques pour réduire la consommation de gaz est un domaine de recherche actif parmi les chercheurs.
 
-### Favoris généralisés {#mev-extraction-generalized-frontrunners}
+### Exécuteurs anticipés généralisés {#mev-extraction-generalized-frontrunners}
 
 Plutôt que de programmer des algorithmes complexes pour détecter des opportunités MEV rentables, certains chercheurs exécutent des favoris généralisés. Les favoris généralisés sont des programmes automatiques qui scrutent le mempool pour détecter les transactions rentables. Le favori copiera le code de la transaction potentiellement rentable, remplacera les adresses par l'adresse du favori et exécutera la transaction localement pour vérifier doublement que la transaction modifiée génère un profit pour l'adresse du favori. Si la transaction est effectivement rentable, le favori soumettra la transaction modifiée avec l'adresse remplacée et un prix de carburant plus élevé devenant ainsi le favori de la transaction originale et ainsi obtenir le MEV du chercheur original.
 
@@ -42,49 +42,49 @@ Les MEV apparaissent sur la blockchain de différentes façons.
 
 ### Arbitrage DEX {#mev-examples-dex-arbitrage}
 
-[L'arbitrage sur les plateformes d'échanges décentralisées](/glossary/#dex) (DEX) est la possibilité MEV la plus simple et la plus connue. Par conséquent, c'est aussi le plus compétitif.
+L'arbitrage sur les [échanges décentralisés](/glossary/#dex) (DEX) est l'opportunité de MEV la plus simple et la plus connue. Par conséquent, c'est aussi le plus compétitif.
 
 Cela fonctionne ainsi : si deux DEX proposent un jeton à deux prix différents, quelqu'un peut acheter sur le DEX le jeton au prix le plus bas et le vendre au prix le plus élevé dans une transaction atomique unique. Grâce au mécanisme de la blockchain, c'est véritablement un arbitrage sans risque.
 
-[Voici l'exemple](https://etherscan.io/tx/0x5e1657ef0e9be9bc72efefe59a2528d0d730d478cfc9e6cdd09af9f997bb3ef4) d'une transaction d'arbitrage rentable où un chercheur a transformé 1 000 ETH en 1 045 ETH en profitant de prix différents de la paire ETH/DAI sur Uniswap vs. Sushiswap.
+[Voici un exemple](https://eth.blockscout.com/tx/0x5e1657ef0e9be9bc72efefe59a2528d0d730d478cfc9e6cdd09af9f997bb3ef4) d'une transaction d'arbitrage rentable où un chercheur a transformé 1 000 ETH en 1 045 ETH en profitant des différents prix de la paire ETH/DAI sur Uniswap par rapport à Sushiswap.
 
 ### Liquidations {#mev-examples-liquidations}
 
 Les liquidations dans les protocoles de prêt représentent une autre occasion bien connue de MEV.
 
-Les protocoles de prêt comme Maker et Aave exigent que les utilisateurs déposent des garanties (par exemple ETH). Cette garantie déposée est ensuite utilisée pour prêter à d'autres utilisateurs.
+Les protocoles de prêt comme Maker et Aave exigent des utilisateurs qu'ils déposent une garantie (p. ex., des ETH). Cette garantie déposée est ensuite utilisée pour prêter à d'autres utilisateurs.
 
-Les utilisateurs peuvent alors emprunter des actifs et des jetons à d'autres en fonction de ce dont ils ont besoin (p. ex. vous pourriez emprunter des MKR si vous voulez voter dans une proposition de gouvernance MakerDAO) jusqu'à un certain pourcentage de leur garantie déposée. Par exemple, si le montant d'emprunt est de 30 % maximum, un utilisateur qui dépose 100 DAI dans le protocole peut emprunter jusqu'à 30 DAI d'un autre actif. Le protocole détermine le pourcentage exact de pouvoir d'emprunt.
+Les utilisateurs peuvent alors emprunter des actifs et des jetons à d'autres en fonction de leurs besoins (p. ex., vous pourriez emprunter des MKR si vous vouliez voter dans une proposition de gouvernance de MakerDAO) jusqu'à un certain pourcentage de leur garantie déposée. Par exemple, si le montant d'emprunt est de 30 % maximum, un utilisateur qui dépose 100 DAI dans le protocole peut emprunter jusqu'à 30 DAI d'un autre actif. Le protocole détermine le pourcentage exact de pouvoir d'emprunt.
 
-La valeur des collatéraux d'un emprunteur fluctue, tout comme leur pouvoir d'emprunt. Si, en raison des fluctuations du marché, la valeur des actifs empruntés excède par exemple 30 % de la valeur de leur garantie (encore une fois, le pourcentage exact est déterminé par le protocole), le protocole permet généralement à quiconque de liquider la garantie et de rembourser instantanément les prêteurs (système similaire à la façon dont les [appels de marge](https://www.investopedia.com/terms/m/margincall.asp) fonctionnent dans la finance traditionnelle). En cas de liquidation, l'emprunteur doit généralement payer des frais de liquidation élevés, dont certains vont au liquidateur — c’est là que se trouve la possibilité du MEV.
+La valeur des collatéraux d'un emprunteur fluctue, tout comme leur pouvoir d'emprunt. Si, en raison des fluctuations du marché, la valeur des actifs empruntés dépasse, disons, 30 % de la valeur de leur garantie (encore une fois, le pourcentage exact est déterminé par le protocole), le protocole permet généralement à n'importe qui de liquider la garantie, remboursant instantanément les prêteurs (ceci est similaire au fonctionnement des [appels de marge](https://www.investopedia.com/terms/m/margincall.asp) dans la finance traditionnelle). En cas de liquidation, l'emprunteur doit généralement payer des frais de liquidation élevés, dont certains vont au liquidateur — c’est là que se trouve la possibilité du MEV.
 
 Les chercheurs rivalisent pour analyser les données de la blockchain le plus rapidement possible afin de déterminer quels emprunteurs peuvent être liquidés et être les premiers à soumettre une transaction de liquidation et à collecter les frais de liquidation pour eux-mêmes.
 
-### Échange Sandwich {#mev-examples-sandwich-trading}
+### Sandwich trading {#mev-examples-sandwich-trading}
 
 L'échange Sandwich est une autre méthode courante d'extraction MEV.
 
 Pour créer un sandwich, un chercheur va inspecter le mempool pour trouver des transactions DEX de grand volume. Par exemple, supposons que quelqu'un souhaite acheter 10 000 UNI avec DAI sur Uniswap. Un échange de cette ampleur aura un impact significatif sur la paire UNI/DAI, ce qui pourrait augmenter considérablement le prix de l'UNI par rapport à DAI.
 
-Un chercheur peut calculer l'impact approximatif en termes de prix de cette importante négociation sur la paire UNI/DAI et exécuter un ordre d'achat optimal immédiatement _avant_ le vaste échange en achetant ainsi des UNI à bon prix, puis exécuter un ordre de vente immédiatement _après_ l'échange en le vendant à un prix bien supérieur résultant de l'importance de l'ordre.
+Un chercheur peut calculer l'effet de prix approximatif de cette grande transaction sur la paire UNI/DAI et exécuter un ordre d'achat optimal immédiatement _avant_ la grande transaction, en achetant des UNI à bas prix, puis exécuter un ordre de vente immédiatement _après_ la grande transaction, en les vendant au prix plus élevé causé par l'ordre important.
 
-Cependant, l'échange Sandwich est plus risqué, car il n'est pas atomique (contrairement à l'arbitrage DEX décrit ci-dessus) et est sujet à une [attaque à la salmonelle](https://github.com/Defi-Cartel/salmonella).
+Le sandwiching, cependant, est plus risqué car il n'est pas atomique (contrairement à l'arbitrage DEX, comme décrit ci-dessus) et est sujet à une [attaque salmonella](https://github.com/Defi-Cartel/salmonella).
 
-### MEV dans l'espace NFT {#mev-examples-nfts}
+### MEV sur les NFT {#mev-examples-nfts}
 
 Le MEV dans l'espace NFT est un phénomène émergent et n'est pas nécessairement rentable.
 
 Cependant, étant donné que les transactions NFT se produisent sur la même blockchain partagée que toutes les autres transactions Ethereum, les chercheurs peuvent utiliser sur le marché des NFT des techniques similaires à celles traditionnellement utilisées pour les opportunités MEV.
 
-Par exemple, s'il y a une forte demande d'un NFT populaire et qu'un chercheur veut un certaine NFT ou un ensemble de NFT, il peut programmer une transaction de telle sorte qu'il soit le premier à acheter le NFT ou encore, il pourra acheter l'ensemble des NFT en une seule transaction. Ou si une NFT est [répertoriée par erreur à un prix bas](https://www.theblockcrypto.com/post/113546/mistake-sees-69000-cryptopunk-sold-for-less-than-a-cent), un chercheur peut faire face à d'autres acheteurs et la récupérer à moindre coût.
+Par exemple, s'il y a une forte demande d'un NFT populaire et qu'un chercheur veut un certaine NFT ou un ensemble de NFT, il peut programmer une transaction de telle sorte qu'il soit le premier à acheter le NFT ou encore, il pourra acheter l'ensemble des NFT en une seule transaction. Ou si un NFT est [mis en vente par erreur à un bas prix](https://www.theblockcrypto.com/post/113546/mistake-sees-69000-cryptopunk-sold-for-less-than-a-cent), un chercheur peut devancer les autres acheteurs et l'acquérir à bas prix.
 
-Un exemple significatif de NFT MEV s'est produit lorsqu'un chercheur a dépensé 7 millions de dollars pour [acheter](https://etherscan.io/address/0x650dCdEB6ecF05aE3CAF30A70966E2F395d5E9E5) chaque Cryptopunk au prix plancher. Un chercheur en blockchain [a expliqué sur Twitter](https://twitter.com/IvanBogatyy/status/1422232184493121538) comment l'acheteur a travaillé avec un fournisseur MEV pour garder son secret d'achat.
+Un exemple frappant de MEV sur les NFT s'est produit lorsqu'un chercheur a dépensé 7 millions de dollars pour [acheter](https://eth.blockscout.com/address/0x650dCdEB6ecF05aE3CAF30A70966E2F395d5E9E5?tab=txs) chaque Cryptopunk au prix plancher. Un chercheur en blockchain a [expliqué sur Twitter](https://twitter.com/IvanBogatyy/status/1422232184493121538) comment l'acheteur a travaillé avec un fournisseur de MEV pour garder son achat secret.
 
 ### La longue traîne {#mev-examples-long-tail}
 
 Les opérations d’arbitrage DEX, de liquidations et d'échange Sandwich sont toutes des opportunités MEV bien connues et ne sont pas susceptibles d’être rentables pour les nouveaux chercheurs. Cependant, il existe une longue série d'opportunités MEV moins connues (les NFT MEV sont sans aucun doute l'une de ces opportunités).
 
-Les chercheurs qui sont sur le point de débuter peuvent rencontrer davantage de succès en recherchant les MEV dans cette longue série. Le [MEV job board](https://github.com/flashbots/mev-job-board) de Flashbot liste certaines opportunités émergentes.
+Les chercheurs qui sont sur le point de débuter peuvent rencontrer davantage de succès en recherchant les MEV dans cette longue série. Le [tableau d'offres d'emploi MEV](https://github.com/flashbots/mev-job-board) de Flashbots répertorie certaines opportunités émergentes.
 
 ## Effets de la MEV {#effects-of-mev}
 
@@ -102,9 +102,9 @@ Sans chercheurs rationnels qui cherchent et corrigent les inefficacités économ
 
 Au niveau de la couche réseau, les favoris généralisés et les ventes aux enchères de prix du gaz dans lesquelles ils se livrent souvent (lorsque deux ou plusieurs favoris rivalisent pour que leur transaction soit incluse dans le bloc suivant en augmentant progressivement le prix du gaz de leurs propres transactions) entraînent une congestion du réseau et des prix élevés de gaz pour tous les autres qui essaient de faire des transactions régulières.
 
-Au-delà de ce qui se passe _à l'intérieur des blocs_, le MEV peut avoir des effets nocifs _entre_ les blocs. Si le MEV disponible dans un bloc dépasse significativement la récompense standard du bloc, les validateurs peuvent être encouragés à réextraire des blocs et à capturer le MEV pour eux-mêmes, causant une réorganisation de la blockchain et une instabilité consensuelle.
+Au-delà de ce qui se passe _au sein_ des blocs, la MEV peut avoir des effets délétères _entre_ les blocs. Si le MEV disponible dans un bloc dépasse significativement la récompense standard du bloc, les validateurs peuvent être encouragés à réextraire des blocs et à capturer le MEV pour eux-mêmes, causant une réorganisation de la blockchain et une instabilité consensuelle.
 
-Cette possibilité de réorganisation de la blockchain a été [précédemment rencontrée sur la blockchain Bitcoin](https://dl.acm.org/doi/10.1145/2976749.2978408). Comme la récompense de bloc de Bitcoin est divisée en deux et les frais de transaction représentent une part plus grande de la récompense de bloc, des situations apparaissent où il devient économiquement rationnel pour les mineurs d'abandonner la récompense du prochain bloc et de réextraire les blocs passés avec des frais plus élevés. Avec la croissance du MEV, le même type de situation pourrait se produire avec Ethereum, menaçant l'intégrité de la blockchain.
+Cette possibilité de réorganisation de la blockchain a été [précédemment explorée sur la blockchain Bitcoin](https://dl.acm.org/doi/10.1145/2976749.2978408). Comme la récompense de bloc de Bitcoin est divisée en deux et les frais de transaction représentent une part plus grande de la récompense de bloc, des situations apparaissent où il devient économiquement rationnel pour les mineurs d'abandonner la récompense du prochain bloc et de réextraire les blocs passés avec des frais plus élevés. Avec la croissance du MEV, le même type de situation pourrait se produire avec Ethereum, menaçant l'intégrité de la blockchain.
 
 ## État de la MEV {#state-of-mev}
 
@@ -112,23 +112,23 @@ L’extraction MEV a été organisée au début de 2021, ce qui a entraîné des
 
 Bien que de nombreux chercheurs gagnent encore beaucoup d'argent avec la MEV, au fur et à mesure que les opportunités deviennent plus connues et que de plus en plus de chercheurs se font concurrence pour la même opportunité, les validateurs capteront de plus en plus le revenu total de la MEV (parce que le même type de ventes aux enchères de gaz, tel que décrit à l'origine ci-dessus, se produit également dans les Flashbots, bien que de manière privée, et les validateurs capteront le revenu des gaz qui en résulte). MEV n'est pas non plus l'apanage d'Ethereum et à mesure que les possibilités deviennent plus compétitives sur Ethereum, les chercheurs se déplacent vers des blockchains alternatifs comme Binance Smart Chain, où des possibilités MEV similaires à celles sur Ethereum existent mais avec moins de concurrence.
 
-D'autre part, la transition de la preuve de travail à la preuve d'enjeu et les efforts en cours pour faire évoluer Ethereum à l'aide de rollups modifient le paysage de la MEV d'une manière qui n'est pas encore très claire. On ne sait pas encore bien comment le fait que les promoteurs de blocs garantis soient connus légèrement à l'avance modifie la dynamique de l'extraction de la MEV par rapport au modèle probabiliste dans la preuve de travail ou comment cela sera perturbé lorsque [l'élection d'un leader secret unique](https://ethresear.ch/t/secret-non-single-leader-election/11789) et [la technologie de validateur distribué](/staking/dvt/) seront mis en œuvre. De même, il reste à voir quelles seront les opportunités de MEV lorsque la plupart des activités des utilisateurs seront transférées d'Ethereum vers ses rollups et shards de niveau 2.
+D'autre part, la transition de la preuve de travail à la preuve d'enjeu et les efforts en cours pour faire évoluer Ethereum à l'aide de rollups modifient le paysage de la MEV d'une manière qui n'est pas encore très claire. On ne sait pas encore bien comment le fait d'avoir des proposeurs de blocs garantis connus un peu à l'avance modifie la dynamique de l'extraction de MEV par rapport au modèle probabiliste de la preuve de travail, ni comment cela sera perturbé lorsque l'[élection d'un leader secret unique](https://ethresear.ch/t/secret-non-single-leader-election/11789) et la [technologie de validateur distribué](/staking/dvt/) seront mises en œuvre. De même, il reste à voir quelles seront les opportunités de MEV lorsque la plupart des activités des utilisateurs seront transférées d'Ethereum vers ses rollups et shards de niveau 2.
 
-## MEV dans la preuve d'enjeu (PoS) Ethereum {#mev-in-ethereum-proof-of-stake}
+## MEV dans la preuve d'enjeu (PoS) d'Ethereum {#mev-in-ethereum-proof-of-stake}
 
 Comme expliqué, la MEV a des implications négatives sur l'expérience globale de l'utilisateur et la sécurité de la couche de consensus. Mais la transition d'Ethereum vers un consensus de preuve d'enjeu (surnommé « La Fusion ») introduit potentiellement de nouveaux risques liés à la MEV :
 
 ### Centralisation des validateurs {#validator-centralization}
 
-Dans l'Ethereum post-fusion, les validateurs (ayant effectué des dépôts de sécurité de 32 ETH) parviennent à un consensus sur la validité des blocs ajoutés à la chaîne Beacon. Puisque 32 ETH peuvent être hors de portée pour beaucoup, [joindre un pool de jalonnement](/staking/pools/) peut être une option plus réalisable. Néanmoins, une distribution saine de [solo stakers](/staking/solo/) est idéale, car elle atténue la centralisation des validateurs et améliore la sécurité d'Ethereum.
+Dans l'Ethereum post-fusion, les validateurs (ayant effectué des dépôts de sécurité de 32 ETH) parviennent à un consensus sur la validité des blocs ajoutés à la chaîne Beacon. Puisque 32 ETH peuvent être hors de portée pour beaucoup, [rejoindre un pool de staking](/staking/pools/) peut être une option plus réalisable. Néanmoins, une distribution saine de [stakers solo](/staking/solo/) est idéale, car elle atténue la centralisation des validateurs et améliore la sécurité d'Ethereum.
 
-Cependant, on pense que l'extraction des MEV est capable d'accélérer la centralisation des validateurs. Cela s'explique en partie par le fait que les validateurs [gagnent moins en proposant des blocs](/roadmap/merge/issuance/#how-the-merge-impacts-ETH-supply) que ce que gagnaient les mineurs auparavant, l'extraction de MEV a considérablement [influencé les gains des validateurs](https://github.com/flashbots/eth2-research/blob/main/notebooks/mev-in-eth2/eth2-mev-calc.ipynb) depuis [La Fusion](/roadmap/merge/).
+Cependant, on pense que l'extraction des MEV est capable d'accélérer la centralisation des validateurs. C'est en partie parce que, comme les validateurs [gagnent moins en proposant des blocs](/roadmap/merge/issuance/#how-the-merge-impacts-ETH-supply) que les mineurs auparavant, l'extraction de MEV a grandement [influencé les gains des validateurs](https://github.com/flashbots/eth2-research/blob/main/notebooks/mev-in-eth2/eth2-mev-calc.ipynb) depuis [La Fusion](/roadmap/merge/).
 
-Les pools de jalonnement plus importants auront probablement plus de ressources à investir dans les optimisations nécessaires pour saisir les opportunités de MEV. Plus ces pools extraient de MEV, plus ils disposent de ressources pour améliorer leurs capacités d'extraction de MEV (et augmenter leurs revenus globaux), créant essentiellement [des économies d'échelle](https://www.investopedia.com/terms/e/economiesofscale.asp#).
+Les pools de jalonnement plus importants auront probablement plus de ressources à investir dans les optimisations nécessaires pour saisir les opportunités de MEV. Plus ces pools extraient de MEV, plus ils disposent de ressources pour améliorer leurs capacités d'extraction de MEV (et augmenter leurs revenus globaux), créant ainsi des [économies d'échelle](https://www.investopedia.com/terms/e/economiesofscale.asp#).
 
 Avec moins de ressources à leur disposition, il se peut que les stakers solos ne puissent pas profiter des opportunités des MEV. Cela pourrait accroître la pression sur les validateurs indépendants pour qu'ils rejoignent de puissants pools de jalonnement pour augmenter leurs revenus, réduisant ainsi la décentralisation d'Ethereum.
 
-### Mempools autorisés {#permissioned-mempools}
+### Mempools avec permission {#permissioned-mempools}
 
 En réponse aux attaques de type « sandwiching » et « frontrunning », les traders peuvent commencer à effectuer des transactions hors chaîne avec des validateurs pour assurer la confidentialité des transactions. Au lieu d'envoyer une transaction MEV potentielle au mempool public, le trader l'envoie directement au validateur, qui l'inclut dans un bloc et partage les bénéfices avec le trader.
 
@@ -136,19 +136,19 @@ Les « dark pools » sont une version plus large de cet arrangement et fonctionn
 
 Les mempools à autorisation accéléreraient également les risques de centralisation décrits dans la section précédente. Les grands pools qui exploitent plusieurs validateurs bénéficieront probablement de la confidentialité des transactions pour les commerçants et les utilisateurs, ce qui augmentera leurs revenus MEV.
 
-La lutte contre ces problèmes liés à la MEV dans l'Ethereum post-fusion est un domaine de recherche essentiel. À ce jour, deux solutions proposées pour réduire l'impact négatif du MEV sur la décentralisation et la sécurité d'Ethereum après la Fusion sont [**Séparation Proposant-Constructeur (PBS)**](/roadmap/pbs/) et l'[**API constructeur**](https://github.com/ethereum/builder-specs).
+La lutte contre ces problèmes liés à la MEV dans l'Ethereum post-fusion est un domaine de recherche essentiel. À ce jour, deux solutions proposées pour réduire l'impact négatif de la MEV sur la décentralisation et la sécurité d'Ethereum après La Fusion sont la [**Séparation Proposeur-Constructeur (PBS)**](/roadmap/pbs/) et l'[**API Builder**](https://github.com/ethereum/builder-specs).
 
-### Séparation entre le proposant et le constructeur {#proposer-builder-separation}
+### Séparation Proposeur-Constructeur {#proposer-builder-separation}
 
 Dans le cas de la preuve de travail et de la preuve d'enjeu, un nœud qui construit un bloc le propose aux autres nœuds participant au consensus pour qu'il soit ajouté à la chaîne. Un nouveau bloc devient partie intégrante de la chaîne canonique après qu'un autre mineur l'a construit (dans la preuve de travail) ou qu'il a reçu les attestations de la majorité des validateurs (dans la preuve d'enjeu).
 
-La combinaison des rôles de producteur et de proposant de blocs est à l'origine de la plupart des problèmes liés à la MEV décrits précédemment. Par exemple, les nœuds de consensus sont incités à déclencher des réorganisations de chaînes lors [d'attaques de type « time-bandit »](https://www.mev.wiki/attack-examples/time-bandit-attack) afin de maximiser les gains MEV.
+La combinaison des rôles de producteur et de proposant de blocs est à l'origine de la plupart des problèmes liés à la MEV décrits précédemment. Par exemple, les nœuds de consensus sont incités à déclencher des réorganisations de chaîne dans des [attaques de type « time-bandit »](https://www.mev.wiki/attack-examples/time-bandit-attack) pour maximiser les gains de MEV.
 
-[Proposer-builder separation](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725) (PBS) est conçu pour atténuer l'impact de la MEV, en particulier au niveau de la couche de consensus. La principale caractéristique de PBS est la séparation des règles relatives aux producteurs et aux proposants de blocs. Les validateurs sont toujours chargés de proposer et de voter sur les blocs, mais une nouvelle classe d'entités spécialisées, appelées **block builders**, sont chargées d'ordonner les transactions et de construire les blocs.
+La [séparation proposeur-constructeur](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725) (PBS) est conçue pour atténuer l'impact de la MEV, en particulier au niveau de la couche de consensus. La principale caractéristique de PBS est la séparation des règles relatives aux producteurs et aux proposants de blocs. Les validateurs sont toujours responsables de la proposition et du vote des blocs, mais une nouvelle catégorie d'entités spécialisées, appelées **constructeurs de blocs**, est chargée d'ordonner les transactions et de construire les blocs.
 
 Dans le cadre de la PBS, un constructeur de blocs crée un paquet de transactions et fait une offre pour son inclusion dans un bloc de la chaîne Beacon (en tant que « charge utile d'exécution »). Le validateur sélectionné pour proposer le bloc suivant vérifie alors les différentes offres et choisit le lot ayant le tarif le plus élevé. PBS crée essentiellement un marché aux enchères, où les constructeurs négocient avec les validateurs qui vendent de l'espace de bloc.
 
-Les conceptions actuelles de PBS utilisent un [schéma d'engagement-révélation](https://gitcoin.co/blog/commit-reveal-scheme-on-ethereum/) dans lequel les constructeurs ne publient qu'un engagement cryptographique sur le contenu d'un bloc (en-tête de bloc) avec leurs offres. Après avoir accepté l'offre gagnante, le proposant crée une proposition de bloc signée qui comprend l'en-tête de bloc. Le constructeur de blocs est censé publier le corps complet du bloc après avoir vu la proposition de bloc signée, et il doit également recevoir suffisamment d'[attestations](/glossary/#attestation) des validateurs avant qu'il ne soit finalisé.
+Les conceptions actuelles de PBS utilisent un [schéma d'engagement-révélation](https://gitcoin.co/blog/commit-reveal-scheme-on-ethereum/) dans lequel les constructeurs ne publient qu'un engagement cryptographique sur le contenu d'un bloc (en-tête de bloc) avec leurs offres. Après avoir accepté l'offre gagnante, le proposant crée une proposition de bloc signée qui comprend l'en-tête de bloc. Le constructeur de blocs est censé publier l'intégralité du corps du bloc après avoir vu la proposition de bloc signée, et il doit également recevoir suffisamment d'[attestations](/glossary/#attestation) de la part des validateurs avant sa finalisation.
 
 #### Comment la séparation proposant-constructeur atténue-t-elle l'impact de la MEV ? {#how-does-pbs-curb-mev-impact}
 
@@ -160,11 +160,11 @@ La séparation proposant-constructeur réduit également les risques de centrali
 
 De même, les validateurs n'ont pas à faire confiance aux constructeurs pour qu'ils ne retiennent pas les corps de blocs ou ne publient pas de blocs invalides, car le paiement est inconditionnel. Les frais du validateur sont toujours traités même si le bloc proposé est indisponible ou déclaré invalide par d'autres validateurs. Dans ce dernier cas, le bloc est tout simplement rejeté, ce qui oblige le créateur du bloc à perdre tous les frais de transaction et les revenus de la MEV.
 
-### API de construction {#builder-api}
+### API Builder {#builder-api}
 
-Bien que la séparation des proposants et des constructeurs promette de réduire les effets de l'extraction des MEV, sa mise en œuvre nécessite des modifications du protocole de consensus. Plus précisément, la règle [fork choice](/developers/docs/consensus-mechanisms/pos/#fork-choice) de la chaîne de balises devrait être mise à jour. L'[API pour les builders](https://github.com/ethereum/builder-specs) est une solution temporaire visant à fournir une mise en œuvre fonctionnelle de la séparation proposer-bâtir, bien qu'avec des hypothèses de confiance plus élevées.
+Bien que la séparation des proposants et des constructeurs promette de réduire les effets de l'extraction des MEV, sa mise en œuvre nécessite des modifications du protocole de consensus. Plus précisément, la règle de [choix de la fourche](/developers/docs/consensus-mechanisms/pos/#fork-choice) sur la Beacon Chain devrait être mise à jour. L'[API Builder](https://github.com/ethereum/builder-specs) est une solution temporaire visant à fournir une implémentation fonctionnelle de la séparation proposeur-constructeur, bien qu'avec des hypothèses de confiance plus élevées.
 
-L'API pour les builders est une version modifiée de l'API [Engine API](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md) utilisée par les clients de la couche de consensus pour demander des charges utiles d'exécution aux clients de la couche d'exécution. Comme indiqué dans la [spécification du validateur honnête](https://github.com/ethereum/consensus-specs/blob/master/specs/bellatrix/validator.md), les validateurs sélectionnés pour les tâches de proposition de bloc demandent un paquet de transactions à un client d'exécution connecté, qu'ils incluent dans le bloc de la chaîne Beacon proposé.
+L'API Builder est une version modifiée de l'[API Engine](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md) utilisée par les clients de la couche de consensus pour demander des charges utiles d'exécution aux clients de la couche d'exécution. Comme indiqué dans la [spécification du validateur honnête](https://github.com/ethereum/consensus-specs/blob/master/specs/bellatrix/validator.md), les validateurs sélectionnés pour les tâches de proposition de bloc demandent un paquet de transactions à un client d'exécution connecté, qu'ils incluent dans le bloc proposé sur la Beacon Chain.
 
 L'API pour les builders fait également office d'intergiciel entre les validateurs et les clients de la couche d'exécution, mais elle est différente car elle permet aux validateurs de la chaîne Beacon de s'approvisionner en blocs auprès d'entités externes (au lieu de construire un bloc localement à l'aide d'un client d'exécution).
 
@@ -178,15 +178,16 @@ Vous trouverez ci-dessous un aperçu du fonctionnement de l'API pour les builder
 
 4. Le constructeur qui exécute l'API pour les builders est censé répondre avec la totalité de la charge utile d'exécution lorsqu'il voit la proposition de bloc aveuglé. Cela permet au validateur de créer un bloc Beacon « signé », qu'il propage à travers le réseau.
 
-5. Un validateur utilisant l'API pour les builders est toujours censé construire un bloc localement au cas où le constructeur de blocs ne répondrait pas rapidement, afin de ne pas manquer les récompenses de la proposition de bloc. Cependant, le validateur ne peut pas créer un autre bloc en utilisant les transactions maintenant révélées ou un autre ensemble, car cela reviendrait à _équivocation_ (signer deux blocs dans le même slot), ce qui est une infraction répréhensible.
+5. Un validateur utilisant l'API pour les builders est toujours censé construire un bloc localement au cas où le constructeur de blocs ne répondrait pas rapidement, afin de ne pas manquer les récompenses de la proposition de bloc. Cependant, le validateur ne peut pas créer un autre bloc en utilisant soit les transactions maintenant révélées, soit un autre ensemble, car cela équivaudrait à une _équivoque_ (signer deux blocs dans le même slot), ce qui est une infraction passible de slashing.
 
-Un exemple d'implémentation de l'API pour les builders est [MEV Boost](https://github.com/flashbots/mev-boost), une amélioration du [mécanisme d'enchères Flashbots](https://docs.flashbots.net/flashbots-auction/overview/) conçu pour freiner les externalités négatives de la MEV sur Ethereum. L'enchère Flashbots permet aux validateurs en preuve d'enjeu d'externaliser le travail de construction de blocs rentables à des parties spécialisées appelées des **chercheurs**. ![Un diagramme montrant en détail le flux de MEV](./mev.png)
+Un exemple de mise en œuvre de l'API Builder est [MEV Boost](https://github.com/flashbots/mev-boost), une amélioration du [mécanisme d'enchères Flashbots](https://docs.flashbots.net/Flashbots-auction/overview) conçue pour limiter les externalités négatives de la MEV sur Ethereum. L'enchère Flashbots permet aux validateurs en preuve d'enjeu d'externaliser le travail de construction de blocs rentables à des parties spécialisées appelées **chercheurs**.
+![Un diagramme montrant le flux de MEV en détail](./mev.png)
 
-Les chercheurs recherchent des opportunités de MEV lucratives et envoient des paquets de transactions aux proposants du bloc, accompagnés d'une [offre à prix scellé](https://en.wikipedia.org/wiki/First-price_sealed-bid_auction) pour l'inclusion dans le bloc. Le validateur qui exécute mev-geth, une version forkée du client go-ethereum (Geth), n'a qu'à choisir le paquet le plus rentable et à l'inclure dans le nouveau bloc. Pour protéger les proposants de bloc (validateurs) des spams et des transactions invalides, les paquets de transactions passent par des **relayeurs** pour être validés avant d'arriver au proposant.
+Les chercheurs recherchent des opportunités de MEV lucratives et envoient des paquets de transactions aux proposeurs de blocs, ainsi qu'une [offre à prix scellé](https://en.wikipedia.org/wiki/First-price_sealed-bid_auction) pour leur inclusion dans le bloc. Le validateur qui exécute mev-geth, une version forkée du client go-ethereum (Geth), n'a qu'à choisir le paquet le plus rentable et à l'inclure dans le nouveau bloc. Pour protéger les proposeurs de blocs (validateurs) du spam et des transactions invalides, les paquets de transactions passent par des **relais** pour validation avant d'arriver au proposeur.
 
-MEV Boost conserve le même fonctionnement que la vente aux enchères Flashbots originale, mais avec de nouvelles fonctionnalités conçues pour le passage à la preuve d'enjeu d'Ethereum. Les chercheurs trouvent toujours des transactions MEV rentables à inclure dans les blocs, mais une nouvelle catégorie de parties spécialisées, appelées **constructeurs**, sont responsables de l'agrégation des transactions et des paquets en blocs. Un builder accepte les offres à prix scellés des chercheurs et effectue des optimisations pour trouver la commande la plus rentable.
+MEV Boost conserve le même fonctionnement que la vente aux enchères Flashbots originale, mais avec de nouvelles fonctionnalités conçues pour le passage à la preuve d'enjeu d'Ethereum. Les chercheurs trouvent toujours des transactions de MEV rentables à inclure dans les blocs, mais une nouvelle catégorie de parties spécialisées, appelées **constructeurs**, est responsable de l'agrégation des transactions et des paquets dans les blocs. Un builder accepte les offres à prix scellés des chercheurs et effectue des optimisations pour trouver la commande la plus rentable.
 
-Le relayeur est toujours responsable de la validation des paquets de transactions avant de les transmettre au proposant. Cependant, MEV Boost introduit des **escrows** chargés de fournir [la disponibilité des données](/developers/docs/data-availability/) en stockant les corps de blocs envoyés par les constructeurs et les en-têtes de blocs envoyés par les validateurs. Ici, un validateur connecté à un relais demande les charges utiles d'exécution disponibles et utilise l'algorithme d'ordonnancement de MEV Boost pour sélectionner l'en-tête de charge utile avec l'offre la plus élevée + les conseils MEV.
+Le relayeur est toujours responsable de la validation des paquets de transactions avant de les transmettre au proposant. Cependant, MEV Boost introduit des **escrows** responsables de fournir la [disponibilité des données](/developers/docs/data-availability/) en stockant les corps de bloc envoyés par les constructeurs et les en-têtes de bloc envoyés par les validateurs. Ici, un validateur connecté à un relais demande les charges utiles d'exécution disponibles et utilise l'algorithme d'ordonnancement de MEV Boost pour sélectionner l'en-tête de charge utile avec l'offre la plus élevée + les conseils MEV.
 
 #### Comment l'API pour les builders atténue-t-elle l'impact de la MEV ? {#how-does-builder-api-curb-mev-impact}
 
@@ -200,21 +201,21 @@ Certains projets, tels que MEV Boost, utilisent l'API pour les builders dans le
 
 2. Le logiciel API pour les builders est un logiciel libre, ce qui permet à quiconque de proposer des services de construction de blocs. Cela signifie que les utilisateurs ne sont pas obligés d'utiliser un constructeur de blocs particulier et cela améliore la neutralité et l'absence de permission d'Ethereum. De plus, les commerçants à la recherche de MEV ne contribueront pas par inadvertance à la centralisation en utilisant des canaux de transaction privés.
 
-## Ressources associées {#related-resources}
+## Ressources connexes {#related-resources}
 
-- [Docs Flashbots](https://docs.flashbots.net/)
-- [GitHub Flashbots](https://github.com/flashbots/pm)
-- [mevboost.org](https://www.mevboost.org/) - _Traqueur en temps réel avec statistiques pour les relais MEV-Boost et les constructeurs de blocs_
+- [Documentation de Flashbots](https://docs.flashbots.net/)
+- [GitHub de Flashbots](https://github.com/flashbots/pm)
+- [mevboost.org](https://www.mevboost.org/) – _Suivi avec des statistiques en temps réel pour les relais MEV-Boost et les constructeurs de blocs_
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Qu'est-ce qu'une valeur extractible par minage (MEV) ?](https://blog.chain.link/what-is-miner-extractable-value-mev/)
-- [MEV et moi](https://www.paradigm.xyz/2021/02/mev-and-me)
-- [L'Ethereum est une Forêt Sombre](https://www.paradigm.xyz/2020/08/ethereum-is-a-dark-forest/)
-- [S'échapper de la forêt Sombre](https://samczsun.com/escaping-the-dark-forest/)
-- [Flashbots : Devancer la crise des MEV](https://medium.com/flashbots/frontrunning-the-mev-crisis-40629a613752)
-- [@bertcmiller's MEV Threads](https://twitter.com/bertcmiller/status/1402665992422047747)
-- [MEV-Boost : Fusionner l'architecture Flashbots](https://ethresear.ch/t/mev-boost-merge-ready-flashbots-architecture/11177)
+- [Qu'est-ce que la valeur extractible par les mineurs (MEV) ?](https://blog.chain.link/what-is-miner-extractable-value-mev/)
+- [La MEV et moi](https://www.paradigm.xyz/2021/02/mev-and-me)
+- [Ethereum est une forêt sombre](https://www.paradigm.xyz/2020/08/ethereum-is-a-dark-forest/)
+- [S'échapper de la forêt sombre](https://samczsun.com/escaping-the-dark-forest/)
+- [Flashbots : devancer la crise de la MEV](https://medium.com/flashbots/frontrunning-the-mev-crisis-40629a613752)
+- [Fils de discussion sur la MEV de @bertcmiller](https://twitter.com/bertcmiller/status/1402665992422047747)
+- [MEV-Boost : architecture Flashbots prête pour La Fusion](https://ethresear.ch/t/mev-boost-merge-ready-flashbots-architecture/11177)
 - [Qu'est-ce que MEV Boost](https://www.alchemy.com/overviews/mev-boost)
-- [Pourquoi exécuter mev-boost ?](https://writings.flashbots.net/writings/why-run-mevboost/)
-- [Le Guide des randonneurs sur Ethereum](https://members.delphidigital.io/reports/the-hitchhikers-guide-to-ethereum)
+- [Pourquoi utiliser mev-boost?](https://writings.flashbots.net/writings/why-run-mevboost/)
+- [Le guide du voyageur pour Ethereum](https://members.delphidigital.io/reports/the-hitchhikers-guide-to-ethereum)
diff --git a/public/content/translations/fr/developers/docs/networking-layer/index.md b/public/content/translations/fr/developers/docs/networking-layer/index.md
index cd1bb10a253..cfc845e6e51 100644
--- a/public/content/translations/fr/developers/docs/networking-layer/index.md
+++ b/public/content/translations/fr/developers/docs/networking-layer/index.md
@@ -1,6 +1,6 @@
 ---
-title: Couche de réseautage
-description: Introduction à la couche réseau Ethereum.
+title: "Couche de réseau"
+description: "Introduction à la couche réseau Ethereum."
 lang: fr
 sidebarDepth: 2
 ---
@@ -13,9 +13,9 @@ Les clients d'exécution font circuler des informations sur les transactions dan
 
 ## Prérequis {#prerequisites}
 
-Une certaine connaissance des [nœuds et clients d'Ethereum](/developers/docs/nodes-and-clients/) sera utile pour comprendre cette page.
+Une certaine connaissance des [nœuds et clients](/developers/docs/nodes-and-clients/) d'Ethereum sera utile pour comprendre cette page.
 
-## La couche d'exécution {#execution-layer}
+## La couche d’exécution {#execution-layer}
 
 Les protocoles de réseau de la couche d'exécution sont divisés en deux piles :
 
@@ -25,27 +25,27 @@ Les protocoles de réseau de la couche d'exécution sont divisés en deux piles
 
 Les deux piles fonctionnent en parallèle. La pile de découverte alimente le réseau en nouveaux participants, et la pile DevP2P permet leurs interactions.
 
-### La découverte {#discovery}
+### Découverte {#discovery}
 
-La découverte est le processus permettant de trouver d'autres nœuds sur le réseau. Il est amorcé en utilisant un petit ensemble de nœuds de démarrage (nœuds dont les adresses sont [codées en dur](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go) dans le client afin de pouvoir être trouvés immédiatement et de connecter le client à des pairs). Ces nœuds de démarrage n'existent que pour introduire un nouveau nœud à un ensemble de pairs - c'est leur seul objectif, ils ne participent pas aux tâches normales du client comme la synchronisation de la chaîne, et ils ne sont utilisés que lors du premier lancement d'un client.
+La découverte est le processus permettant de trouver d'autres nœuds sur le réseau. Il est amorcé à l'aide d'un petit ensemble de bootnodes (nœuds dont les adresses sont [codées en dur](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go) dans le client afin qu'ils puissent être trouvés immédiatement et connecter le client à des pairs). Ces nœuds de démarrage n'existent que pour introduire un nouveau nœud à un ensemble de pairs - c'est leur seul objectif, ils ne participent pas aux tâches normales du client comme la synchronisation de la chaîne, et ils ne sont utilisés que lors du premier lancement d'un client.
 
-Le protocole utilisé pour les interactions des nœuds avec les nœuds de démarrage est une forme modifiée de [Kademlia](https://medium.com/coinmonks/a-brief-overview-of-kademlia-and-its-use-in-various-decentralized-platforms-da08a7f72b8f) qui utilise une [table de hachage distribué](https://en.wikipedia.org/wiki/Distributed_hash_table) pour partager des listes de nœuds. Chaque nœud dispose d'une version de cette table contenant les informations nécessaires pour se connecter à ses pairs les plus proches. Cette « proximité » n'est pas géographique - la distance est définie par la similitude de l'ID du nœud. Chaque table de nœud est régulièrement actualisée en tant que fonctionnalité de sécurité. Par exemple, dans [Discv5](https://github.com/ethereum/devp2p/tree/master/discv5), les nœuds de protocole de découverte sont également en mesure d'envoyer des « publicités » qui affichent les sous-protocoles pris en charge par le client, ce qui permet aux pairs de négocier les protocoles qu'ils peuvent tous deux utiliser pour communiquer.
+Le protocole utilisé pour les interactions nœud-bootnode est une forme modifiée de [Kademlia](https://medium.com/coinmonks/a-brief-overview-of-kademlia-and-its-use-in-various-decentralized-platforms-da08a7f72b8f) qui utilise une [table de hachage distribuée](https://en.wikipedia.org/wiki/Distributed_hash_table) pour partager les listes de nœuds. Chaque nœud dispose d'une version de cette table contenant les informations nécessaires pour se connecter à ses pairs les plus proches. Cette « proximité » n'est pas géographique - la distance est définie par la similitude de l'ID du nœud. Chaque table de nœud est régulièrement actualisée en tant que fonctionnalité de sécurité. Par exemple, dans le protocole de découverte [Discv5](https://github.com/ethereum/devp2p/tree/master/discv5), les nœuds sont également capables d'envoyer des « publicités » qui affichent les sous-protocoles que le client prend en charge, permettant aux pairs de négocier les protocoles qu'ils peuvent tous deux utiliser pour communiquer.
 
-Le processus de découverte commence par une partie de PING-PONG. Un PING-PONG réussi va « lier » le nouveau nœud à un nœud de démarrage. Le message initial qui avertit un nœud de démarrage de l'existence d'un nouveau nœud entrant sur le réseau est un `PING`. Ce `PING` inclut des informations hachées sur le nouveau nœud, le nœud de démarrage et une date d'expiration. Le nœud de démarrage reçoit le `PING` et retourne un `PONG` contenant le hachage `PING`. Si les hachages `PING` et `PONG` correspondent, alors la connexion entre le nouveau nœud et le nœud de démarrage est vérifiée et on dit qu'ils sont « liés ».
+Le processus de découverte commence par une partie de PING-PONG. Un PING-PONG réussi va « lier » le nouveau nœud à un nœud de démarrage. Le message initial qui alerte un bootnode de l'existence d'un nouveau nœud entrant sur le réseau est un `PING`. Ce `PING` inclut des informations hachées sur le nouveau nœud, le bootnode et un horodatage d'expiration. Le bootnode reçoit le `PING` et renvoie un `PONG` contenant le hachage du `PING`. Si les hachages `PING` et `PONG` correspondent, la connexion entre le nouveau nœud et le bootnode est vérifiée et ils sont alors considérés comme "liés".
 
-Une fois lié, le nouveau nœud peut envoyer une requête `FIND-NEIGHBOURS` au nœud de démarrage. Les données retournées par le nœud de démarrage incluent une liste de pairs auxquels le nouveau nœud peut se connecter. Si les nœuds ne sont pas liés, la requête `FIND-NEIGHBOURS` échouera, de sorte que le nouveau nœud ne pourra pas entrer sur le réseau.
+Une fois lié, le nouveau nœud peut envoyer une requête `FIND-NEIGHBOURS` au bootnode. Les données retournées par le nœud de démarrage incluent une liste de pairs auxquels le nouveau nœud peut se connecter. Si les nœuds ne sont pas liés, la requête `FIND-NEIGHBOURS` échouera, de sorte que le nouveau nœud ne pourra pas entrer sur le réseau.
 
 Dès que le nouveau nœud reçoit une liste de voisins depuis le nœud de démarrage, il commence un échange PING-PONG avec chacun d'eux. Les PING-PONG réussissent à lier le nouveau nœud avec ses voisins, ce qui permet l’échange de messages.
 
 ```
-démarrage du client --> connexion au nœud de démarrage --> lien avec le nœud de démarrage --> trouver les voisins --> liens avec les voisins
+démarrer le client --> se connecter au bootnode --> se lier au bootnode --> trouver des voisins --> se lier aux voisins
 ```
 
-Les clients d'exécution utilisent actuellement le protocole de découverte [Discv4](https://github.com/ethereum/devp2p/blob/master/discv4.md) et des actions ont été entreprises pour migrer vers le protocole [Discv5](https://github.com/ethereum/devp2p/tree/master/discv5).
+Les clients d'exécution utilisent actuellement le protocole de découverte [Discv4](https://github.com/ethereum/devp2p/blob/master/discv4.md) et un effort actif est en cours pour migrer vers le protocole [Discv5](https://github.com/ethereum/devp2p/tree/master/discv5).
 
-#### ENR : Ethereum Node Records (Registres des Nœuds Ethereum) {#enr}
+#### ENR : Registres de nœud Ethereum {#enr}
 
-Le [registre des nœuds Ethereum (ENR : Ethereum Node Records)](/developers/docs/networking-layer/network-addresses/) est un objet qui contient trois éléments de base : une signature (hachage du contenu des registres selon un schéma d'identité convenu), un numéro de séquence qui suit les modifications apportées au registre, et une liste arbitraire de paires clé/valeur. Il s'agit d'un format à l'épreuve du futur qui permet de simplifier l'échange d'informations d'identification entre les nouveaux pairs. C'est également le format [d'adresse réseau](/developers/docs/networking-layer/network-addresses) préféré pour les nœuds Ethereum.
+Le [registre de nœud Ethereum (ENR)](/developers/docs/networking-layer/network-addresses/) est un objet qui contient trois éléments de base : une signature (hachage du contenu de l'enregistrement créé selon un schéma d'identité convenu), un numéro de séquence qui suit les modifications de l'enregistrement, et une liste arbitraire de paires clé-valeur. Il s'agit d'un format pérenne qui facilite l'échange d'informations d'identification entre les nouveaux pairs et qui constitue le format d'[adresse réseau](/developers/docs/networking-layer/network-addresses) privilégié pour les nœuds Ethereum.
 
 #### Pourquoi le processus de découverte est-il basé sur UDP ? {#why-udp}
 
@@ -53,7 +53,7 @@ UDP ne prend pas en charge le contrôle des erreurs, le renvoi des paquets en é
 
 ### DevP2P {#devp2p}
 
-DevP2P est en lui-même une pile de protocoles qu'Ethereum implémente pour établir et maintenir le réseau de pair à pair. Une fois les nouveaux nœuds entrés sur le réseau, leurs interactions sont régies par des protocoles dans la pile [DevP2P](https://github.com/ethereum/devp2p). Ils reposent tous sur TCP et comprennent le protocole de transport RLPx, le protocole filaire et plusieurs sous-protocoles. [RLPx](https://github.com/ethereum/devp2p/blob/master/rlpx.md) est le protocole régissant l'initiation, l'authentification et la maintenance des sessions entre nœuds. RLPx code les messages à l'aide de RLP (Recursive Length Prefix), une méthode très efficace d'encodage des données dans une structure minimale pour l'envoi entre nœuds.
+DevP2P est en lui-même une pile de protocoles qu'Ethereum implémente pour établir et maintenir le réseau de pair à pair. Une fois que de nouveaux nœuds entrent sur le réseau, leurs interactions sont régies par des protocoles de la pile [DevP2P](https://github.com/ethereum/devp2p). Ils reposent tous sur TCP et comprennent le protocole de transport RLPx, le protocole filaire et plusieurs sous-protocoles. [RLPx](https://github.com/ethereum/devp2p/blob/master/rlpx.md) est le protocole qui régit l'initiation, l'authentification et la maintenance des sessions entre les nœuds. RLPx code les messages à l'aide de RLP (Recursive Length Prefix), une méthode très efficace d'encodage des données dans une structure minimale pour l'envoi entre nœuds.
 
 Une session RLPx entre deux nœuds commence par une poignée de main cryptographique. Cela implique que le nœud envoie un message d'authentification qui est ensuite vérifié par le pair. En cas de vérification réussie, le pair génère un message de reconnaissance d'authentification à renvoyer au nœud initiateur. Il s'agit d'un processus d'échange de clés qui permet aux nœuds de communiquer en privé et en toute sécurité. Une poignée de main cryptographique réussie déclenche ensuite l'envoi par les deux nœuds d'un message « bonjour » « en mode filaire ». Le protocole filaire est initié par un échange réussi de messages de bienvenue.
 
@@ -71,21 +71,21 @@ Outre les messages de bienvenue, le protocole filaire peut également envoyer un
 
 ### Sous-protocoles {#sub-protocols}
 
-#### Le protocole filaire {#wire-protocol}
+#### Protocole filaire {#wire-protocol}
 
-Une fois que les pairs sont connectés et qu'une session RLPx est entamée, le protocole filaire définit la façon dont les pairs communiquent. Initialement, le protocole filaire définissait trois tâches principales : synchronisation de chaînes, propagation de blocs et échange de transactions. Cependant, depuis qu'Ethereum est passé à la preuve d'enjeu, la propagation des blocs et la synchronisation des chaînes sont devenues partie intégrante de la couche de consensus. L'échange de transactions est toujours à la charge des clients d'exécution. L'échange de transactions fait référence à l'échange de transactions en attente entre les nœuds afin que les constructeurs de blocs puissent sélectionner certaines d'entre elles pour les inclure dans le bloc suivant. Des informations plus détaillées sur ces tâches sont disponibles [ici](https://github.com/ethereum/devp2p/blob/master/caps/eth.md). Les clients qui prennent en charge ces sous-protocoles les affichent via [JSON-RPC](/developers/docs/apis/json-rpc/).
+Une fois que les pairs sont connectés et qu'une session RLPx est entamée, le protocole filaire définit la façon dont les pairs communiquent. Initialement, le protocole filaire définissait trois tâches principales : synchronisation de chaînes, propagation de blocs et échange de transactions. Cependant, depuis qu'Ethereum est passé à la preuve d'enjeu, la propagation des blocs et la synchronisation des chaînes sont devenues partie intégrante de la couche de consensus. L'échange de transactions est toujours à la charge des clients d'exécution. L'échange de transactions fait référence à l'échange de transactions en attente entre les nœuds afin que les constructeurs de blocs puissent sélectionner certaines d'entre elles pour les inclure dans le bloc suivant. Des informations détaillées sur ces tâches sont disponibles [ici](https://github.com/ethereum/devp2p/blob/master/caps/eth.md). Les clients qui prennent en charge ces sous-protocoles les exposent via le [JSON-RPC](/developers/docs/apis/json-rpc/).
 
-#### Les (sous-protocole ethereum léger) {#les}
+#### les (sous-protocole léger d'Ethereum) {#les}
 
-Il s'agit d'un protocole minimal destiné à synchroniser les clients légers. Jusqu'à présent, ce protocole a rarement été utilisé, dans la mesure où les nœuds complets sont contraints de servir des données à des clients légers sans être incités à le faire. Le comportement par défaut des clients d'exécution n'est pas de servir des données clientes légères via les. D'autres informations sont disponibles dans les [spécifications](https://github.com/ethereum/devp2p/blob/master/caps/les.md).
+Il s'agit d'un protocole minimal destiné à synchroniser les clients légers. Jusqu'à présent, ce protocole a rarement été utilisé, dans la mesure où les nœuds complets sont contraints de servir des données à des clients légers sans être incités à le faire. Le comportement par défaut des clients d'exécution n'est pas de servir des données clientes légères via les. De plus amples informations sont disponibles dans la [spécification](https://github.com/ethereum/devp2p/blob/master/caps/les.md) du protocole les.
 
-#### Snap (protocole d'accrochage) {#snap}
+#### Snap {#snap}
 
-Le [protocole snap](https://github.com/ethereum/devp2p/blob/master/caps/snap.md#ethereum-snapshot-protocol-snap) est une extension optionnelle qui permet aux pairs d'échanger des instantanés d'états récents, permettant aux pairs de vérifier les données de compte et de stockage sans avoir à télécharger les nœuds intermédiaires d'arbre de Merkle.
+Le [protocole snap](https://github.com/ethereum/devp2p/blob/master/caps/snap.md#ethereum-snapshot-protocol-snap) est une extension facultative qui permet aux pairs d'échanger des instantanés d'états récents, ce qui leur permet de vérifier les données de compte et de stockage sans avoir à télécharger les nœuds intermédiaires de l'arbre de Merkle.
 
-#### Wit (protocole de témoin) {#wit}
+#### Wit (protocole témoin) {#wit}
 
-Le [protocole de témoin](https://github.com/ethereum/devp2p/blob/master/caps/wit.md#ethereum-witness-protocol-wit) est une extension facultative qui permet l'échange de témoins d'état entre pairs, aidant à synchroniser les clients à la pointe de la chaîne.
+Le [protocole témoin](https://github.com/ethereum/devp2p/blob/master/caps/wit.md#ethereum-witness-protocol-wit) est une extension facultative qui permet l'échange de témoins d'état entre pairs, aidant à synchroniser les clients à la pointe de la chaîne.
 
 #### Whisper {#whisper}
 
@@ -95,23 +95,23 @@ Whisper était un protocole visant à fournir une messagerie sécurisée entre p
 
 Les clients de consensus participent à un réseau distinct de pair-à-pair avec une spécification différente. Les clients de consensus doivent participer à des commutateurs de blocs afin de recevoir des pairs de nouveaux blocs de leurs pairs et les diffuser quand c'est à leur tour de proposer un bloc. De la même manière que la couche d'exécution, cette approche nécessite d'abord un protocole de découverte afin qu'un nœud puisse trouver des pairs et établir des sessions sécurisées pour échanger des blocs, des attestations, etc.
 
-### La découverte {#consensus-discovery}
+### Découverte {#consensus-discovery}
 
-Comme pour les clients d'exécution, les clients de consensus utilisent [discv5](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#the-discovery-domain-discv5) sur UDP pour trouver des pairs. L'implémentation de la couche de consensus de discv5 diffère de celle des clients d'exécution uniquement en ce qu'elle inclut un adaptateur connectant discv5 dans une pile [libP2P](https://libp2p.io/), dépréciant DevP2P. Les sessions de la couche d'exécution RLPx sont dépréciées au profit du système de liaison sécurisé libP2P.
+Semblables aux clients d'exécution, les clients de consensus utilisent [discv5](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#the-discovery-domain-discv5) sur UDP pour trouver des pairs. L'implémentation de la couche de consensus de discv5 diffère de celle des clients d'exécution uniquement en ce qu'elle inclut un adaptateur connectant discv5 dans une pile [libP2P](https://libp2p.io/), dépréciant DevP2P. Les sessions de la couche d'exécution RLPx sont dépréciées au profit du système de liaison sécurisé libP2P.
 
-### ENRs {#consensus-enr}
+### ENR {#consensus-enr}
 
-L'ENR pour les nœuds de consensus inclut la clé publique du nœud, l'adresse IP, les ports UDP et TCP et deux champs spécifiques au consensus : l'attestation bitfield du sous-réseau et la clé `eth2`. Le premier permet aux nœuds de trouver plus facilement des nœuds participant à des sous-réseaux de commutation d'attestations spécifiques. La clé `eth2` contient des informations sur la version de la fourche d'Ethereum que le nœud utilise, en s'assurant que les pairs se connectent au bon Ethereum.
+L'ENR pour les nœuds de consensus inclut la clé publique du nœud, l'adresse IP, les ports UDP et TCP et deux champs spécifiques au consensus : le champ de bits du sous-réseau d'attestation et la clé `eth2`. Le premier permet aux nœuds de trouver plus facilement des nœuds participant à des sous-réseaux de commutation d'attestations spécifiques. La clé `eth2` contient des informations sur la version de la fourche Ethereum que le nœud utilise, garantissant que les pairs se connectent au bon réseau Ethereum.
 
 ### libP2P {#libp2p}
 
 La pile libP2P prend en charge toutes les communications après la découverte. Les clients peuvent composer et écouter sur IPv4 et/ou IPv6 tel que défini dans leur ENR. Les protocoles de la couche libP2P peuvent être subdivisés en domaines de commutation et de questions/réponses.
 
-### Commutation {#gossip}
+### Gossip {#gossip}
 
-Le domaine du commutateur inclut toutes les informations qui doivent se propager rapidement sur le réseau. Cela inclut les blocs de la chaîne phare, les preuves, les attestations, les sorties et les coupes. Les informations sont transmises à l'aide de libP2P gossipsub v1 et repose sur diverses métadonnées stockées localement sur chaque nœud, y compris la taille maximale des charges de commutation à recevoir et à transmettre. Des informations plus détaillées sur les domaines de commutation sont disponibles [ici](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#the-gossip-domain-gossipsub).
+Le domaine du commutateur inclut toutes les informations qui doivent se propager rapidement sur le réseau. Cela inclut les blocs de la chaîne phare, les preuves, les attestations, les sorties et les coupes. Les informations sont transmises à l'aide de libP2P gossipsub v1 et repose sur diverses métadonnées stockées localement sur chaque nœud, y compris la taille maximale des charges de commutation à recevoir et à transmettre. Des informations détaillées sur le domaine Gossip sont disponibles [ici](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#the-gossip-domain-gossipsub).
 
-### Question-réponse {#request-response}
+### Requête-réponse {#request-response}
 
 Le domaine question-réponse contient des protocoles pour les clients demandant des informations spécifiques à leurs pairs. Il peut s'agir, par exemple, de demander des blocs spécifiques de la chaîne phare correspondant à certains hachages de la racine ou se situant dans une gamme d'emplacements. Les réponses sont toujours renvoyées sous la forme d'octets encodés SSZ compressés par snappy.
 
@@ -121,23 +121,23 @@ SSZ signifie "sérialisation simple". Elle utilise des décalages fixes qui faci
 
 ## Connexion des clients d'exécution et de consensus {#connecting-clients}
 
-Les clients de consensus et d'exécution fonctionnent en parallèle. Ils doivent être connectés afin que le client de consensus puisse fournir des instructions au client d'exécution et que le client d'exécution puisse passer des paquets de transactions au client de consensus pour les inclure dans les blocs phares. Cette communication entre les deux clients peut être réalisée en utilisant une connexion RPC locale. Une API connue sous le nom de ['Engine-API'](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md) définit les instructions envoyées entre les deux clients. Puisque les deux clients se trouvent derrière une seule identité de réseau, ils partagent un ENR (registre de nœuds Ethereum) qui contient une clé séparée pour chaque client (clé eth1 et clé eth2).
+Les clients de consensus et d'exécution fonctionnent en parallèle. Ils doivent être connectés afin que le client de consensus puisse fournir des instructions au client d'exécution et que le client d'exécution puisse passer des paquets de transactions au client de consensus pour les inclure dans les blocs phares. Cette communication entre les deux clients peut être réalisée en utilisant une connexion RPC locale. Une API connue sous le nom d'['Engine-API'](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md) définit les instructions envoyées entre les deux clients. Puisque les deux clients se trouvent derrière une seule identité de réseau, ils partagent un ENR (registre de nœuds Ethereum) qui contient une clé séparée pour chaque client (clé eth1 et clé eth2).
 
 Un résumé du flux de contrôle est affiché ci-dessous (la pile réseau pertinente apparaît entre parenthèses).
 
-### Lorsque le client du consensus n'est pas un producteur de blocs : {#when-consensus-client-is-not-block-producer}
+### Lorsque le client de consensus n'est pas un producteur de blocs : {#when-consensus-client-is-not-block-producer}
 
 - Le client de consensus reçoit un bloc via le protocole de commutation (consensus p2p)
-- Le client de consensus prévalide le bloc, c'est-à-dire qu'il s'assure qu'il est arrivé d'un expéditeur valide avec des métadonnées correctes
+- Le client de consensus prévalide le bloc, c'est-à-dire qu'il s'assure qu'il provient d'un expéditeur valide avec des métadonnées correctes.
 - Les transactions dans le bloc sont envoyées à la couche d'exécution en tant que charge d'exécution (connexion RPC locale)
-- La couche d'exécution exécute les transactions et valide l'état dans l'en-tête du bloc (c'est-à-dire vérifie la correspondance des haches)
+- La couche d’exécution exécute les transactions et valide l'état dans l'en-tête de bloc (c'est-à-dire qu'elle vérifie que les hachages correspondent).
 - La couche d'exécution transmet les données de validation à la couche de consensus, le bloc est maintenant considéré comme validé (connexion RPC locale)
 - La couche de consensus ajoute un bloc à la tête de sa propre blockchain et l'atteste, diffusant l'attestation sur le réseau (consensus p2p)
 
-### Lorsque le client du consensus est un producteur de blocs : {#when-consensus-client-is-block-producer}
+### Lorsque le client de consensus est un producteur de blocs : {#when-consensus-client-is-block-producer}
 
 - Le client de consensus reçoit une note l'informant qu'il est le prochain producteur de blocs (consensus p2p)
-- La couche de consensus appelle la méthode `create block` dans le client d'exécution (RPC en local)
+- La couche de consensus appelle la méthode `create block` dans le client d'exécution (RPC local).
 - La couche d'exécution accède au mempool de transaction qui a été alimenté par le protocole de commutation de transaction (exécution p2p)
 - Le client d'exécution empaquette les transactions dans un bloc, exécute les transactions et génère un hachage du bloc
 - Le client de consensus récupère les transactions et bloque le hachage du client d'exécution et les ajoute au bloc phare (RPC)
@@ -146,10 +146,10 @@ Un résumé du flux de contrôle est affiché ci-dessous (la pile réseau pertin
 
 Une fois le bloc attesté par suffisamment de validateurs, il est ajouté en tête de la chaîne, justifié et finalisé.
 
-![](cons_client_net_layer.png) ![](exe_client_net_layer.png)
+![](cons_client_net_layer.png)\n![](exe_client_net_layer.png)
 
-Le schéma de couche réseau pour les clients de consensus et d'exécution par [ethresear.ch](https://ethresear.ch/t/eth1-eth2-client-relationship/7248)
+Schéma de la couche réseau pour les clients de consensus et d'exécution, de [ethresear.ch](https://ethresear.ch/t/eth1-eth2-client-relationship/7248)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-[DevP2P](https://github.com/ethereum/devp2p) [LibP2p](https://github.com/libp2p/specs) [spécifications réseau de la couche de consensus](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#enr-structure) [kademlia to discv5](https://vac.dev/kademlia-to-discv5) [kademlia paper](https://pdos.csail.mit.edu/~petar/papers/maymounkov-kademlia-lncs.pdf) [introduction à Ethereum p2p](https://p2p.paris/en/talks/intro-ethereum-networking/) [relation eth1/eth2](http://ethresear.ch/t/eth1-eth2-client-relationship/7248) [vidéo sur les détails de La Fusion avec client eth2](https://www.youtube.com/watch?v=zNIrIninMgg)
+[DevP2P](https://github.com/ethereum/devp2p)\n[LibP2p](https://github.com/libp2p/specs)\n[Spécifications réseau de la couche de consensus](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#enr-structure)\n[De Kademlia à discv5](https://vac.dev/kademlia-to-discv5)\n[Document de recherche Kademlia](https://pdos.csail.mit.edu/~petar/papers/maymounkov-kademlia-lncs.pdf)\n[Introduction au P2P d'Ethereum](https://p2p.paris/en/talks/intro-ethereum-networking/)\n[Relation eth1/eth2](http://ethresear.ch/t/eth1-eth2-client-relationship/7248)\n[Vidéo sur la Fusion et les détails du client eth2](https://www.youtube.com/watch?v=zNIrIninMgg)
diff --git a/public/content/translations/fr/developers/docs/networking-layer/network-addresses/index.md b/public/content/translations/fr/developers/docs/networking-layer/network-addresses/index.md
index bbd1dc954b9..4ba45744c81 100644
--- a/public/content/translations/fr/developers/docs/networking-layer/network-addresses/index.md
+++ b/public/content/translations/fr/developers/docs/networking-layer/network-addresses/index.md
@@ -1,6 +1,6 @@
 ---
-title: Adresses réseau
-description: Une introduction aux adresses réseau.
+title: "Adresses réseau"
+description: "Une introduction aux adresses réseau."
 lang: fr
 sidebarDepth: 2
 ---
@@ -13,7 +13,7 @@ Une certaine compréhension de la [couche réseau](/developers/docs/networking-l
 
 ## Multiaddr {#multiaddr}
 
-Le format originel d'adresse des nœuds Ethereum était le 'multiaddr' (abréviation de 'multi-addresses' en anglais). Multiaddr est un format universel conçu pour les réseaux de pair-à-pair. Les adresses sont représentées par des paires clé-valeur avec des clés et des valeurs séparées par un slash. Par exemple, la multiaddr pour un nœud avec une adresse IPv4 `192.168.22.27` à l'écoute du port TCP `33000` ressemble à :
+Le format originel d'adresse des nœuds Ethereum était le 'multiaddr' (abréviation de 'multi-addresses' en anglais). Multiaddr est un format universel conçu pour les réseaux de pair-à-pair. Les adresses sont représentées par des paires clé-valeur avec des clés et des valeurs séparées par un slash. Par exemple, la multiaddr pour un nœud avec l'adresse IPv4 `192.168.22.27` écoutant sur le port TCP `33000` ressemble à :
 
 `/ip4/192.168.22.27/tcp/33000`
 
@@ -25,15 +25,15 @@ Pour un nœud Ethereum, la multiaddr contient l'identifiant du nœud (un hachage
 
 Un enode est un moyen d'identifier un nœud Ethereum en utilisant un format d'adresse URL. L'identifiant hexadécimal de nœud est encodé dans la partie nom d'utilisateur de l'URL, séparée de l'hôte à l'ide du signe @. Le nom d'hôte ne peut être donné qu'en tant qu'adresse IP, les noms DNS ne sont pas autorisés. Le port dans la section nom d'hôte est le port d'écoute TCP. Si les ports TCP et UDP (découverte) diffèrent, le port UDP est spécifié comme paramètre de requête "discport".
 
-Dans l'exemple suivant, l'URL du nœud décrit un nœud avec une adresse IP `10.3.58.`, port TCP `30303` et port de découverte UDP `30301`.
+Dans l'exemple suivant, l'URL du nœud décrit un nœud avec l'adresse IP `10.3.58.6`, le port TCP `30303` et le port de découverte UDP `30301`.
 
 `enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0@10.3.58.6:30303?discport=30301`
 
-## Registres de nœuds Ethereum (ENRs en anglais) {#enr}
+## Enregistrements de nœuds Ethereum (ENR) {#enr}
 
-Les registres de Nœuds Ethereum (ENRs en anglais) sont un format standardisé pour les adresses réseau sur Ethereum. Ils remplacent les 'multiaddr' et les 'enodes'. Ceux-ci sont particulièrement utiles car ils permettent un échange plus large d'informations entre les nœuds. L'ENR contient une signature, un numéro de séquence et des champs détaillant le schéma d'identité utilisé pour générer et valider les signatures. L'ENR peut également être alimenté de données arbitraires organisées sous la forme de paires valeur-clé. Ces paires valeur-clé contiennent l'adresse IP du nœud ainsi que les informations sur les sous-protocoles que le nœud peut utiliser. Les clients de consensus utilisent une [structure ENR spécifique](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#enr-structure) pour identifier les nœuds d'amorçage et incluent également un champ `eth2` contenant des informations sur la fourche Ethereum actuelle et le sous-réseau de l'attestation de commutation (cela permet de connecter le nœud à un ensemble particulier de pairs dont les attestations sont regroupées).
+Les registres de Nœuds Ethereum (ENRs en anglais) sont un format standardisé pour les adresses réseau sur Ethereum. Ils remplacent les 'multiaddr' et les 'enodes'. Ceux-ci sont particulièrement utiles car ils permettent un échange plus large d'informations entre les nœuds. L'ENR contient une signature, un numéro de séquence et des champs détaillant le schéma d'identité utilisé pour générer et valider les signatures. L'ENR peut également être alimenté de données arbitraires organisées sous la forme de paires valeur-clé. Ces paires valeur-clé contiennent l'adresse IP du nœud ainsi que les informations sur les sous-protocoles que le nœud peut utiliser. Les clients de consensus utilisent une [structure ENR spécifique](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#enr-structure) pour identifier les nœuds de démarrage et incluent également un champ `eth2` contenant des informations sur la fourche Ethereum actuelle et le sous-réseau de potins d'attestation (ceci connecte le nœud à un ensemble particulier de pairs dont les attestations sont agrégées).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [EIP-778 : enregistrements de nœuds Ethereum (ENR)](https://eips.ethereum.org/EIPS/eip-778)
-- [LibP2P : Multiaddr-Enode-ENE ?!](https://consensys.net/diligence/blog/2020/09/libp2p-multiaddr-enode-enr/)
+- [EIP-778 : Enregistrements de nœuds Ethereum (ENR)](https://eips.ethereum.org/EIPS/eip-778)
+- [LibP2P: Multiaddr-Enode-ENR ?!](https://consensys.net/diligence/blog/2020/09/libp2p-multiaddr-enode-enr/)
diff --git a/public/content/translations/fr/developers/docs/networking-layer/portal-network/index.md b/public/content/translations/fr/developers/docs/networking-layer/portal-network/index.md
index afdb2c17ee5..fc28762b303 100644
--- a/public/content/translations/fr/developers/docs/networking-layer/portal-network/index.md
+++ b/public/content/translations/fr/developers/docs/networking-layer/portal-network/index.md
@@ -1,6 +1,6 @@
 ---
 title: Le Portal Network
-description: Un aperçu de Portal Network - un réseau en développement conçu pour soutenir les clients à faibles ressources.
+description: "Un aperçu de Portal Network - un réseau en développement conçu pour soutenir les clients à faibles ressources."
 lang: fr
 ---
 
@@ -10,25 +10,25 @@ Pour contourner ce problème de stockage disque, des nœuds 'légers' ont été
 
 Le réseau Portal est une nouvelle conception de réseau pour Ethereum qui vise à résoudre le problème de disponibilité des données pour les nœuds « légers » sans avoir à faire confiance ou à mettre une pression supplémentaire sur les nœuds complets, en partageant les données nécessaires en petits morceaux à travers le réseau.
 
-En savoir plus sur [les noeuds et les clients](/developers/docs/nodes-and-clients/)
+En savoir plus sur les [nœuds et les clients](/developers/docs/nodes-and-clients/)
 
-## Pourquoi avons-nous besoin de Portal Network ? {#why-do-we-need-portal-network}
+## Pourquoi avons-nous besoin du Portal Network {#why-do-we-need-portal-network}
 
 Les nœuds Ethereum stockent leur propre copie complète ou partielle de la blockchain Ethereum. Cette copie locale est utilisée pour valider les transactions et s'assurer que le nœud suit la chaîne correcte. Ces données stockées localement permettent aux nœuds de vérifier indépendamment que les données entrantes sont valides et correctes sans avoir à faire confiance à une autre entité.
 
-Cette copie locale de la blockchain et des données associées, état et reçus, occupe beaucoup d'espace sur le disque dur du nœud. Par exemple, un disque dur de 2 To est recommandé pour exécuter un nœud en utilisant [Geth](https://geth.ethereum.org) associé à un client de consensus. En utilisant la synchronisation instantanée, qui ne stocke les données de la chaîne que d'un ensemble de blocs relativement récents, Geth occupe généralement environ 650 Go d'espace disque mais augmente d'environ 14 Go/semaine (vous pouvez élaguer le nœud pour le ramener à 650 Go périodiquement).
+Cette copie locale de la blockchain et des données associées, état et reçus, occupe beaucoup d'espace sur le disque dur du nœud. Par exemple, un disque dur de 2 To est recommandé pour exécuter un nœud utilisant [Geth](https://geth.ethereum.org) associé à un client de consensus. En utilisant la synchronisation instantanée, qui ne stocke les données de la chaîne que d'un ensemble de blocs relativement récents, Geth occupe généralement environ 650 Go d'espace disque mais augmente d'environ 14 Go/semaine (vous pouvez élaguer le nœud pour le ramener à 650 Go périodiquement).
 
-Cela signifie que le fonctionnement d'un nœud peut être coûteux, car une grande quantité d'espace disque doit être dédiée à Ethereum. Il existe plusieurs solutions à ce problème sur la feuille de route d'Ethereum, notamment [l'expiration de l'historique](/roadmap/statelessness/#history-expiry), [l'expiration de l'état](/roadmap/statelessness/#state-expiry) et [l'absence d'état](/roadmap/statelessness/). Cependant, ces solutions sont probablement encore à plusieurs années de leur mise en œuvre. Il existe également des [nœuds légers](/developers/docs/nodes-and-clients/light-clients/) qui ne sauvegardent pas leur propre copie des données de la chaîne, ils demandent les données dont ils ont besoin aux nœuds complets. Cependant, cela signifie que les nœuds légers doivent faire confiance aux nœuds complets pour fournir des données honnêtes et cela sollicite également les nœuds complets qui doivent fournir les données dont les nœuds légers ont besoin.
+Cela signifie que le fonctionnement d'un nœud peut être coûteux, car une grande quantité d'espace disque doit être dédiée à Ethereum. Il existe plusieurs solutions à ce problème sur la feuille de route d'Ethereum, notamment [l'expiration de l'historique](/roadmap/statelessness/#history-expiry), [l'expiration de l'état](/roadmap/statelessness/#state-expiry) et le [statelessness](/roadmap/statelessness/). Cependant, ces solutions sont probablement encore à plusieurs années de leur mise en œuvre. Il existe également des [nœuds légers](/developers/docs/nodes-and-clients/light-clients/) qui ne sauvegardent pas leur propre copie des données de la chaîne, ils demandent les données dont ils ont besoin aux nœuds complets. Cependant, cela signifie que les nœuds légers doivent faire confiance aux nœuds complets pour fournir des données honnêtes et cela sollicite également les nœuds complets qui doivent fournir les données dont les nœuds légers ont besoin.
 
 Le Portal Network vise à fournir une alternative pour que les nœuds légers obtiennent leurs données sans avoir à faire confiance ou à étoffer de manière significative le travail qui doit être effectué par les nœuds complets. La manière dont cela sera réalisé est d'introduire une nouvelle façon pour les nœuds Ethereum de partager des données à travers le réseau.
 
 ## Comment fonctionne le Portal Network ? {#how-does-portal-network-work}
 
-Les nœuds Ethereum ont des protocoles stricts qui définissent comment ils communiquent entre eux. Les clients d'exécution communiquent à l'aide d'un ensemble de sous-protocoles connus sous le nom de [DevP2P](/developers/docs/networking-layer/#devp2p), tandis que les clients de consensus utilisent une autre pile de sous-protocoles appelée [libP2P](/developers/docs/networking-layer/#libp2p). Ces définitions déterminent les types de données qui peuvent être échangés entre les nœuds.
+Les nœuds Ethereum ont des protocoles stricts qui définissent comment ils communiquent entre eux. Les clients d'exécution communiquent à l'aide d'un ensemble de sous-protocoles connus sous le nom de [DevP2P](/developers/docs/networking-layer/#devp2p), tandis que les clients de consensus utilisent une pile de sous-protocoles différente appelée [libP2P](/developers/docs/networking-layer/#libp2p). Ces définitions déterminent les types de données qui peuvent être échangés entre les nœuds.
 
 ![devP2P et libP2P](portal-network-devp2p-libp2p.png)
 
-Les nœuds peuvent également fournir des données spécifiques via l'[API JSON-RPC](/developers/docs/apis/json-rpc/), qui est la manière dont les applications et les portefeuilles échangent des informations avec les nœuds Ethereum. Cependant, aucun de ces protocoles n'est idéal pour fournir des données aux clients légers.
+Les nœuds peuvent également servir des données spécifiques via l'[API JSON-RPC](/developers/docs/apis/json-rpc/), qui est la manière dont les applications et les portefeuilles échangent des informations avec les nœuds Ethereum. Cependant, aucun de ces protocoles n'est idéal pour fournir des données aux clients légers.
 
 Les clients légers ne peuvent actuellement pas demander des morceaux spécifiques de données de chaîne via DevP2P ou libre car ces protocoles sont uniquement conçus pour permettre la synchronisation de la chaîne et la propagation des blocs et des transactions. Les clients légers ne souhaitent pas télécharger ces informations car cela les empêcherait d'être « légers ».
 
@@ -36,7 +36,7 @@ L'API JSON-RPC n'est pas non plus un choix idéal pour les demandes de données
 
 Le but du Portal Network est de repenser l'ensemble de la conception, en se construisant spécifiquement pour la légèreté, en dehors des contraintes de conception des clients Ethereum existants.
 
-L'idée principale du Portal Network est de prendre les meilleurs éléments de la pile réseau actuelle en permettant aux clients légers d'obtenir les informations nécessaires, telles que les données historiques et l'identité de la tête actuelle de la chaîne, via un réseau décentralisé peer-to-peer léger de style DevP2P en utilisant une [DHT](https://en.wikipedia.org/wiki/Distributed_hash_table) (similaire à Bittorrent).
+L'idée principale du Portal Network est de reprendre les meilleurs aspects de la pile réseau actuelle en permettant aux informations nécessaires aux clients légers, comme les données historiques et l'identité de la tête de chaîne actuelle, d'être diffusées via un réseau décentralisé pair-à-pair léger de type DevP2P utilisant une [DHT](https://en.wikipedia.org/wiki/Distributed_hash_table) (similaire à Bittorrent).
 
 L'idée est d'ajouter de petites parties des données historiques totales d'Ethereum et certaines responsabilités spécifiques à chaque nœud. Ensuite, les demandes sont traitées en recherchant les nœuds stockant les données spécifiques demandées et en les récupérant directement auprès d'eux.
 
@@ -48,16 +48,16 @@ L'objectif est de permettre à un réseau décentralisé de clients Portal lége
 - synchroniser les données récentes et historiques de la chaîne
 - récupérer les données d'état
 - diffuser les transactions
-- exécuter les transactions en utilisant [l'EVM](/developers/docs/evm/)
+- exécuter des transactions à l'aide de l'[EVM](/developers/docs/evm/)
 
 Les avantages de cette conception de réseau sont :
 
 - réduire la dépendance vis-à-vis des fournisseurs centralisés
 - réduire l'utilisation de la bande passante Internet
 - synchronisation minimale ou nulle
-- Accessible aux appareils à ressources limitées (\<1 GB RAM, \<100 MB d'espace disque, 1 CPU)
+- Accessible aux appareils à ressources limitées (\<1 Go de RAM, \<100 Mo d'espace disque, 1 processeur)
 
-Le diagramme ci-dessous montre les fonctions des clients existants qui peuvent être fournies par le Portal Network, permettant aux utilisateurs d'accéder à ces fonctions sur des appareils à très faibles ressources.
+Le tableau ci-dessous présente les fonctions des clients existants qui peuvent être fournies par le Portal Network, permettant aux utilisateurs d'accéder à ces fonctions sur des appareils à très faibles ressources.
 
 ### Portal Networks
 
@@ -69,21 +69,21 @@ Le diagramme ci-dessous montre les fonctions des clients existants qui peuvent 
 
 ## Diversité des clients par défaut {#client-diversity-as-default}
 
-Les développeurs du Portal Network ont également fait le choix de concevoir trois clients distincts du Portal Network dès le premier jour.
+Les développeurs du Portal Network ont également fait le choix de concevoir quatre clients Portal Network distincts dès le premier jour.
 
 Les clients du Portal Network sont :
 
 - [Trin](https://github.com/ethereum/trin) : écrit en Rust
 - [Fluffy](https://fluffy.guide) : écrit en Nim
 - [Ultralight](https://github.com/ethereumjs/ultralight) : écrit en Typescript
-- [Shisui](https://github.com/optimism-java/shisui) : écrit en Go
+- [Shisui](https://github.com/zen-eth/shisui) : écrit en Go
 
 Avoir plusieurs implémentations de clients indépendants renforce la résilience et la décentralisation du réseau Ethereum.
 
 Si un client rencontre des problèmes ou des vulnérabilités, d'autres clients peuvent continuer à fonctionner normalement, évitant ainsi un unique point de défaillance. De plus, différentes implémentations de clients encouragent l'innovation et la concurrence, stimulant les améliorations et réduisant le risque de monoculture au sein de l'écosystème.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Le Portal Network (Piper Merriam à Devcon Bogota)](https://www.youtube.com/watch?v=0stc9jnQLXA).
+- [Le Portal Network (Piper Merriam à la Devcon de Bogota)](https://www.youtube.com/watch?v=0stc9jnQLXA).
 - [Le discord du Portal Network](https://discord.gg/CFFnmE7Hbs)
-- [Le site web de Portal Network](https://www.ethportal.net/)
+- [Le site web du Portal Network](https://www.ethportal.net/)
diff --git a/public/content/translations/fr/developers/docs/networks/index.md b/public/content/translations/fr/developers/docs/networks/index.md
index 577ea67237b..cb685fec99c 100644
--- a/public/content/translations/fr/developers/docs/networks/index.md
+++ b/public/content/translations/fr/developers/docs/networks/index.md
@@ -1,6 +1,6 @@
 ---
-title: Réseaux
-description: Une vue d'ensemble des réseaux Ethereum et où obtenir de l'ether de réseau de test (ETH) pour tester votre application.
+title: "Les réseaux"
+description: "Une vue d'ensemble des réseaux Ethereum et où obtenir de l'ether de réseau de test (ETH) pour tester votre application."
 lang: fr
 ---
 
@@ -10,9 +10,9 @@ Votre compte Ethereum fonctionnera sur les différents réseaux, mais le solde d
 
 ## Prérequis {#prerequisites}
 
-Vous devez comprendre les [bases d'Ethereum](/developers/docs/intro-to-ethereum/) avant de lire des informations sur les différents réseaux, car les réseaux de test vous donneront une version bon marché et sûre d'Ethereum avec laquelle vous pourrez vous amuser.
+Vous devez comprendre les [bases d'Ethereum](/developers/docs/intro-to-ethereum/) avant de vous informer sur les différents réseaux, car les réseaux de test vous donneront une version bon marché et sûre d'Ethereum avec laquelle vous pourrez vous amuser.
 
-## Réseaux public {#public-networks}
+## Réseaux publics {#public-networks}
 
 Les réseaux publics sont accessibles à toute personne disposant d'une connexion Internet, partout dans le monde. N'importe qui peut lire ou créer des transactions sur une blockchain publique, et valider les transactions exécutées. Le consensus établi entre les pairs décide de l'inclusion des transactions et de l'état du réseau.
 
@@ -20,11 +20,11 @@ Les réseaux publics sont accessibles à toute personne disposant d'une connexio
 
 Le réseau principal Ethereum est la blockchain publique primaire de production, où des transactions de valeur réelle se produisent sur le registre distribué.
 
-Quand on discute des prix de l'ETH dans les échanges, on fait référence à l'ETH du réseau principal.
+Lorsque les gens et les échanges discutent des prix de l'ETH, ils parlent de l'ETH du réseau principal.
 
 ### Réseaux de test Ethereum {#ethereum-testnets}
 
-En plus du réseau principal, il existe des réseaux de test publics. Il s'agit de réseaux utilisés par les développeurs de protocoles ou de contrats intelligents pour tester, dans un environnement de production, à la fois les mises à niveau de protocoles et les contrats intelligents avant leur déploiement sur le réseau principal. Considérez cela comme une analogie entre les serveurs de production et les serveurs d'essai.
+En plus du réseau principal, il existe des réseaux de test publics. Il s'agit de réseaux utilisés par les développeurs de protocoles ou de contrats intelligents pour tester à la fois les mises à niveau de protocoles ainsi que les contrats intelligents potentiels dans un environnement semblable à la production avant le déploiement sur le réseau principal. Considérez cela comme une analogie entre les serveurs de production et les serveurs d'essai.
 
 Vous devriez tester tout code de contrat que vous écrivez sur un réseau de test avant de le déployer sur le réseau principal. Parmi les dApps qui s'intègrent aux contrats intelligents existants, la plupart des projets ont des copies déployées sur des réseaux de test.
 
@@ -34,19 +34,15 @@ L'ETH sur les réseaux de test est censé n'avoir aucune valeur réelle ; cepend
 
 #### Quel réseau de test dois-je utiliser ?
 
-Les deux réseaux de test publics que les développeurs de clients conservent actuellement sont Sepolia et Hoodi. Sepolia est un réseau dédié aux développeurs de contrats et d'applications qui vise à tester leurs applications. Le réseau Hoodi permet aux développeurs de protocoles de tester les mises à jour du réseau, et aux participants de tester les validateurs en cours d'exécution.
+Les deux réseaux de test publics que les développeurs de clients conservent actuellement sont Sepolia et Hoodi. Sepolia est un réseau dédié aux développeurs de contrats et d'applications qui vise à tester leurs applications. Le réseau Hoodi permet aux développeurs de protocoles de tester les mises à niveau du réseau, et aux stakers de tester les validateurs en cours d'exécution.
 
 #### Sepolia {#sepolia}
 
-**Sepolia est le réseau de test recommandé par défaut pour le développement d'applications.**. Le réseau Sepolia utilise un ensemble de validateurs autorisés. Il est assez nouveau, de sorte que son état et son historique sont tous deux assez restreints. Cela signifie que le réseau est rapide à synchroniser et que l'exécution d'un nœud en son sein nécessite moins de stockage. Ceci est utile pour les utilisateurs désireux de faire tourner un nœud rapidement et d'interagir directement avec le réseau.
-
-- Ensemble de validateurs fermés, contrôlé par le client & équipes de test
-- Nouveau réseau de test, moins d'applications déployées que sur d'autres réseaus de tests
-- La synchronisation rapide et le fonctionnement d'un nœud nécessitent un espace disque minimal
+**Sepolia est le réseau de test recommandé par défaut pour le développement d'application**. Le réseau Sepolia utilise un ensemble de validateurs permissionnés, contrôlé par les équipes clientes et de test.
 
 ##### Ressources
 
-- [Site Web](https://sepolia.dev/)
+- [Site web](https://sepolia.dev/)
 - [GitHub](https://github.com/eth-clients/sepolia)
 - [Otterscan](https://sepolia.otterscan.io/)
 - [Etherscan](https://sepolia.etherscan.io)
@@ -54,71 +50,125 @@ Les deux réseaux de test publics que les développeurs de clients conservent ac
 
 ##### Robinets
 
-- [QuickNode Sepolia Faucet](https://faucet.quicknode.com/drip)
+- [Robinet Sepolia d'Alchemy](https://www.alchemy.com/faucets/ethereum-sepolia)
+- [Robinet Sepolia de Chain Platform](https://faucet.chainplatform.co/faucets/ethereum-sepolia/)
+- [Robinet Sepolia de Chainstack](https://faucet.chainstack.com/sepolia-testnet-faucet)
+- [Robinet de l'écosystème Ethereum](https://www.ethereum-ecosystem.com/faucets/ethereum-sepolia)
+- [Robinet Sepolia d'ethfaucet.com](https://ethfaucet.com/networks/ethereum)
+- [Robinet Sepolia Web3 de Google Cloud](https://cloud.google.com/application/web3/faucet/ethereum/sepolia)
 - [Grabteeth](https://grabteeth.xyz/)
+- [Robinet Sepolia d'Infura](https://www.infura.io/faucet)
 - [Robinet PoW](https://sepolia-faucet.pk910.de/)
-- [Coinbase Wallet Faucet | Sepolia](https://coinbase.com/faucets/ethereum-sepolia-faucet)
-- [Alchemy Sepolia faucet](https://sepoliafaucet.com/)
-- [Infura Sepolia faucet](https://www.infura.io/faucet)
-- [Robinet Sepolia Chainstack](https://faucet.chainstack.com/sepolia-testnet-faucet)
-- [Robinet de l'écosystème Ethereum](https://www.ethereum-ecosystem.com/faucets/ethereum-sepolia)
+- [Robinet Sepolia de QuickNode](https://faucet.quicknode.com/ethereum/sepolia)
 
 #### Hoodi {#hoodi}
 
-_Note : [le réseau de test Goerli est obsolète](https://ethereum-magicians.org/t/proposal-predictable-ethereum-testnet-lifecycle/11575/17) et a été remplacé par Hoodi. Veuillez envisager de migrer vos applications vers Sepolia._
-
-Hoodi est un réseau de test qui permet de tester, de valider et de mettre en jeu. Le réseau Hoodi est ouvert aux utilisateurs souhaitant exécuter un validateur de réseau de test. Les utilisateurs désireux de tester les mises à jour de protocoles avant de les déployer sur le réseau principal sont donc invités à utiliser Hoodi.
+Hoodi est un réseau de test qui permet de tester, de valider et de mettre en jeu. Le réseau Hoodi est ouvert aux utilisateurs souhaitant exécuter un validateur de réseau de test. Les utilisateurs désireux de tester les mises à niveau de protocoles avant de les déployer sur le réseau principal sont donc invités à utiliser Hoodi.
 
-- Ensemble de validateurs ouvert, les validateurs peuvent tester les mises à jour du réseau
-- État diversifié, utile pour tester les interactions des contrats intelligents complexes
+- Ensemble de validateurs ouvert, les validateurs peuvent tester les mises à niveau du réseau
+- État diversifié, utile pour tester des interactions de contrats intelligents complexes
 - Plus long à synchroniser et nécessite plus de stockage pour exécuter un nœud
 
 ##### Ressources
 
-- [Site Web](https://hoodi.ethpandaops.io/)
+- [Site web](https://hoodi.ethpandaops.io/)
 - [GitHub](https://github.com/eth-clients/hoodi)
-- [Explorer](https://explorer.hoodi.ethpandaops.io/)
-- [Checkpoint Sync](https://checkpoint-sync.hoodi.ethpandaops.io/)
+- [Explorateur](https://explorer.hoodi.ethpandaops.io/)
+- [Synchronisation par point de contrôle](https://checkpoint-sync.hoodi.ethpandaops.io/)
+- [Otterscan](https://hoodi.otterscan.io/)
+- [Etherscan](https://hoodi.etherscan.io/)
 
 ##### Robinets
 
+- [Robinet Hoodi de Chain Platform](https://faucet.chainplatform.co/faucets/ethereum-hoodi/)
 - [Robinet Hoodi](https://hoodi.ethpandaops.io/)
+- [Robinet PoW](https://hoodi-faucet.pk910.de/)
+
+#### Ephemery {#ephemery}
+
+Ephemery est un type unique de réseau de test qui se réinitialise entièrement chaque mois. L'état d'exécution et de consensus revient à la genèse tous les 28 jours, ce qui signifie que tout ce qui se passe sur le réseau de test est éphémère. Cela le rend idéal pour les tests à court terme, l'amorçage rapide des nœuds et les applications de type « hello world » qui n'ont pas besoin de permanence.
+
+- État toujours frais, tests à court terme des validateurs et des applications
+- Comprend uniquement l'ensemble de contrats de base
+- Un ensemble de validateurs ouvert, avec un accès aisé à des capitaux importants
+- Exigences minimales pour un nœud et synchronisation la plus rapide, &lt;5 Go en moyenne
+
+##### Ressources
+
+- [Site web](https://ephemery.dev/)
+- [Github](https://github.com/ephemery-testnet/ephemery-resources)
+- [Chat communautaire](https://matrix.to/#/#staker-testnet:matrix.org)
+- [Blockscout](https://explorer.ephemery.dev/)
+- [Otterscan](https://otter.bordel.wtf/)
+- [Explorateur de balises](https://beaconlight.ephemery.dev/)
+- [Synchronisation par point de contrôle](https://checkpoint-sync.ephemery.ethpandaops.io)
+- [Plateforme de lancement](https://launchpad.ephemery.dev/)
+
+#### Robinets
+
+- [Robinet Bordel](https://faucet.bordel.wtf/)
+- [Robinet PoW Pk910](https://ephemery-faucet.pk910.de/)
 
-Pour lancer un validateur sur le réseau de test Hoodi, utilisez la [plateforme de lancement Hoodi](https://hoodi.launchpad.ethereum.org/en/).
+#### Holesky (déprécié) {#holesky}
 
-### Réseaux de test de Couche 2 {#layer-2-testnets}
+Le réseau de test Holesky est déprécié à compter de septembre 2025. Les opérateurs de staking et les fournisseurs d'infrastructure devraient utiliser Hoodi pour les tests de validateurs à la place.
 
-[La couche 2 (Layer 2 - L2)](/layer-2/) est un terme collectif pour désigner un ensemble spécifique de solutions aptes à faire évoluer Ethereum. Une couche 2 est une blockchaià part entière qui prolonge Ethereum et hérite des garanties de sécurité d'Ethereum. Les réseaux de test de couche 2 sont généralement étroitement couplés aux réseaux publics de test Ethereum.
+- [Annonce de la fermeture du réseau de test Holesky](https://blog.ethereum.org/2025/09/01/holesky-shutdown-announcement) - _Blog EF, 1er septembre 2025_
+- [Mises à jour des réseaux de test Holesky et Hoodi](https://blog.ethereum.org/en/2025/03/18/hoodi-holesky) - _Blog EF, 18 mars 2025_
+
+### Réseaux de test de couche 2 {#layer-2-testnets}
+
+[La couche 2 (L2)](/layer-2/) est un terme collectif qui décrit un ensemble spécifique de solutions de mise à l'échelle d'Ethereum. Une couche 2 est une blockchaià part entière qui prolonge Ethereum et hérite des garanties de sécurité d'Ethereum. Les réseaux de test de couche 2 sont généralement étroitement couplés aux réseaux publics de test Ethereum.
 
 #### Arbitrum Sepolia {#arbitrum-sepolia}
 
 Un réseau de test pour [Arbitrum](https://arbitrum.io/).
 
+##### Ressources
+
+- [Etherscan](https://sepolia.arbiscan.io/)
+- [Blockscout](https://sepolia-explorer.arbitrum.io/)
+
 ##### Robinets
 
-- [Robinet Chainlink](https://faucets.chain.link/arbitrum-sepolia)
-- [Robinet Alchemy](https://www.alchemy.com/faucets/arbitrum-sepolia)
+- [Robinet Arbitrum Sepolia d'Alchemy](https://www.alchemy.com/faucets/arbitrum-sepolia)
+- [Robinet Arbitrum Sepolia de Chainlink](https://faucets.chain.link/arbitrum-sepolia)
+- [Robinet Arbitrum Sepolia d'ethfaucet.com](https://ethfaucet.com/networks/arbitrum)
+- [Robinet Arbitrum Sepolia de QuickNode](https://faucet.quicknode.com/arbitrum/sepolia)
 
 #### Optimistic Sepolia {#optimistic-sepolia}
 
-Réseau de test pour [Optimism](https://www.optimism.io/).
+Un réseau de test pour [Optimism](https://www.optimism.io/).
+
+##### Ressources
+
+- [Etherscan](https://sepolia-optimistic.etherscan.io/)
+- [Blockscout](https://optimism-sepolia.blockscout.com/)
 
 ##### Robinets
 
-- [Robinet Chainlink](https://faucets.chain.link/optimism-sepolia)
-- [Robinet Alchemy](https://www.alchemy.com/faucets/optimism-sepolia)
+- [Robinet d'Alchemy](https://www.alchemy.com/faucets/optimism-sepolia)
+- [Robinet de Chainlink](https://faucets.chain.link/optimism-sepolia)
+- [Robinet Optimism Sepolia d'ethfaucet.com](https://ethfaucet.com/networks/optimism)
+- [Robinet du réseau de test](https://docs.optimism.io/builders/tools/build/faucets)
 
 #### Starknet Sepolia {#starknet-sepolia}
 
 Un réseau de test pour [Starknet](https://www.starknet.io).
 
+##### Ressources
+
+- [Starkscan](https://sepolia.starkscan.co/)
+
 ##### Robinets
 
-- [Robinet Alchemy](https://www.alchemy.com/faucets/starknet-sepolia)
+- [Robinet d'Alchemy](https://www.alchemy.com/faucets/starknet-sepolia)
+- [Robinet Starknet Sepolia de Blast](https://blastapi.io/faucets/starknet-sepolia-eth)
+- [Robinet Starknet](https://starknet-faucet.vercel.app/)
 
 ## Réseaux privés {#private-networks}
 
-Un réseau Ethereum est un réseau privé si ses nœuds ne sont pas connectés à un réseau public (à savoir réseau principal ou réseau de test). Dans ce contexte, « privé » signifie « réservé » ou « isolé », plutôt que « protégé » ou « sécurisé ».
+Un réseau Ethereum est un réseau privé si ses nœuds ne sont pas connectés à un réseau public (c'est-à-dire, au réseau principal ou à un réseau de test). Dans ce contexte, « privé » signifie « réservé » ou « isolé », plutôt que « protégé » ou « sécurisé ».
 
 ### Réseaux de développement {#development-networks}
 
@@ -132,12 +182,35 @@ Le processus de consensus est contrôlé par un ensemble prédéfini de nœuds d
 
 Si le réseau public Ethereum peut être assimilé à l'Internet public, vous pouvez considérer un réseau de consortium comme un intranet privé.
 
+## <Emoji text="🚉" /> Pourquoi les réseaux de test Ethereum portent-ils le nom de stations de métro ? {#why-naming}
+
+De nombreux réseaux de test d'Ethereum portent le nom de stations de métro ou de gares réelles. Cette tradition de nommage a commencé tôt et reflète les villes du monde où les contributeurs ont vécu ou travaillé. C'est symbolique, mémorable et pratique. Tout comme les réseaux de test sont isolés du réseau principal d'Ethereum, les lignes de métro fonctionnent séparément du trafic en surface.
+
+### <Emoji text="🚧" /> Réseaux de test couramment utilisés et anciens {#common-and-legacy-testnets}
+
+- **Sepolia** - Un quartier d'Athènes, en Grèce, desservi par le métro. Actuellement utilisé pour les tests de contrats intelligents et de dapps.
+- **Hoodi** - Nommé d'après la station de métro Hoodi à Bangalore, en Inde. Utilisé pour les tests des validateurs et des mises à niveau du protocole.
+- **Goerli** _(déprécié)_ - Nommé d'après la gare de Görlitz (Görlitzer Bahnhof) à Berlin, en Allemagne.
+- **Rinkeby** _(déprécié)_ - Nommé d'après une banlieue de Stockholm qui possède une station de métro.
+- **Ropsten** _(déprécié)_ - Fait référence à un quartier et à un ancien terminal de ferry/métro à Stockholm.
+- **Kovan** _(déprécié)_ - Nommé d'après une station de MRT à Singapour.
+- **Morden** _(déprécié)_ - Nommé d'après une station du métro de Londres. Premier réseau de test public d'Ethereum.
+
+### <Emoji text="🧪" /> Autres réseaux de test spécialisés {#other-testnets}
+
+Certains réseaux de test ont été créés pour des tests à court terme ou spécifiques à une mise à niveau et ne sont pas nécessairement sur le thème du métro :
+
+- **Holesky** _(déprécié)_ - Nommé d'après la station Holešovice à Prague. Utilisé pour les tests de validateurs ; déprécié en 2025.
+- **Kiln**, **Zhejiang**, **Shandong**, **Prater**, **Pyrmont**, **Olympic** _(tous dépréciés)_ et **Ephemery** - Conçus spécialement pour les simulations de mises à niveau comme La Fusion, Shanghai ou les expérimentations de validateurs. Certains noms sont régionaux ou thématiques plutôt que basés sur des stations de métro.
+
+L'utilisation de noms de stations de métro aide les développeurs à identifier et à mémoriser rapidement les réseaux de test sans avoir à se fier à des ID de chaîne numériques. Cela reflète également la culture d'Ethereum : pratique, globale et centrée sur l'humain.
+
 ## Outils connexes {#related-tools}
 
-- [Chainlist](https://chainlist.org/) _liste de réseaux EVM pour connecter les portefeuilles et les fournisseurs aux ID de chaîne et de réseau appropriés_
-- [Chaînes basées sur l'EVM](https://github.com/ethereum-lists/chains) _répertoire GitHub des chaînes de métadonnées qui alimentent la Chainlist_
+- [Chainlist](https://chainlist.org/) _liste des réseaux EVM pour connecter les portefeuilles et les fournisseurs aux ID de chaîne et de réseau appropriés_
+- [Chaînes basées sur l'EVM](https://github.com/ethereum-lists/chains) _dépôt GitHub de métadonnées de chaînes qui alimente Chainlist_
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Proposition : Cycle de vie prévisible du réseau de test Ethereum](https://ethereum-magicians.org/t/proposal-predictable-ethereum-testnet-lifecycle/11575/17)
-- [L'évolution des réseaux de test Ethereum](https://etherworld.co/2022/08/19/the-evolution-of-ethereum-testnet/)
+- [Proposition : Cycle de vie prévisible des réseaux de test Ethereum](https://ethereum-magicians.org/t/proposal-predictable-ethereum-testnet-lifecycle/11575/17)
+- [L'évolution des réseaux de test d'Ethereum](https://etherworld.co/2022/08/19/the-evolution-of-ethereum-testnet/)
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/archive-nodes/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/archive-nodes/index.md
index fa7df83693a..ff91588aee1 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/archive-nodes/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/archive-nodes/index.md
@@ -1,6 +1,6 @@
 ---
-title: Nœud d'archive Ethereum
-description: Un aperçu des nœuds d'archive
+title: "Nœud d'archive Ethereum"
+description: "Un aperçu des nœuds d'archive"
 lang: fr
 sidebarDepth: 2
 ---
@@ -9,21 +9,21 @@ Un nœud d'archive est une instance d'un client Ethereum configurée pour créer
 
 ## Prérequis {#prerequisites}
 
-Vous devriez comprendre le concept d'un [nœud Ethereum](/developers/docs/nodes-and-clients/), [son architecture](/developers/docs/nodes-and-clients/node-architecture/), les [stratégies de synchronisation](/developers/docs/nodes-and-clients/#sync-modes), les pratiques de [mise en fonctionnement](/developers/docs/nodes-and-clients/run-a-node/) et [leur utilisation](/developers/docs/apis/json-rpc/).
+Vous devez comprendre le concept d'un [nœud Ethereum](/developers/docs/nodes-and-clients/), [son architecture](/developers/docs/nodes-and-clients/node-architecture/), les [stratégies de synchronisation](/developers/docs/nodes-and-clients/#sync-modes), les pratiques pour les [exécuter](/developers/docs/nodes-and-clients/run-a-node/) et les [utiliser](/developers/docs/apis/json-rpc/).
 
 ## Qu'est-ce qu'un nœud d'archive
 
-Pour saisir l'importance d'un nœud d'archive, clarifions le concept d'« état. » Ethereum peut être désigné comme une _machine à état basée sur les transactions_. Il est composé de comptes et d'applications exécutant des transactions qui modifient leur état. Les données globales contenant des informations sur chaque compte et contrat sont stockées dans une base de données triée appelée état. Cela est géré par le client de la couche d'exécution (EL) et comprend :
+Pour saisir l'importance d'un nœud d'archive, clarifions le concept d'« état. » Ethereum peut être qualifié de _machine à état basée sur les transactions_. Il est composé de comptes et d'applications exécutant des transactions qui modifient leur état. Les données globales contenant des informations sur chaque compte et contrat sont stockées dans une base de données triée appelée état. Cela est géré par le client de la couche d'exécution (EL) et comprend :
 
 - Soldes et nonces des comptes
 - Code des contrats et stockage
-- Données liées au consensus, par exemple, le contrat de dépôt de mise en jeu
+- Données liées au consensus, par ex., Contrat de dépôt de mise en jeu
 
-Pour interagir avec le réseau, vérifier et produire de nouveaux blocs, les clients Ethereum doivent suivre les changements les plus récents (le sommet de la chaîne) et donc l'état actuel. Un client de couche d'exécution configuré en tant que nœud complet vérifie et suit le dernier état du réseau, mais ne met en cache que les derniers états, par ex. l'état associé aux 128 derniers blocs, afin qu'il puisse gérer les réorganisations en chaîne et fournir un accès rapide aux données récentes. L'état récent est ce dont tous les clients ont besoin pour vérifier les transactions entrantes et utiliser le réseau.
+Pour interagir avec le réseau, vérifier et produire de nouveaux blocs, les clients Ethereum doivent suivre les changements les plus récents (le sommet de la chaîne) et donc l'état actuel. Un client de la couche d’exécution, configuré en tant que nœud complet, vérifie et suit l’état le plus récent du réseau, mais ne met en cache que les quelques états précédents (par ex. l’état associé aux 128 derniers blocs), afin de pouvoir gérer les réorganisations de la chaîne et fournir un accès rapide aux données récentes. L'état récent est ce dont tous les clients ont besoin pour vérifier les transactions entrantes et utiliser le réseau.
 
 Vous pouvez imaginer l'état comme un instantané de réseau momentané à un bloc donné et l'archive comme une relecture de l'historique.
 
-Les états historiques peuvent être élagués en toute sécurité car ils ne sont pas nécessaires au fonctionnement du réseau et il serait inutilement redondant pour le client de conserver toutes les données obsolètes. Les états qui existaient avant un certain bloc récent (par exemple, 128 blocs avant la tête) sont effectivement éliminés. Les nœuds complets ne conservent que les données historiques de la blockchain (blocs et transactions) et des instantanés historiques occasionnels qu'ils peuvent utiliser pour régénérer des états plus anciens sur demande. Pour ce faire, ils réexécutent les transactions passées dans l'EVM, ce qui peut être exigeant en termes de calcul lorsque l'état souhaité est éloigné de l'instantané le plus proche.
+Les états historiques peuvent être élagués en toute sécurité car ils ne sont pas nécessaires au fonctionnement du réseau et il serait inutilement redondant pour le client de conserver toutes les données obsolètes. Les états qui existaient avant un certain bloc récent (par ex., 128 blocs avant la tête) sont effectivement supprimés. Les nœuds complets ne conservent que les données historiques de la blockchain (blocs et transactions) et des instantanés historiques occasionnels qu'ils peuvent utiliser pour régénérer des états plus anciens sur demande. Pour ce faire, ils réexécutent les transactions passées dans l'EVM, ce qui peut être exigeant en termes de calcul lorsque l'état souhaité est éloigné de l'instantané le plus proche.
 
 Cependant, cela signifie que l'accès à un état historique sur un nœud complet nécessite une grande quantité de calcul. Le client peut avoir besoin d'exécuter toutes les transactions passées et de calculer un état historique à partir de la genèse. Les nœuds d'archive résolvent ce problème en stockant non seulement les états les plus récents, mais également tous les états historiques créés après chaque bloc. Cela implique essentiellement un compromis avec l'exigence d'un espace disque plus grand.
 
@@ -35,8 +35,8 @@ L'utilisation régulière d'Ethereum, comme l'envoi de transactions, le déploie
 
 Le principal avantage des archives d'état est un accès rapide aux requêtes sur les états historiques. Par exemple, le nœud d'archive renverrait rapidement des résultats tels que :
 
-- _Quel était le solde ETH du compte 0x1337... au bloc 15537393 ?_
-- _Quel est le solde du jeton 0x dans le contrat 0x au bloc 1920000 ?_
+- _Quel était le solde en ETH du compte 0x1337... au bloc 15537393 ?_
+- _Quel est le solde du jeton 0x dans le contrat 0x au bloc 1920000 ?_
 
 Comme expliqué ci-dessus, un nœud complet aurait besoin de générer ces données par l'exécution de l'EVM, utilisant le CPU et prenant du temps. Les nœuds d'archive y accèdent sur le disque et fournissent les réponses immédiatement. Cette fonctionnalité est utile pour certaines parties de l'infrastructure, par exemple :
 
@@ -46,13 +46,13 @@ Comme expliqué ci-dessus, un nœud complet aurait besoin de générer ces donn
 - Développeurs de DApp
 - Audit et conformité
 
-Il existe divers [services](/developers/docs/nodes-and-clients/nodes-as-a-service/) gratuits qui permettent également d'accéder aux données historiques. Comme il est plus exigeant d'exécuter un nœud d'archive, cet accès est généralement limité et ne fonctionne que pour des accès occasionnels. Si votre projet nécessite un accès constant aux données historiques, vous devriez envisager d'en exécuter un vous-même.
+Il existe également divers [services](/developers/docs/nodes-and-clients/nodes-as-a-service/) gratuits qui permettent d'accéder aux données historiques. Comme il est plus exigeant d'exécuter un nœud d'archive, cet accès est généralement limité et ne fonctionne que pour des accès occasionnels. Si votre projet nécessite un accès constant aux données historiques, vous devriez envisager d'en exécuter un vous-même.
 
 ## Implémentations et utilisation
 
 Dans ce contexte, le terme « nœud d'archive » fait référence aux données fournies par les clients de la couche d'exécution orientés utilisateur, car ils gèrent la base de données d'état et fournissent des points de terminaison JSON-RPC. Les options de configuration, le temps de synchronisation et la taille de la base de données peuvent varier selon le client. Pour plus de détails, veuillez vous référer à la documentation fournie par votre client.
 
-Avant de démarrer votre propre nœud d'archive, renseignez-vous sur les différences entre les clients et surtout sur les différentes [exigences matérielles](/developers/docs/nodes-and-clients/run-a-node/#requirements). La plupart des clients ne sont pas optimisés pour cette fonctionnalité et leurs archives nécessitent plus de 12 To d'espace. En revanche, des implémentations telles qu'Erigon peuvent stocker les mêmes données en moins de 3 To, ce qui en fait la méthode la plus efficace pour exécuter un nœud d'archive.
+Avant de démarrer votre propre nœud d'archive, renseignez-vous sur les différences entre les clients et surtout sur les diverses [exigences matérielles](/developers/docs/nodes-and-clients/run-a-node/#requirements). La plupart des clients ne sont pas optimisés pour cette fonctionnalité et leurs archives nécessitent plus de 12 To d'espace. En revanche, des implémentations telles qu'Erigon peuvent stocker les mêmes données en moins de 3 To, ce qui en fait la méthode la plus efficace pour exécuter un nœud d'archive.
 
 ## Pratiques recommandées
 
@@ -60,21 +60,22 @@ Outre les [recommandations générales pour l'exécution d'un nœud](/developers
 
 ### Matériel
 
-Assurez-vous toujours de vérifier les exigences matérielles pour un mode spécifique dans la documentation du client. L'espace disque est la principale exigence pour les nœuds d'archive. Selon le client, cela varie de 3 To à 12 To. Même si le disque dur peut être considéré comme une meilleure solution pour de grandes quantités de données, sa synchronisation et la mise à jour constante de la tête de chaîne nécessiteront des disques SSD. Les disques [SATA](https://www.cleverfiles.com/help/sata-hard-drive.html) sont assez bons mais ils doivent être d'une qualité fiable, au moins [TLC](https://blog.synology.com/tlc-vs-qlc-ssds-what-are-the-differences). Les disques peuvent être installés dans un ordinateur de bureau ou un serveur avec suffisamment d'emplacements. Ces appareils dédiés sont idéaux pour exécuter un nœud à haute disponibilité. Il est tout à fait possible de l'exécuter sur un ordinateur portable, mais la portabilité entraînera un coût supplémentaire.
+Assurez-vous toujours de vérifier les exigences matérielles pour un mode spécifique dans la documentation du client.
+L'espace disque est la principale exigence pour les nœuds d'archive. Selon le client, cela varie de 3 To à 12 To. Même si le disque dur peut être considéré comme une meilleure solution pour de grandes quantités de données, sa synchronisation et la mise à jour constante de la tête de chaîne nécessiteront des disques SSD. Les disques [SATA](https://www.cleverfiles.com/help/sata-hard-drive.html) sont suffisants, mais ils doivent être d'une qualité fiable, au moins [TLC](https://blog.synology.com/tlc-vs-qlc-ssds-what-are-the-differences). Les disques peuvent être installés dans un ordinateur de bureau ou un serveur avec suffisamment d'emplacements. Ces appareils dédiés sont idéaux pour exécuter un nœud à haute disponibilité. Il est tout à fait possible de l'exécuter sur un ordinateur portable, mais la portabilité entraînera un coût supplémentaire.
 
-Toutes les données doivent tenir dans un seul volume, donc les disques doivent être joints, par ex. avec [RAID0](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_0) ou LVM. Il pourrait également être utile d'envisager d'utiliser [ZFS](https://en.wikipedia.org/wiki/ZFS) car il prend en charge « Copy-on-write » qui garantit que les données sont correctement écrites sur le disque sans aucune erreur de bas niveau.
+Toutes les données doivent tenir dans un seul volume, les disques doivent donc être joints, par ex., avec [RAID0](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_0) ou LVM. Il pourrait également être utile d'envisager d'utiliser [ZFS](https://en.wikipedia.org/wiki/ZFS), car il prend en charge le "Copy-on-write", qui garantit que les données sont correctement écrites sur le disque sans aucune erreur de bas niveau.
 
-Pour plus de stabilité et de sécurité dans la prévention de la corruption accidentelle de la base de données, en particulier dans une configuration professionnelle, envisagez d'utiliser la [mémoire ECC](https://en.wikipedia.org/wiki/ECC_memory) si votre système le prend en charge. Il est généralement conseillé d'avoir la même quantité de RAM que pour un nœud complet, mais davantage de RAM peut accélérer la synchronisation.
+Pour plus de stabilité et de sécurité dans la prévention de la corruption accidentelle de la base de données, en particulier dans une configuration professionnelle, envisagez d'utiliser de la [mémoire ECC](https://en.wikipedia.org/wiki/ECC_memory) si votre système la prend en charge. Il est généralement conseillé d'avoir la même quantité de RAM que pour un nœud complet, mais davantage de RAM peut accélérer la synchronisation.
 
 Lors de la synchronisation initiale, les clients en mode archive exécuteront chaque transaction depuis la genèse. La vitesse d'exécution est principalement limitée par le CPU, donc un CPU plus rapide peut apporter une aide avec le temps de synchronisation initial. Sur un ordinateur grand public moyen, la synchronisation initiale peut prendre jusqu'à un mois.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Nœud complet Ethereum vs Nœud d'archive Ethereum](https://www.quicknode.com/guides/infrastructure/ethereum-full-node-vs-archive-node) - _QuickNode, septembre 2022_
-- [Construire votre propre nœud d'archive Ethereum.](https://tjayrush.medium.com/building-your-own-ethereum-archive-node-72c014affc09) - _par Thomas Jay Rush, août 2021_
-- [Comment configurer Erigon, le RPC d'Erigon et TrueBlocks (scraping et API) en tant que services](https://magnushansson.xyz/blog_posts/crypto_defi/2022-01-10-Erigon-Trueblocks) _– Magnus Hansson, mis à jour en septembre 2022_
+- [Nœud complet Ethereum vs Nœud d'archive](https://www.quicknode.com/guides/infrastructure/ethereum-full-node-vs-archive-node) - _QuickNode, septembre 2022_
+- [Construire votre propre nœud d'archive Ethereum](https://tjayrush.medium.com/building-your-own-ethereum-archive-node-72c014affc09) - _Thomas Jay Rush, août 2021_
+- [Comment configurer Erigon, le RPC d'Erigon et TrueBlocks (scrape et API) en tant que services](https://magnushansson.xyz/blog_posts/crypto_defi/2022-01-10-Erigon-Trueblocks) _– Magnus Hansson, mis à jour en septembre 2022_
 
 ## Sujets connexes {#related-topics}
 
-- [ Nœuds et clients](/developers/docs/nodes-and-clients/)
+- [Nœuds et clients](/developers/docs/nodes-and-clients/)
 - [Exécuter un nœud](/developers/docs/nodes-and-clients/run-a-node/)
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/bootnodes/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/bootnodes/index.md
index 2d5014deccf..658e5aa4c7e 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/bootnodes/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/bootnodes/index.md
@@ -1,31 +1,32 @@
 ---
-title: Introduction aux nœuds de démarrage d'Ethereum
-description: Informations de base dont vous avez besoin pour comprendre les nœuds de démarrage
+title: "Introduction aux nœuds de démarrage d'Ethereum"
+description: "Informations de base dont vous avez besoin pour comprendre les nœuds de démarrage"
 lang: fr
 ---
 
 Lorsqu'un nouveau nœud rejoint le réseau Ethereum, il doit se connecter aux nœuds déjà présents sur ledit réseau dans le but de découvrir de nouveaux pairs. Ces points d'entrée dans le réseau Ethereum sont appelés bootnodes ou nœuds de démarrage. Les clients disposent généralement d'une liste de nœuds de démarrage codée en dur. Ces « bootnodes » sont généralement gérés par l'équipe de développement de l'Ethereum Foundation ou via les équipes clients elles-mêmes. À noter que ces nœuds de démarrage sont bien distincts des nœuds statiques. Les nœuds statiques sont appelés maintes et maintes fois, tandis que les nœuds de démarrage ne sont sollicités que dans le cas où il n'y a pas assez de pairs auxquels se connecter, et qu'un nœud se trouve dans le besoin d'amorcer de nouvelles connexions.
 
-## Se connecter à un nœud de démarrage {#connect-to-a-bootnode}
+## Se connecter à un bootnode {#connect-to-a-bootnode}
 
-La plupart des clients ont une liste de nœuds de démarrage intégrée, mais il se peut que vous souhaitiez exécuter votre propre nœud de démarrage, ou encore, prendre un nœud qui ne soit pas issu de la liste codée en dur du client. Dans ce cas, vous pouvez les mentionner comme suit au démarrage de votre client (exemple pour Geth, veuillez vérifier la documentation de votre client) :
+La plupart des clients ont une liste de bootnodes intégrée, mais vous pouvez également vouloir exécuter votre propre bootnode, ou en utiliser un qui ne fait pas partie de la liste codée en dur du client. Dans ce cas, vous pouvez les mentionner comme suit au démarrage de votre client (exemple pour Geth, veuillez vérifier la documentation de votre client) :
 
 ```
 geth --bootnodes "enode://<node ID>@<IP address>:<port>"
 ```
 
-## Exécuter un nœud de démarrage {#run-a-bootnode}
+## Exécuter un bootnode {#run-a-bootnode}
 
-Les nœuds de démarrage sont des nœuds complets qui ne se trouvent pas derrière une NAT ([Traduction des adresses réseau](https://www.geeksforgeeks.org/network-address-translation-nat/)). Tout nœud complet peut servir de nœud de démarrage tant qu'il reste accessible au public.
+Les bootnodes sont des nœuds complets qui ne se trouvent pas derrière un NAT ([Traduction d'adresse réseau](https://www.geeksforgeeks.org/network-address-translation-nat/)). Tout nœud complet peut servir de nœud de démarrage tant qu'il reste accessible au public.
 
-Lorsque vous démarrez un nœud, celui-ci doit enregistrer votre [*enode](/developers/docs/networking-layer/network-addresses/#enode), qui est un identifiant public que d'autres peuvent utiliser pour se connecter à votre nœud. *Un enode est un moyen de décrire un nœud Ethereum sous la forme d'un **URI. **Un identifiant de ressource uniforme ou Uniform Resource Identifier (URI) est une séquence unique de caractères qui identifie une ressource logique ou physique, utilisée par les technologies web.
+Lorsque vous démarrez un nœud, il doit enregistrer votre [enode](/developers/docs/networking-layer/network-addresses/#enode), qui est un identifiant public que d'autres peuvent utiliser pour se connecter à votre nœud.
 
 L'enode est généralement régénéré lors de chaque redémarrage, alors assurez-vous de consulter la documentation de votre client pour savoir comment produire un enode persistant pour votre nœud de démarrage.
 
 Afin d'être un nœud de démarrage performant, il est de bon augure d'augmenter le nombre maximum d'homologues qui peuvent se connecter à ce nœud. L'exécution d'un nœud de démarrage accompagné par de nombreux pairs, augmentera considérablement les besoins en bande passante.
 
-## Nœuds de démarrage disponibles {#available-bootnodes}
+## Bootnodes disponibles {#available-bootnodes}
 
-Une liste des nœuds de démarrage intégrés à go-ethereum peut être consultée [ici.](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23) Ces nœuds de démarrage sont gérés par l'Ethereum Foundation et l'équipe go-ethereum.
+Une liste de bootnodes intégrés dans go-ethereum peut être trouvée [ici](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23). Ces nœuds de démarrage sont gérés par l'Ethereum Foundation et l'équipe go-ethereum.
 
-Il existe aussi d'autres listes de nœuds de démarrage maintenues par des bénévoles. Veillez à toujours inclure au moins un nœud de démarrage officiel, sinon vous risquez d'être attaqué par *Eclipse. *Une attaque par éclipse est une attaque par laquelle un acteur malveillant isole un nœud au sein d'un réseau peer-to-peer (P2P) afin d'obscurcir la vue d'un utilisateur sur le réseau et de perturber le réseau en général. Similaires aux attaques Sybil, excepté que dans ce cas, seul un nœud est visé contrairement à une attaque Sybil qui vise l'ensemble du réseau.
+Il existe aussi d'autres listes de nœuds de démarrage maintenues par des bénévoles. Veillez à toujours inclure au moins un nœud de démarrage officiel, sinon vous risquez d'être attaqué par \*Eclipse.
+\*Une attaque par éclipse est une attaque par laquelle un acteur malveillant isole un nœud au sein d'un réseau peer-to-peer (P2P) afin d'obscurcir la vue d'un utilisateur sur le réseau et de perturber le réseau en général. Similaires aux attaques Sybil, excepté que dans ce cas, seul un nœud est visé contrairement à une attaque Sybil qui vise l'ensemble du réseau.
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/client-diversity/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/client-diversity/index.md
index 2aecc50369b..3639e7dcfb9 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/client-diversity/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/client-diversity/index.md
@@ -1,6 +1,6 @@
 ---
-title: Diversité des clients
-description: Une explication de haut niveau sur l'importance de la diversité des clients Ethereum.
+title: "Diversité des clients"
+description: "Une explication de haut niveau sur l'importance de la diversité des clients Ethereum."
 lang: fr
 sidebarDepth: 2
 ---
@@ -9,11 +9,11 @@ Le comportement d'un nœud Ethereum est contrôlé par le logiciel client qu'il
 
 ## Prérequis {#prerequisites}
 
-Si vous ne maîtrisez pas déjà ce que sont les nœuds et les clients, consultez la page [nœuds et clients](/developers/docs/nodes-and-clients/). [Exécution](/glossary/#execution-layer) et [couches de consensus](/glossary/#consensus-layer) sont définies dans le glossaire.
+Si vous ne comprenez pas encore ce que sont les nœuds et les clients, consultez [nœuds et clients](/developers/docs/nodes-and-clients/). Les couches « [exécution](/glossary/#execution-layer) » et « [consensus](/glossary/#consensus-layer) » sont définies dans le glossaire.
 
 ## Pourquoi existe-t-il différents clients ? {#why-multiple-clients}
 
-De multiples clients, développés et mis à jour de manière indépendante, existent parce que la diversité des clients rend le réseau plus résistant aux attaques et aux bogues. La multitude de clients est une force propre à Ethereum - d'autres blockchains dépendent de l'infaillibilité d'un seul client. Cependant, il ne suffit pas de disposer de plusieurs clients, ceux-ci doivent être adoptés par la communauté et la totalité des nœuds actifs répartis relativement égale entre eux.
+De multiples clients, développés et mis à jour de manière indépendante, existent parce que la diversité des clients rend le réseau plus résistant aux attaques et aux bogues. La multitude de clients est une force propre à Ethereum - d'autres blockchains dépendent de l'infaillibilité d'un seul client. Cependant, il ne suffit pas de disposer de plusieurs clients ; ceux-ci doivent être adoptés par la communauté et l'ensemble des nœuds actifs doit être réparti de manière relativement égale entre eux.
 
 ## Pourquoi la diversité des clients est-elle importante ? {#client-diversity-importance}
 
@@ -23,86 +23,107 @@ Disposer de nombreux clients développés et mis à jour de façon indépendante
 
 Un bogue dans un client individualisé est moins risqué pour le réseau lorsqu'il représente une minorité de nœuds Ethereum. Lorsque les nœuds sont répartis de façon à peu près égale entre de nombreux clients, la probabilité que la plupart des clients souffrent d'un problème commun est faible et, par conséquent, le réseau est plus robuste.
 
-### Résistance aux attaques {#resilience}
+### Résilience aux attaques {#resilience}
 
-La diversité des clients offre également une résilience aux attaques. Par exemple, une attaque qui viserait [un client spécifique](https://twitter.com/vdWijden/status/1437712249926393858) sur une branche particulière de la chaîne a peu de chance de réussir parce que les autres clients sont peu susceptibles d'être exploités de la même manière et que la chaîne canonique reste intacte. La faible diversité des clients augmente le risque associé à un piratage sur le client dominant. La diversité des clients s'est déjà avérée être une défense efficace contre les attaques malveillantes sur le réseau, par exemple l'attaque de Shanghai par déni de service en 2016 a pu être menée parce que les attaquants ont réussi à tromper le client dominant (Geth) en exécutant une opération sur disque i/o des dizaines de milliers de fois par bloc. Puisque des clients alternatifs étaient également en ligne et ne partageaient pas la vulnérabilité, Ethereum a pu résister à l'attaque et continuer à fonctionner pendant que la vulnérabilité de Geth était corrigée.
+La diversité des clients offre également une résilience aux attaques. Par exemple, une attaque qui [trompe un client particulier](https://twitter.com/vdWijden/status/1437712249926393858) pour l'attirer sur une branche particulière de la chaîne a peu de chances de réussir, car les autres clients sont peu susceptibles d'être exploitables de la même manière et la chaîne canonique reste non corrompue. La faible diversité des clients augmente le risque associé à un piratage sur le client dominant. La diversité des clients s'est déjà avérée être une défense importante contre les attaques malveillantes sur le réseau ; par exemple, l'attaque par déni de service de Shanghai en 2016 a été possible parce que les attaquants ont pu tromper le client dominant (Geth) en lui faisant exécuter une opération d'E/S disque lente des dizaines de milliers de fois par bloc. Puisque des clients alternatifs étaient également en ligne et ne partageaient pas la vulnérabilité, Ethereum a pu résister à l'attaque et continuer à fonctionner pendant que la vulnérabilité de Geth était corrigée.
 
 ### Finalité de la preuve d'enjeu {#finality}
 
 Un bug dans un client de consensus avec plus de 33 % des nœuds Ethereum pourrait empêcher la finalisation couche de consensus, de sorte que les utilisateurs ne pourraient pas avoir confiance dans le fait que les transactions ne seraient pas annulées ou modifiées à un moment donné. Cela serait problématique pour de nombreuses applications basées sur Ethereum, en particulier pour la DeFi.
 
-<Emoji text="🚨" className="me-4" /> Pire encore, un bogue critique dans un client avec une majorité des deux tiers pourrait causer <a href="https://www.symphonious.net/2021/09/23/what-happens-if-beacon-chain-consensus-fails/" target="_blank">le fractionnement et la finalisation incorrecte de la chaîne</a>, entraînant le blocage d'un grand nombre de validateurs sur une chaîne invalide. S'ils souhaitent rejoindre la bonne chaîne, ces validateurs sont confrontés à un délestage ou à un retrait volontaire et à une réactivation lente et coûteuse. La magnitude d'un délestage est proportionnelle au nombre de nœuds impliqués avec une majorité des deux tiers sanctionnée au maximum (32 ETH).
+<Emoji text="🚨" className="me-4" /> Pire encore, un bogue critique dans un client détenant une majorité des deux tiers pourrait provoquer <a href="https://www.symphonious.net/2021/09/23/what-happens-if-beacon-chain-consensus-fails/" target="_blank">une division et une finalisation incorrectes de la chaîne</a>, bloquant un grand nombre de validateurs sur une chaîne invalide. S'ils souhaitent rejoindre la bonne chaîne, ces validateurs sont confrontés à un délestage ou à un retrait volontaire et à une réactivation lente et coûteuse. La magnitude d'un délestage est proportionnelle au nombre de nœuds impliqués avec une majorité des deux tiers sanctionnée au maximum (32 ETH).
 
 Bien que ces scénarios soient peu probables, l’écosystème Ethereum peut atténuer leurs risques en éliminant la distribution des clients sur les nœuds actifs. Idéalement, aucun client de consensus ne devrait pouvoir atteindre 33 % du total des nœuds.
 
-### Partager les responsabilités {#responsibility}
+### Responsabilité partagée {#responsibility}
 
 Le fait d'avoir des clients majoritaires a aussi un coût humain. Il impose une pression et une responsabilité excessives à une petite équipe de développement. Plus la diversité des clients est limitée, plus la charge de responsabilité est importante pour les développeurs qui maintiennent le client majoritaire. La répartition de cette responsabilité entre plusieurs équipes est bénéfique pour la bonne santé du réseau de nœuds d'Ethereum et de son réseau d'utilisateurs.
 
-## Diversité actuelle de clients {#current-client-diversity}
+## Diversité actuelle des clients {#current-client-diversity}
 
-![Graphique Pie montrant la diversité des clients](./client-diversity.png) _Schéma issu des données de [ethernodes.org](https://ethernodes.org) et [clientdiversity.org](https://clientdiversity.org/)_
+### Clients d'exécution {#execution-clients-breakdown}
 
-Les deux diagrammes ci-dessus montrent des instantanés de la diversité actuelle de clients pour l'exécution et les couches de consensus (au moment de l'écriture en janvier 2022). La couche d'exécution est dominée par [Geth](https://geth.ethereum.org/), avec [Open Ethereum](https://openethereum.github.io/) en seconde place, [Erigon](https://github.com/ledgerwatch/erigon) troisième et [Nethermind](https://nethermind.io/) quatrième, puis d'autres logiciels représentant moins de 1 % du réseau. Le client le plus couramment utilisé sur la couche de consensus - [Prysm](https://prysmaticlabs.com/#projects) - n'est pas aussi dominant que Geth mais représente toujours plus de 60 % du réseau. [Lighthouse](https://lighthouse.sigmaprime.io/) et [Teku](https://consensys.net/knowledge-base/ethereum-2/teku/) représentent respectivement ~20 % et ~14 %, et les autres clients ne sont que rarement utilisés.
+<PieChart
+data={[
+{ name: "Geth", value: 41 },
+{ name: "Nethermind", value: 38 },
+{ name: "Besu", value: 16 },
+{ name: "Erigon", value: 3 },
+{ name: "Reth", value: 2 }
+]}
+/>
 
-Les données de la couche d'exécution ont été obtenues à partir de [Ethernodes](https://ethernodes.org) le 23 janvier 2022. Les données pour les clients de consensus ont été obtenues à partir de [Michael Sproul](https://github.com/sigp/blockprint). Les données du client du consensus sont plus difficiles à obtenir dans la mesure où les clients de la couche de consensus ne disposent pas toujours de traces claires susceptibles d'être utilisées pour les identifier. Les données ont été générées à l'aide d'un algorithme de classification qui, parfois, induit en erreur certains des clients minoritaires (voir [ici](https://twitter.com/sproulM_/status/1440512518242197516) pour plus de détails). Dans le diagramme ci-dessus, ces classifications ambiguës sont traitées avec une étiquette de type soit/soit (par exemple Nimbus/Teku). Néanmoins, il est clair que la majorité du réseau utilise Prysm. Les données constituent un instantané sur un ensemble fixe de blocs (dans ce cas, les blocs de la chaîne phare pour les emplacements 2048001 à 2164916) et la domination de Prysm a parfois même été plus élevée, dépassant les 68 %. Bien que ce ne soient que des instantanés, les valeurs du diagramme fournissent un bonne vision générale de l'état actuel de la diversité des clients.
+### Clients de consensus {#consensus-clients-breakdown}
 
-Des données mises à jour concernant la diversité des clients pour la couche de consensus sont maintenant disponibles sur [clientdiversity.org](https://clientdiversity.org/).
+<PieChart
+data={[
+{ name: "Lighthouse", value: 42.71 },
+{ name: "Prysm", value: 30.91},
+{ name: "Teku", value: 13.86},
+{ name: "Nimbus", value: 8.74},
+{ name: "Lodestar", value: 2.67 },
+{ name: "Grandine", value: 1.04 },
+{ name: "Autre", value: 0.07 }
+]}
+/>
 
-## Couche d'exécution {#execution-layer}
+Ce diagramme peut être obsolète — rendez-vous sur [ethernodes.org](https://ethernodes.org) et [clientdiversity.org](https://clientdiversity.org) pour obtenir des informations à jour.
 
-Jusqu’à présent, la conversation autour de la diversité des clients s’est principalement concentrée sur la couche de consensus. Cependant, le client d'exécution [Geth](https://geth.ethereum.org) compte actuellement pour environ 85 % de l'ensemble de tous les nœuds. Ce pourcentage est problématique pour les mêmes raisons que pour les clients de consensus. Par exemple, un bogue dans Geth affectant la gestion des transactions ou la construction de blocs d'exécution peut conduire les clients de consensus à finaliser des transactions problématiques ou avec des bogues. Ainsi, Ethereum serait plus sain avec une distribution plus uniforme des clients d'exécution, idéalement sans client représentant plus de 33 % du réseau.
+Les deux diagrammes circulaires ci-dessus montrent des instantanés de la diversité actuelle des clients pour les couches d'exécution et de consensus (au moment de la rédaction en octobre 2025). La diversité des clients s'est améliorée au fil des ans et la couche d'exécution a vu une réduction de la domination de [Geth](https://geth.ethereum.org/), avec [Nethermind](https://www.nethermind.io/nethermind-client) juste derrière, puis [Besu](https://besu.hyperledger.org/) et [Erigon](https://github.com/ledgerwatch/erigon), les autres clients représentant moins de 3 % du réseau. Le client le plus utilisé sur la couche de consensus — [Lighthouse](https://lighthouse.sigmaprime.io/) — est au coude-à-coude avec le deuxième plus utilisé. [Prysm](https://prysmaticlabs.com/#projects) et [Teku](https://consensys.net/knowledge-base/ethereum-2/teku/) représentent respectivement ~31 % et ~14 %, et les autres clients sont rarement utilisés.
 
-## Utiliser un client minoritaire {#use-minority-client}
-
-Pour résoudre le problème de la diversité des clients, il ne suffit pas que les utilisateurs individuels choisissent des clients minoritaires : il faut aussi que les pools de mineurs/validateurs et les institutions comme les principales dapps et les plateformes d'échange changent de clients. Cependant, tous les utilisateurs peuvent collaborer pour corriger le déséquilibre actuel et normaliser l'utilisation de tous les logiciels Ethereum disponibles. Après La Fusion, tous les opérateurs de nœuds seront requis pour exécuter un client d'exécution et un client de consensus. Le choix des combinaisons de clients suggérées ci-dessous contribuera à accroître la diversité des clients.
-
-### Clients d'exécution {#execution-clients}
-
-[Besu](https://www.hyperledger.org/use/besu)
-
-[Nethermind](https://downloads.nethermind.io/)
+Les données de la couche d'exécution ont été obtenues sur [supermajority.info](https://supermajority.info/) le 26 octobre 2025. Les données pour les clients de consensus ont été obtenues auprès de [Michael Sproul](https://github.com/sigp/blockprint). Les données du client du consensus sont plus difficiles à obtenir dans la mesure où les clients de la couche de consensus ne disposent pas toujours de traces claires susceptibles d'être utilisées pour les identifier. Les données ont été générées à l'aide d'un algorithme de classification qui confond parfois certains des clients minoritaires (voir [ici](https://twitter.com/sproulM_/status/1440512518242197516) pour plus de détails). Dans le diagramme ci-dessus, ces classifications ambiguës sont traitées avec une étiquette « soit/soit » (p. ex., Nimbus/Teku). Néanmoins, il est clair que la majorité du réseau utilise Prysm. Bien que ce ne soient que des instantanés, les valeurs du diagramme fournissent un bonne vision générale de l'état actuel de la diversité des clients.
 
-[Erigon](https://github.com/ledgerwatch/erigon)
+Des données à jour sur la diversité des clients pour la couche de consensus sont désormais disponibles sur [clientdiversity.org](https://clientdiversity.org/).
 
-[Go-Ethereum](https://geth.ethereum.org/)
+## Couche d’exécution {#execution-layer}
 
-### Clients de consensus {#consensus-clients}
+Jusqu’à présent, la conversation autour de la diversité des clients s’est principalement concentrée sur la couche de consensus. Cependant, le client d'exécution [Geth](https://geth.ethereum.org) représente actuellement environ 85 % de tous les nœuds. Ce pourcentage est problématique pour les mêmes raisons que pour les clients de consensus. Par exemple, un bogue dans Geth affectant la gestion des transactions ou la construction de blocs d'exécution peut conduire les clients de consensus à finaliser des transactions problématiques ou avec des bogues. Ainsi, Ethereum serait plus sain avec une distribution plus uniforme des clients d'exécution, idéalement sans client représentant plus de 33 % du réseau.
 
-[Nimbus](https://nimbus.team/)
+## Utiliser un client minoritaire {#use-minority-client}
 
-[Lighthouse](https://github.com/sigp/lighthouse)
+Assurer la diversité des clients ne se limite pas au choix individuel d’utilisateurs qui optent pour des clients minoritaires : cela nécessite aussi que les pools de validateurs et les institutions, comme les principales dapps et plateformes d’échange, changent également de client. Cependant, tous les utilisateurs peuvent collaborer pour corriger le déséquilibre actuel et normaliser l'utilisation de tous les logiciels Ethereum disponibles. Après La Fusion, tous les opérateurs de nœuds seront requis pour exécuter un client d'exécution et un client de consensus. Le choix des combinaisons de clients suggérées ci-dessous contribuera à accroître la diversité des clients.
 
-[Teku](https://consensys.net/knowledge-base/ethereum-2/teku/)
+### Clients d'exécution {#execution-clients}
 
-[Lodestar](https://github.com/ChainSafe/lodestar)
+- [Besu](https://www.hyperledger.org/use/besu)
+- [Nethermind](https://downloads.nethermind.io/)
+- [Erigon](https://github.com/ledgerwatch/erigon)
+- [Go-Ethereum](https://geth.ethereum.org/)
+- [Reth](https://reth.rs/)
 
-[Prysm](https://prysm.offchainlabs.com/docs/)
+### Clients de consensus {#consensus-clients}
 
-[Grandine](https://docs.grandine.io/)
+- [Nimbus](https://nimbus.team/)
+- [Lighthouse](https://github.com/sigp/lighthouse)
+- [Teku](https://consensys.io/teku)
+- [Lodestar](https://github.com/ChainSafe/lodestar)
+- [Prysm](https://prysm.offchainlabs.com/docs/)
+- [Grandine](https://docs.grandine.io/)
 
-Les utilisateurs techniques peuvent aider à accélérer ce processus en rédigeant plus de tutoriels et de documentation pour les clients minoritaires et ainsi encourager leurs pairs à migrer loin des clients dominants. Des guides pour basculer vers un client de consensus minoritaire sont disponibles sur [clientdiversity.org](https://clientdiversity.org/).
+Les utilisateurs techniques peuvent aider à accélérer ce processus en rédigeant plus de tutoriels et de documentation pour les clients minoritaires et ainsi encourager leurs pairs à migrer loin des clients dominants. Des guides pour passer à un client de consensus minoritaire sont disponibles sur [clientdiversity.org](https://clientdiversity.org/).
 
-## Tableaux de bord relatif à la diversité des clients {#client-diversity-dashboards}
+## Tableaux de bord de la diversité des clients {#client-diversity-dashboards}
 
 Plusieurs tableaux de bord donnent des statistiques en temps réel de la diversité des clients pour la couche d'exécution et la couche de consensus.
 
 **Couche de consensus:**
 
 - [Rated.network](https://www.rated.network/)
-- [clientdiversity.org](https://clientdiversity.org/) **Couche d'exécution :**
+- [clientdiversity.org](https://clientdiversity.org/)
+
+**Couche d’exécution :**
 
 - [supermajority.info](https://supermajority.info//)
 - [Ethernodes](https://ethernodes.org/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Diversité des clients sur la couche de consensus d'Ethereum](https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA)
-- [La Fusion Ethereum : Exécutez le client majoritaire à vos risques et périls !](https://dankradfeist.de/ethereum/2022/03/24/run-the-majority-client-at-your-own-peril.html) – _Dankrad Fiest, 24 mars 2022_
+- [La diversité des clients sur la couche de consensus d'Ethereum](https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA)
+- [La Fusion d'Ethereum : utilisez le client majoritaire à vos risques et périls !](https://dankradfeist.de/ethereum/2022/03/24/run-the-majority-client-at-your-own-peril.html) – _Dankrad Fiest, 24 mars 2022_
 - [L'importance de la diversité des clients](https://our.status.im/the-importance-of-client-diversity/)
 - [Liste des services de nœuds Ethereum](https://ethereumnodes.com/)
-- [Cinq raisons au problème de la diversité des clients](https://notes.ethereum.org/@afhGjrKfTKmksTOtqhB9RQ/BJGj7uh08)
-- [Diversité Ethereum et comment la résoudre (YouTube)](https://www.youtube.com/watch?v=1hZgCaiqwfU)
+- [Les « Cinq pourquoi » du problème de la diversité des clients](https://notes.ethereum.org/@afhGjrKfTKmksTOtqhB9RQ/BJGj7uh08)
+- [La diversité sur Ethereum et comment la résoudre (YouTube)](https://www.youtube.com/watch?v=1hZgCaiqwfU)
 - [clientdiversity.org](https://clientdiversity.org/)
 
 ## Sujets connexes {#related-topics}
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/index.md
index 055bb982b7f..7e66dd0f69c 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/index.md
@@ -1,6 +1,6 @@
 ---
-title: Nœuds et clients
-description: Présentation des nœuds Ethereum et des logiciels clients, de la façon de configurer un nœud et des raisons de le faire.
+title: "Nœuds et clients"
+description: "Présentation des nœuds Ethereum et des logiciels clients, de la façon de configurer un nœud et des raisons de le faire."
 lang: fr
 sidebarDepth: 2
 ---
@@ -9,9 +9,9 @@ Ethereum est un réseau d'ordinateurs qui exécutent des logiciels (appelés nœ
 
 ## Prérequis {#prerequisites}
 
-Vous devez comprendre le concept de réseau de pair-à-pair et [les bases de l'EVM](/developers/docs/evm/) avant d'approfondir et d'exécuter votre propre instance d'un client Ethereum. Commencez par lire la page [Introduction à Ethereum](/developers/docs/intro-to-ethereum/).
+Vous devez comprendre le concept de réseau pair-à-pair et les [bases de l'EVM](/developers/docs/evm/) avant d'approfondir et d'exécuter votre propre instance d'un client Ethereum. Consultez notre [introduction à Ethereum](/developers/docs/intro-to-ethereum/).
 
-Si vous êtes novice au sujet des nœuds, nous vous recommandons de consulter en premier lieu notre introduction conviviale sur [l'exécution d'un nœud Ethereum](/run-a-node).
+Si vous découvrez le sujet des nœuds, nous vous recommandons de consulter d'abord notre introduction conviviale sur [l'exécution d'un nœud Ethereum](/run-a-node).
 
 ## En quoi consistent les nœuds et les clients? {#what-are-nodes-and-clients}
 
@@ -20,24 +20,26 @@ Un « nœud » désigne toute instance de logiciel client Ethereum connecté à
 - Le client d'exécution (également connu sous le nom de moteur d'exécution, de client EL ou anciennement de client Eth1) écoute les nouvelles transactions diffusées sur le réseau, les exécute dans l'EVM, et contient la dernière base de données et l'état de toutes les données Ethereum actuelles.
 - Le client de consensus (également connu sous le nom de Nœud Beacon, client CL ou anciennement de client Eth2) implémente l'algorithme de consensus de la preuve d'enjeu, qui permet au réseau de parvenir à un accord basé sur des données validées du client d'exécution. Il y a également un troisième logiciel, appelé « validateur », qui peut être ajouté au client de consensus afin de permettre à un nœud de participer à la sécurisation du réseau.
 
-Ces clients travaillent ensemble pour suivre la tête de la chaîne Ethereum et permettre aux utilisateurs d'interagir avec le réseau Ethereum. La conception modulaire avec plusieurs logiciels fonctionnant ensemble est appelée [complexité encapsulée](https://vitalik.eth.limo/general/2022/02/28/complexity.html). Cette approche a permis de plus facilement exécuter [La Fusion](/roadmap/merge) de manière fluide, facilite la maintenance et le développement du logiciel client et permet la réutilisation des clients individuels, par exemple au sein de [l'écosystème](/layer-2/) de la couche 2.
+Ces clients travaillent ensemble pour suivre la tête de la chaîne Ethereum et permettre aux utilisateurs d'interagir avec le réseau Ethereum. La conception modulaire avec plusieurs logiciels fonctionnant ensemble est appelée [complexité encapsulée](https://vitalik.eth.limo/general/2022/02/28/complexity.html). Cette approche a facilité l'exécution de [La Fusion](/roadmap/merge) en toute transparence, facilite la maintenance et le développement du logiciel client, et permet la réutilisation de clients individuels, par exemple, dans l'[écosystème de la couche 2](/layer-2/).
 
-![Exécution couplée et clients de consensus](./eth1eth2client.png) Diagramme simplifié d'une exécution couplée et d'un client de consensus.
+![Clients d'exécution et de consensus couplés](./eth1eth2client.png)
+Schéma simplifié d'un client d'exécution et de consensus couplé.
 
 ### Diversité des clients {#client-diversity}
 
-Les [clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) et [clients de consensus](/developers/docs/nodes-and-clients/#consensus-clients) existent dans une variété de langages de programmation développés par différentes équipes.
+Les [clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) et les [clients de consensus](/developers/docs/nodes-and-clients/#consensus-clients) existent dans une variété de langages de programmation développés par différentes équipes.
 
-Les implémentations de plusieurs clients peuvent renforcer le réseau en réduisant sa dépendance sur la base d'un code unique. L'objectif idéal est de parvenir à la diversité sans qu'aucun client ne domine le réseau, éliminant ainsi un point de défaillance potentiel. La diversité des langages invite également une communauté plus large de développeurs et leur permet de créer des intégrations dans leur langage préféré.
+Les implémentations de plusieurs clients peuvent renforcer le réseau en réduisant sa dépendance sur la base d'un code unique. L'objectif idéal est de parvenir à la diversité sans qu'aucun client ne domine le réseau, éliminant ainsi un point de défaillance potentiel.
+La diversité des langages invite également une communauté plus large de développeurs et leur permet de créer des intégrations dans leur langage préféré.
 
 En savoir plus sur la [diversité des clients](/developers/docs/nodes-and-clients/client-diversity/).
 
 Ce que ces implémentations ont en commun, c'est qu'elles suivent toutes une seule spécification. Les spécifications régissent le fonctionnement du réseau Ethereum et de la blockchain. Chaque détail technique est défini et les spécifications peuvent être trouvées en tant que :
 
-- À l'origine, le [Livre jaune Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf)
+- À l'origine, le [Livre jaune d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf)
 - [Spécifications d'exécution](https://github.com/ethereum/execution-specs/)
 - [Spécifications de consensus](https://github.com/ethereum/consensus-specs)
-- [EIPs](https://eips.ethereum.org/) implémentés dans diverses [mises à jour réseau](/ethereum-forks/)
+- [EIP](https://eips.ethereum.org/) mis en œuvre dans diverses [mises à niveau du réseau](/ethereum-forks/)
 
 ### Suivi des nœuds sur le réseau {#network-overview}
 
@@ -47,14 +49,15 @@ Les crackers multiples offrent une vue d'ensemble en temps réel des nœuds du r
 - [Ethernodes](https://ethernodes.org/) par Bitfly
 - [Nodewatch](https://www.nodewatch.io/) par Chainsafe, exploration des nœuds de consensus
 - [Monitoreth](https://monitoreth.io/) - par MigaLabs, un outil de surveillance de réseau distribué
+- [Rapports hebdomadaires sur la santé du réseau](https://probelab.io) - par ProbeLab, utilisant le [crawler Nebula](https://github.com/dennis-tra/nebula) et d'autres outils
 
 ## Types de nœuds {#node-types}
 
-Si vous voulez [exécuter votre propre nœud](/developers/docs/nodes-and-clients/run-a-node/), vous devez comprendre qu'il existe différents types de nœuds et que ceux-ci consomment les données différemment. En fait, les clients peuvent exécuter différents types de nœuds : légers, complets et d'archives. Il existe également différentes stratégies de synchronisation afin d'accélérer le temps de synchronisation. La synchronisation fait référence à la vitesse à laquelle on peut obtenir les informations les plus récentes sur l'état d'Ethereum.
+Si vous voulez [exécuter votre propre nœud](/developers/docs/nodes-and-clients/run-a-node/), vous devez comprendre qu'il existe différents types de nœuds qui consomment les données différemment. En fait, les clients peuvent exécuter différents types de nœuds : légers, complets et d'archives. Il existe également différentes stratégies de synchronisation afin d'accélérer le temps de synchronisation. La synchronisation fait référence à la vitesse à laquelle on peut obtenir les informations les plus récentes sur l'état d'Ethereum.
 
 ### Nœud complet {#full-node}
 
-Les nœuds complets effectuent une validation bloc par bloc de la blockchain, y compris le téléchargement et la vérification du corps du bloc et des données d'état pour chaque bloc. Il existe différentes classes de nœuds complets - certains commencent à partir du bloc de genèse et vérifient chaque bloc de l'ensemble de l'historique de la blockchain. D'autres commencent leur vérification à partir d'un bloc plus récent qu'ils considèrent comme valide (par exemple, la 'snap sync' de Geth). Indépendamment du point de départ de la vérification, les nœuds complets ne conservent qu'une copie locale des données relativement récentes (généralement les 128 blocs les plus récents), permettant de supprimer les anciennes données pour économiser de l'espace disque. Les anciennes données peuvent être régénérées lorsqu'elles sont nécessaires.
+Les nœuds complets effectuent une validation bloc par bloc de la blockchain, y compris le téléchargement et la vérification du corps du bloc et des données d'état pour chaque bloc. Il existe différentes classes de nœuds complets - certains commencent à partir du bloc de genèse et vérifient chaque bloc de l'ensemble de l'historique de la blockchain. D'autres commencent leur vérification à partir d'un bloc plus récent qu'ils jugent valide (p. ex., la « synchronisation instantanée » de Geth). Indépendamment du point de départ de la vérification, les nœuds complets ne conservent qu'une copie locale des données relativement récentes (généralement les 128 blocs les plus récents), permettant de supprimer les anciennes données pour économiser de l'espace disque. Les anciennes données peuvent être régénérées lorsqu'elles sont nécessaires.
 
 - Stocke toutes les données de la blockchain (même si celles-ci sont régulièrement "« taillées », de sorte qu'un nœud complet ne stocke pas toutes les données de la chaîne depuis la genèse)
 - Participe à la validation de blocs, vérifie tous les blocs et états.
@@ -65,20 +68,21 @@ Les nœuds complets effectuent une validation bloc par bloc de la blockchain, y
 
 Les nœuds d'archive sont des nœuds complets qui vérifient chaque bloc depuis le bloc de genèse et ne suppriment jamais aucune des données téléchargées.
 
-- Stocke tout ce qui est conservé dans le nœud complet et construit une archive des états de l'historique. Il est nécessaire pour aller chercher des informations comme le solde d'un compte au bloc #4 000 000, ou tester vos propres ensembles de transactions simplement et efficacement sans les miner en utilisant le traçage.
+- Stocke tout ce qui est conservé dans le nœud complet et construit une archive des états de l'historique. C’est nécessaire si vous souhaitez interroger, par exemple, le solde d’un compte au bloc n°4 000 000, ou tester de manière simple et fiable votre propre ensemble de transactions sans les valider à l’aide du traçage.
 - Ces données représentent des unités de téraoctets qui rendent les nœuds d'archives moins attrayants pour les utilisateurs courants, mais peut être utile pour des services comme les explorateurs de blocs, les fournisseurs de portefeuilles et les analyses de chaînes.
 
 La synchronisation des clients dans un autre mode que celui de l'archivage entraînera la suppression de données de la blockchain. Cela signifie qu'il n'existe pas d'archive de tous les états de l'historique, mais que le nœud complet est capable de les construire sur demande.
 
-En savoir plus sur les [nœuds d'archives](/developers/docs/nodes-and-clients/archive-nodes).
+En savoir plus sur les [nœuds d'archive](/developers/docs/nodes-and-clients/archive-nodes).
 
 ### Nœud léger {#light-node}
 
-Au lieu de télécharger chaque bloc, les nœuds légers téléchargent seulement les en-têtes de bloc. Ces en-têtes ne contiennent que des informations sommaires sur le contenu des blocs. Toute autre information que le nœud léger pourrait requérir fait l'objet d'une requête auprès d'un nœud complet. Les nœuds légers peuvent alors comparer indépendamment les données qu'ils reçoivent avec les racines d'état dans les en-têtes de bloc. Les nœuds légers permettent aux utilisateurs de participer au réseau Ethereum sans nécessité de matériel onéreux ou de connexion internet haut débit nécessaires à l'exécution d'un nœud complet. Les nœuds légers peuvent même être exécutés depuis des téléphones portables ou des appareils embarqués. Les nœuds légers ne participent pas au consensus (c'est-à-dire qu'ils ne peuvent pas être des mineurs ou des validateurs), mais ils peuvent accéder à la blockchain Ethereum avec la même efficience et garantie de sécurité qu'un nœud complet.
+Au lieu de télécharger chaque bloc, les nœuds légers téléchargent seulement les en-têtes de bloc. Ces en-têtes ne contiennent que des informations sommaires sur le contenu des blocs. Toute autre information que le nœud léger pourrait requérir fait l'objet d'une requête auprès d'un nœud complet. Les nœuds légers peuvent alors comparer indépendamment les données qu'ils reçoivent avec les racines d'état dans les en-têtes de bloc. Les nœuds légers permettent aux utilisateurs de participer au réseau Ethereum sans nécessité de matériel onéreux ou de connexion internet haut débit nécessaires à l'exécution d'un nœud complet. Les nœuds légers peuvent même être exécutés depuis des téléphones portables ou des appareils embarqués. Les nœuds légers ne participent pas au consensus (c'est-à-dire qu'ils ne peuvent pas être des validateurs), mais ils peuvent accéder à la blockchain Ethereum avec les mêmes fonctionnalités et garanties de sécurité qu'un nœud complet.
 
-Les clients légers sont un domaine de développement actif pour Ethereum et nous nous attendons à prochainement voir apparaître de nouveaux clients légers pour la couche de consensus et la couche d'exécution. Il existe également des routes potentielles pour fournir des données client légers sur le [réseau de diffusion](https://www.ethportal.net/). Ceci est avantageux dans la mesure où le réseau de diffusion pourrait supporter un réseau de nœuds légers sans avoir besoin que des nœuds complets servent les requêtes.
+Les clients légers sont un domaine de développement actif pour Ethereum et nous nous attendons à prochainement voir apparaître de nouveaux clients légers pour la couche de consensus et la couche d'exécution.
+Il existe également des itinéraires potentiels pour fournir des données de client léger sur le [réseau gossip](https://www.ethportal.net/). Ceci est avantageux dans la mesure où le réseau de diffusion pourrait supporter un réseau de nœuds légers sans avoir besoin que des nœuds complets servent les requêtes.
 
-Ethereum ne prend pas encore en charge un nombre important de ces nœuds légers mais la prise en charge des nœuds légers est une thématique qui devrait fortement se développer dans un futur proche. En particulier, des clients comme [Nimbus](https://nimbus.team/), [Helios](https://github.com/a16z/helios), et [LodeStar](https://lodestar.chainsafe.io/) se focalisent actuellement fortement sur les nœuds légers.
+Ethereum ne prend pas encore en charge un nombre important de ces nœuds légers mais la prise en charge des nœuds légers est une thématique qui devrait fortement se développer dans un futur proche. En particulier, des clients comme [Nimbus](https://nimbus.team/), [Helios](https://github.com/a16z/helios) et [LodeStar](https://lodestar.chainsafe.io/) se concentrent actuellement beaucoup sur les nœuds légers.
 
 ## Pourquoi exécuter un nœud Ethereum ? {#why-should-i-run-an-ethereum-node}
 
@@ -89,36 +93,36 @@ Exécuter un nœud vous permet d'utiliser directement Ethereum en toute confianc
 L'exécution de votre propre nœud vous permet d'utiliser Ethereum de façon privée, autonome et fiable. Vous n'avez pas besoin de faire confiance au réseau car vous pouvez vous-même vérifier les données avec votre client. « Ne faites pas confiance, vérifiez » est une devise populaire de la blockchain.
 
 - Votre nœud vérifie lui-même toutes les transactions et tous les blocs par rapport aux règles de consensus. Cela signifie que vous n’avez ni à vous fier à d’autres nœuds du réseau ni à leur faire entièrement confiance.
-- Vous pouvez utiliser un portefeuille Ethereum avec votre propre nœud. Vous pouvez utiliser des DApps de manière plus sécurisée et privée parce que vous n'aurez pas à communiquer vos adresses et soldes avec des intermédiaires. Tout peut être contrôlé avec votre propre client. [MetaMask](https://metamask.io), [Frame](https://frame.sh/), et [de nombreux autres portefeuilles](/wallets/find-wallet/) proposent l'importation du RPC, leur permettant d'utiliser votre nœud.
+- Vous pouvez utiliser un portefeuille Ethereum avec votre propre nœud. Vous pouvez utiliser des DApps de manière plus sécurisée et privée parce que vous n'aurez pas à communiquer vos adresses et soldes avec des intermédiaires. Tout peut être contrôlé avec votre propre client. [MetaMask](https://metamask.io), [Frame](https://frame.sh/), et [de nombreux autres portefeuilles](/wallets/find-wallet/) permettent l'importation de RPC, ce qui leur permet d'utiliser votre nœud.
 - Vous pouvez exécuter et autohéberger d'autres services qui dépendent des données d'Ethereum. Par exemple, il peut s'agir d'un validateur de Chaîne Phare, d'un logiciel comme la couche 2, d'une infrastructure, d'explorateur de blocs, de processeurs de paiement, etc.
-- Vous pouvez fournir vos propres [points de terminaison RPC personnalisés](/developers/docs/apis/json-rpc/). Vous pourriez même proposer ces points de terminaison publiquement à la communauté pour les aider à éviter les grands fournisseurs centralisés.
-- Vous pouvez vous connecter à votre nœud en utilisant **les communications interprocessus (IPC)** ou réécrire le nœud pour charger votre programme en tant que plugin. Cette démarche garantit une faible latence, or cela est très utile, par exemple lorsque vous traitez beaucoup de données en utilisant des bibliothèques web3 ou lorsque vous avez besoin de remplacer vos transactions le plus rapidement possible (cas du frontrunning).
-- Vous pouvez directement miser de l'ETH pour sécuriser le réseau et gagner des récompenses. Voir [la mise en jeu individuelle](/staking/solo/) pour commencer.
+- Vous pouvez fournir vos propres [points de terminaison RPC](/developers/docs/apis/json-rpc/) personnalisés. Vous pourriez même proposer ces points de terminaison publiquement à la communauté pour les aider à éviter les grands fournisseurs centralisés.
+- Vous pouvez vous connecter à votre nœud en utilisant les **communications interprocessus (IPC)** ou réécrire le nœud pour charger votre programme en tant que plugin. Cela garantit une faible latence, ce qui est très utile, par exemple, lors du traitement d'un grand nombre de données à l'aide de bibliothèques web3 ou lorsque vous devez remplacer vos transactions le plus rapidement possible (c'est-à-dire, le frontrunning).
+- Vous pouvez directement miser de l'ETH pour sécuriser le réseau et gagner des récompenses. Consultez la [mise en jeu en solo](/staking/solo/) pour commencer.
 
 ![Comment accéder à Ethereum via votre application et vos nœuds](./nodes.png)
 
-### Avantages du réseau {#network-benefits}
+### Avantages pour le réseau {#network-benefits}
 
 Il est important de disposer d'un ensemble diversifié de nœuds pour garantir le bon fonctionnement, la sécurité et la résilience opérationnelle d’Ethereum.
 
 - Les nœuds complets appliquent les règles de consensus afin de ne pas se faire piéger en acceptant des blocs qui ne les suivent pas. Cette approche offre une sécurité supplémentaire au sein du réseau. En effet, si tous les nœuds étaient des nœuds légers (qui ne font pas de vérification complète), les validateurs pourraient attaquer le réseau.
-- Dans le cas d'une attaque qui surmonte les défenses crypto-économiques de [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/#what-is-pos), une reprise sociale peut être effectuée par les nœuds complets choisissant de suivre la chaîne honnête.
+- En cas d'attaque qui surmonte les défenses crypto-économiques de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/#what-is-pos), une récupération sociale peut être effectuée par des nœuds complets choisissant de suivre la chaîne honnête.
 - Un plus grand nombre de nœuds dans le réseau se traduit par un réseau plus diversifié et robuste, soit l'objectif ultime de la décentralisation, qui favorise un système fiable et résistant à la censure.
-- Les noeuds complets fournissent un accès aux données de la blockchain pour les clients légers qui en dépendent. Les nœuds légers ne stockent pas toute la blockchain. Au lieu de cela, ils vérifient les données via les [racines d'état des en-têtes de blocs](/developers/docs/blocks/#block-anatomy). Ils peuvent demander plus d'informations aux noeuds complets si besoin.
+- Les noeuds complets fournissent un accès aux données de la blockchain pour les clients légers qui en dépendent. Les nœuds légers ne stockent pas l'intégralité de la blockchain, mais ils vérifient les données via les [racines d'état dans les en-têtes de bloc](/developers/docs/blocks/#block-anatomy). Ils peuvent demander plus d'informations aux noeuds complets si besoin.
 
 Si vous exécutez un nœud complet, l'ensemble du réseau Ethereum en bénéficie, même si vous ne faites pas fonctionner un validateur.
 
-## Exécuter son propre nœud {#running-your-own-node}
+## Exécuter votre propre nœud {#running-your-own-node}
 
 Vous aimeriez faire fonctionner votre propre client Ethereum ?
 
-Pour une introduction facile destinée aux débutants, consultez notre page [pour en savoir plus](/run-a-node).
+Pour une introduction conviviale pour les débutants, visitez notre page [exécuter un nœud](/run-a-node) pour en savoir plus.
 
-Si vous connaissez mieux la technique, vous pouvez obtenir plus de détails et d'options pour [exécuter votre propre nœud](/developers/docs/nodes-and-clients/run-a-node/).
+Si vous êtes un utilisateur plus technique, plongez dans plus de détails et d'options sur la façon de [lancer votre propre nœud](/developers/docs/nodes-and-clients/run-a-node/).
 
 ## Alternatives {#alternatives}
 
-Mettre en place votre propre nœud peut prendre du temps et nécessiter des ressources, mais vous n'avez pas toujours besoin de faire tourner votre propre instance. Dans ce cas-là, vous pouvez faire appel à un fournisseur de services tiers (API). Pour un aperçu de l'utilisation de ces services, consultez [les nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service/).
+Mettre en place votre propre nœud peut prendre du temps et nécessiter des ressources, mais vous n'avez pas toujours besoin de faire tourner votre propre instance. Dans ce cas-là, vous pouvez faire appel à un fournisseur de services tiers (API). Pour un aperçu de l'utilisation de ces services, consultez la section [nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service/).
 
 Si quelqu'un dans votre communauté venait opérer un noeud Ethereum fonctionnant sous forme d'API ouvertes, vous pouvez utiliser des appels RPC, afin de monter le système de fichiers de l'ordinateur, commun à la chaîne de bloc, sur votre wallet, dans le but de garantir une meilleure protection de votre vie privée que cela ne serait le cas si un tiers de confiance était choisi aléatoirement.
 
@@ -126,28 +130,28 @@ D'autre part, si vous exécutez un client, vous pouvez le partager avec vos amis
 
 ## Clients d'exécution {#execution-clients}
 
-La communauté Ethereum gère plusieurs clients d'exécution open-source (précédemment connus sous le nom de « clients Eth1 » ou simplement « clients Ethereum »), développés par différentes équipes en utilisant différents langages de programmation. Cela rend le réseau plus solide et [diversifié](/developers/docs/nodes-and-clients/client-diversity/). L'idéal est d'atteindre l'objectif de diversité sans qu'aucun client ne prédomine afin de réduire les points de défaillance uniques.
+La communauté Ethereum gère plusieurs clients d'exécution open-source (précédemment connus sous le nom de « clients Eth1 » ou simplement « clients Ethereum »), développés par différentes équipes en utilisant différents langages de programmation. Cela rend le réseau plus fort et plus [diversifié](/developers/docs/nodes-and-clients/client-diversity/). L'idéal est d'atteindre l'objectif de diversité sans qu'aucun client ne prédomine afin de réduire les points de défaillance uniques.
 
-Ce tableau récapitule les différents clients. Tous ont passé [les tests client](https://github.com/ethereum/tests) et sont activement entretenus pour rester à jour grâce aux mises à niveau du réseau.
+Ce tableau récapitule les différents clients. Tous passent les [tests de client](https://github.com/ethereum/tests) et sont activement maintenus pour rester à jour avec les mises à niveau du réseau.
 
-| Client                                                                   | Langage    | Systèmes d'exploitation | Réseaux                            | Stratégies de synchronisation                                       | Élagage d'état  |
-| ------------------------------------------------------------------------ | ---------- | ----------------------- | ---------------------------------- | ------------------------------------------------------------------- | --------------- |
-| [Geth](https://geth.ethereum.org/)                                       | Go         | Linux, Windows, macOS   | Réseau principal, Sepolia, Holesky | [capture](#snap-sync), [complet](#full-sync)                        | Archive, élagué |
-| [Nethermind](https://www.nethermind.io/)                                 | C#, .NET   | Linux, Windows, macOS   | Réseau principal, Sepolia, Holesky | [capture](#snap-sync) (sans service), rapide, [complet](#full-sync) | Archive, élagué |
-| [Besu](https://besu.hyperledger.org/en/stable/)                          | Java       | Linux, Windows, macOS   | Réseau principal, Sepolia, Holesky | [capture](#snap-sync), [rapide](#fast-sync), [complet](#full-sync)  | Archive, élagué |
-| [Erigon](https://github.com/ledgerwatch/erigon)                          | Go         | Linux, Windows, macOS   | Réseau principal, Sepolia, Holesky | [Totale](#full-sync)                                                | Archive, élagué |
-| [Reth](https://reth.rs/)                                                 | Rust       | Linux, Windows, macOS   | Réseau principal, Sepolia, Holesky | [Totale](#full-sync)                                                | Archive, élagué |
-| [EthereumJS](https://github.com/ethereumjs/ethereumjs-monorepo) _(bêta)_ | TypeScript | Linux, Windows, macOS   | Sepolia, Holesky                   | [Totale](#full-sync)                                                | Élagué          |
+| Client                                                                                      | Langue                   | Systèmes d'exploitation | Les réseaux                       | Stratégies de synchronisation                                                             | élagage d'état  |
+| ------------------------------------------------------------------------------------------- | ------------------------ | ----------------------- | --------------------------------- | ----------------------------------------------------------------------------------------- | --------------- |
+| [Geth](https://geth.ethereum.org/)                                                          | Go                       | Linux, Windows, macOS   | Réseau principal, Sepolia, Goerli | [Instantané](#snap-sync), [Complet](#full-sync)                                           | Archive, élagué |
+| [Nethermind](https://www.nethermind.io/)                                                    | C#, .NET | Linux, Windows, macOS   | Réseau principal, Sepolia, Goerli | [Instantané](#snap-sync) (sans service), Rapide, [Complet](#full-sync) | Archive, élagué |
+| [Besu](https://besu.hyperledger.org/en/stable/)                                             | Java                     | Linux, Windows, macOS   | Réseau principal, Sepolia, Goerli | [Instantané](#snap-sync), [Rapide](#fast-sync), [Complet](#full-sync)                     | Archive, élagué |
+| [Erigon](https://github.com/ledgerwatch/erigon)                                             | Go                       | Linux, Windows, macOS   | Réseau principal, Sepolia, Goerli | [Complet](#full-sync)                                                                     | Archive, élagué |
+| [Reth](https://reth.rs/)                                                                    | Rust                     | Linux, Windows, macOS   | Réseau principal, Sepolia, Goerli | [Complet](#full-sync)                                                                     | Archive, élagué |
+| [EthereumJS](https://github.com/ethereumjs/ethereumjs-monorepo) _(bêta)_ | TypeScript               | Linux, Windows, macOS   | Sepolia, Holesky                  | [Complet](#full-sync)                                                                     | Élagué          |
 
-Pour plus d'information sur les réseaux pris en charge, lisez la page [Réseaux Ethereum](/developers/docs/networks/).
+Pour en savoir plus sur les réseaux pris en charge, consultez la page sur les [réseaux Ethereum](/developers/docs/networks/).
 
 Chaque client est utilisé à des fins uniques et présente des avantages particuliers. Vous devez donc en choisir un en fonction de vos propres préférences. La diversité permet de concentrer les implémentations sur des fonctionnalités et des utilisateurs distincts. Vous pouvez choisir un client en fonction de ses fonctionnalités, de son support, de son langage de programmation ou de ses licences.
 
 ### Besu {#besu}
 
-Hyperledger Besu est un client Ethereum de niveau entreprise pour les réseaux autorisés. Il exécute toutes les fonctionnalités du réseau principal Ethereum, du traçage à GraphQL, dispose d'une surveillance étendue et est pris en charge par ConsenSys, à la fois dans les canaux communautaires ouverts et par le biais de SLA commerciaux pour les entreprises. Il est écrit en Java et se trouve sous licence Apache 2.0.
+Hyperledger Besu est un client Ethereum de niveau entreprise pour les réseaux autorisés. Il exécute toutes les fonctionnalités du réseau principal Ethereum, du traçage à GraphQL, dispose d'une surveillance étendue et est pris en charge par ConsenSys, à la fois sur les canaux communautaires ouverts et par le biais de SLA commerciaux destinés aux entreprises. Il est écrit en Java et se trouve sous licence Apache 2.0.
 
-La [documentation](https://besu.hyperledger.org/en/stable/) complète de Besu vous donnera plus de détails sur ses fonctionnalités et sa configuration.
+La [documentation](https://besu.hyperledger.org/en/stable/) complète de Besu vous guidera à travers tous les détails de ses fonctionnalités et de ses configurations.
 
 ### Erigon {#erigon}
 
@@ -157,7 +161,7 @@ Erigon, anciennement connu sous le nom de Turbo-Geth, est une fourche de Go Ethe
 
 Go Ethereum (ou Geth, en abrégé) est l'une des implémentations initiales du protocole Ethereum. Il s'agit actuellement du client le plus répandu. Il offre la plus grande base d'utilisateurs et la plus grande variété d'outils aux utilisateurs et développeurs. Il est rédigé en Go, entièrement open source et sous licence GNU LGPL v3.
 
-En savoir plus sur Geth grâce à sa [documentation](https://geth.ethereum.org/docs/).
+En savoir plus sur Geth dans sa [documentation](https://geth.ethereum.org/docs/).
 
 ### Nethermind {#nethermind}
 
@@ -167,7 +171,7 @@ Nethermind est une implémentation d'Ethereum créée avec la pile technologique
 - un accès à l'état ;
 - mise en réseau et fonctionnalités avancées comme les tableaux de bord Prometheus/Grafana, la prise en charge de la journalisation d'entreprise seq, le traçage RPC-JSON et les plugins d'analyse.
 
-Nethermind dispose également d'[une documentation détaillée](https://docs.nethermind.io), d'un solide support de développement, d'une communauté en ligne et d'une assistance 24h/24 et 7j/7 offerte aux utilisateurs premium.
+Nethermind dispose également d'une [documentation détaillée](https://docs.nethermind.io), d'un solide support pour les développeurs, d'une communauté en ligne et d'une assistance 24h/24 et 7j/7 disponible pour les utilisateurs premium.
 
 ### Reth {#reth}
 
@@ -175,7 +179,7 @@ Reth (abréviation de Rust Ethereum) est une implémentation de nœud complet Et
 
 Reth est opérationnel et convient à une utilisation dans des environnements critiques, tels que la mise en jeu ou les services nécessitant une haute disponibilité. Fonctionne bien dans les cas d'utilisation où des performances élevées avec de grandes marges sont requises, telles que RPC, MEC, l'indexation, les simulations et les activités P2P.
 
-Pour en savoir plus, consultez la [documentation de Reth](https://reth.rs/) ou le [dépôt GitHub de Reth](https://github.com/paradigmxyz/reth?tab=readme-ov-file#reth).
+Pour en savoir plus, consultez le [Livre Reth](https://reth.rs/) ou le [dépôt GitHub de Reth](https://github.com/paradigmxyz/reth?tab=readme-ov-file#reth).
 
 ### En développement {#execution-in-development}
 
@@ -185,52 +189,52 @@ Ces clients en sont encore aux premiers stades de développement et ne sont pas
 
 Le client d'execution EthereumJS (EthereumJS) est écrit en Typescript et composé d'un certain nombre de paquets, y compris les primitives de base Ethereum représentées par les classes Block, Transaction et Arbre de Merkle Patricia et les composants clients principaux, y compris une implémentation de la machine virtuelle Ethereum (EVM), une classe blockchain et la pile réseau DevP2P.
 
-Pour en savoir plus, lisez sa [documentation](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master)
+Apprenez-en davantage en lisant sa [documentation](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master)
 
 ## Clients de consensus {#consensus-clients}
 
-De nombreux clients de consensus (précédemment connus sous le nom de clients 'Eth2') prennent en charge les [mises à niveau du consensus](/roadmap/beacon-chain/). Ils sont responsables de toute la logique liée au consensus, y compris l'algorithme de choix de fourche, le traitement des attestations et la gestion des récompenses et des pénalités de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos).
+Il existe plusieurs clients de consensus (précédemment appelés clients « Eth2 ») pour prendre en charge les [mises à niveau du consensus](/roadmap/beacon-chain/). Ils sont responsables de toute la logique liée au consensus, y compris l'algorithme de choix de la fourche, le traitement des attestations et la gestion des récompenses et pénalités de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos).
 
-| Client                                                        | Langage    | Systèmes d'exploitation | Réseaux                                                         |
+| Client                                                        | Langue     | Systèmes d'exploitation | Les réseaux                                                     |
 | ------------------------------------------------------------- | ---------- | ----------------------- | --------------------------------------------------------------- |
-| [Lighthouse](https://lighthouse.sigmaprime.io/)               | Rust       | Linux, Windows, macOS   | Beacon Chain, Holesky, Pyrmont, Sepolia, et plus encore         |
-| [Lodestar](https://lodestar.chainsafe.io/)                    | TypeScript | Linux, Windows, macOS   | Beacon Chain, Holesky, Sepolia, et plus encore                  |
-| [Nimbus](https://nimbus.team/)                                | Nim        | Linux, Windows, macOS   | Beacon Chain, Holesky, Sepolia, et plus encore                  |
-| [Prysm](https://prysm.offchainlabs.com/docs/)   | Go         | Linux, Windows, macOS   | Beacon Chain, Gnosis, Holesky, Pyrmont, Sepolia, et plus encore |
-| [Teku](https://consensys.net/knowledge-base/ethereum-2/teku/) | Java       | Linux, Windows, macOS   | Beacon Chain, Gnosis, Holesky, Sepolia, et plus encore          |
-| [Grandine](https://docs.grandine.io/)                         | Rust       | Linux, Windows, macOS   | Beacon Chain, Holesky, Sepolia, et plus encore                  |
+| [Lighthouse](https://lighthouse.sigmaprime.io/)               | Rust       | Linux, Windows, macOS   | Chaîne phare, Holesky, Pyrmont, Sepolia, et plus encore         |
+| [Lodestar](https://lodestar.chainsafe.io/)                    | TypeScript | Linux, Windows, macOS   | Chaîne phare, Goerli, Sepolia, et plus encore                   |
+| [Nimbus](https://nimbus.team/)                                | Nim        | Linux, Windows, macOS   | Chaîne phare, Goerli, Sepolia, et plus encore                   |
+| [Prysm](https://prysm.offchainlabs.com/docs/)                 | Go         | Linux, Windows, macOS   | Chaîne phare, Gnosis, Holesky, Pyrmont, Sepolia, et plus encore |
+| [Teku](https://consensys.net/knowledge-base/ethereum-2/teku/) | Java       | Linux, Windows, macOS   | Chaîne phare, Gnosis, Holesky, Sepolia, et plus encore          |
+| [Grandine](https://docs.grandine.io/)                         | Rust       | Linux, Windows, macOS   | Chaîne phare, Goerli, Sepolia, et plus encore                   |
 
 ### Lighthouse {#lighthouse}
 
 Lighthouse est une implémentation de client de consensus écrite en Rust sous la licence Apache-2.0. Mise à niveau par Sigma Prime, elle est stable et prête à la production depuis la genèse de la Chaîne phare. Diverses entreprises, groupes d'enjeux et particuliers l'utilisent. Elle se veut sécurisée, performante et interopérable dans un large éventail d'environnements allant des PC de bureau aux déploiements automatisés de pointe.
 
-La documentation est disponible dans le [Livre Lighthouse](https://lighthouse-book.sigmaprime.io/)
+La documentation se trouve dans le [Livre Lighthouse](https://lighthouse-book.sigmaprime.io/)
 
 ### Lodestar {#lodestar}
 
 Lodestar est une implémentation de client de consensus prête à la production, écrite en Typescript sous la licence LGPL-3.0. Mise à jour par ChainSafe Systems, elle constitue le plus récent des clients de consensus pour les validateurs individuels, les développeurs et les chercheurs. Lodestar est composé d'un nœud phare et d'un client validateur utilisant des implémentations JavaScript des protocoles Ethereum. Lodestar vise à améliorer la convivialité d'Ethereum auprès des clients légers, à étendre l'accessibilité à un plus grand groupe de développeurs et à contribuer davantage à la diversité des écosystèmes.
 
-De plus amples informations sont disponibles sur notre site [Lodestar](https://lodestar.chainsafe.io/)
+Plus d'informations sont disponibles sur le [site web de Lodestar](https://lodestar.chainsafe.io/)
 
 ### Nimbus {#nimbus}
 
 Nimbus est une implémentation de client de consensus écrite en Nim sous la licence Apache-2.0. Il s'agit d'un client prêt à la production utilisé par les validateurs individuels et les groupes de mise en jeu. Nimbus est conçu pour favoriser l'efficacité des ressources, ce qui le rend facile à utiliser sur des appareils disposant de ressources limitées ou sur des infrastructures d'entreprise sans compromettre la stabilité ou les performances de récompense. Une empreinte plus légère en termes de ressources signifie que le client a une plus grande marge de sécurité lorsque le réseau est sollicité.
 
-En savoir plus avec la [Documentation de Nimbus](https://nimbus.guide/)
+En savoir plus dans la [documentation de Nimbus](https://nimbus.guide/)
 
 ### Prysm {#prysm}
 
 Prysm est un client de consensus open source complet écrit en Go sous la licence GPL-3.0. Il dispose d'une interface utilisateur optionnelle et donne la priorité à l'expérience utilisateur, à la documentation et à la configurabilité, tant pour les utilisateurs particuliers qu'institutionnels.
 
-Consultez [la documentation Prysm](https://prysm.offchainlabs.com/docs/) pour en savoir plus.
+Visitez la [documentation de Prysm](https://prysm.offchainlabs.com/docs/) pour en savoir plus.
 
 ### Teku {#teku}
 
 Teku est l'un des clients originaux de la genèse de la Chaine Phare. En plus des objectifs habituels (sécurité, robustesse, stabilité, facilité d'utilisation, performance), Teku vise spécifiquement à respecter pleinement toutes les normes du client de consensus.
 
-Teku offre des options de déploiement très flexibles. Le nœud phare et le client de validation peuvent être exécutés ensemble dans le cadre d'un seul processus, ce qui est extrêmement pratique pour les validateurs individuels. Les nœuds peuvent également être exécutés séparément pour des opérations de mise en jeu sophistiquées. En outre, Teku est entièrement compatible avec [Web3Signer](https://github.com/ConsenSys/web3signer/) s'agissant de sécuriser les clés de signature et de les protéger contre les délestages.
+Teku offre des options de déploiement très flexibles. Le nœud phare et le client de validation peuvent être exécutés ensemble dans le cadre d'un seul processus, ce qui est extrêmement pratique pour les validateurs individuels. Les nœuds peuvent également être exécutés séparément pour des opérations de mise en jeu sophistiquées. De plus, Teku est entièrement interopérable avec [Web3Signer](https://github.com/ConsenSys/web3signer/) pour la sécurité des clés de signature et la protection contre le slashing.
 
-Teku est écrit en Java et est disponible sous licence Apache 2.0. Il est développé par l'équipe de protocoles de ConsenSys qui est également responsable de Besu et Web3Signer. Pour en savoir plus, consultez la documentation [Teku](https://docs.teku.consensys.net/en/latest/).
+Teku est écrit en Java et est disponible sous licence Apache 2.0. Il est développé par l'équipe de protocoles de ConsenSys qui est également responsable de Besu et Web3Signer. En savoir plus dans la [documentation de Teku](https://docs.teku.consensys.net/en/latest/).
 
 ### Grandine {#grandine}
 
@@ -280,7 +284,7 @@ Le mode client léger permet de télécharger tous les en-têtes de bloc, les do
 - Ne récupère que les derniers états en s'appuyant sur la confiance dans les développeurs et le mécanisme de consensus.
 - Le client est prêt à être utilisé avec l'état actuel du réseau en quelques minutes.
 
-**NB** La synchronisation légère ne fonctionne pas encore avec la version preuve d'enjeu d'Ethereum - de nouvelles versions prenant en charge la synchronisation légère devraient être bientôt disponibles !
+**N.B.** La synchronisation légère ne fonctionne pas encore avec l'Ethereum à preuve d'enjeu - de nouvelles versions de la synchronisation légère devraient bientôt être disponibles !
 
 [En savoir plus sur les clients légers](/developers/docs/nodes-and-clients/light-clients/)
 
@@ -288,22 +292,22 @@ Le mode client léger permet de télécharger tous les en-têtes de bloc, les do
 
 #### Synchronisation optimiste {#optimistic-sync}
 
-La synchronisation optimiste est une stratégie de synchronisation post-fusion conçue pour être opt-in et rétrocompatible. Elle permet à des nœuds d'exécution de se synchroniser via des méthodes reconnues. Le moteur d'exécution peut importer _de manière optimiste_ des blocs phares sans les vérifier complètement, trouver la dernière tête, puis commencer à synchroniser la chaîne en utilisant les méthodes ci-dessus. Ensuite, une fois le client d'exécution mis à jour, il informe le client de consensus de la validité des transactions sur la Chaîne phare.
+La synchronisation optimiste est une stratégie de synchronisation post-fusion conçue pour être opt-in et rétrocompatible. Elle permet à des nœuds d'exécution de se synchroniser via des méthodes reconnues. Le moteur d'exécution peut importer _de manière optimiste_ les blocs balises sans les vérifier complètement, trouver l'en-tête le plus récent, puis commencer à synchroniser la chaîne avec les méthodes ci-dessus. Ensuite, une fois le client d'exécution mis à jour, il informe le client de consensus de la validité des transactions sur la Chaîne phare.
 
 [En savoir plus sur la synchronisation optimiste](https://github.com/ethereum/consensus-specs/blob/master/sync/optimistic.md)
 
-#### Synchronisation des points de contrôle {#checkpoint-sync}
+#### Synchronisation par point de contrôle {#checkpoint-sync}
 
-La synchronisation des points de contrôle, également connue sous le nom de synchronisation à faible subjectivité, génère une expérience utilisateur supérieure pour la synchronisation du Nœud Phare. Elle est basée sur des hypothèses de [faible subjectivité](/developers/docs/consensus-mechanisms/pos/weak-subjectivity/) qui permettent de synchroniser la Chaîne phare à partir d'un point de contrôle de faible subjectivité récent plutôt que de la genèse. La synchronisation des points de contrôle réduit sensiblement le temps de synchronisation initiale avec des hypothèses de confiance similaires à la synchronisation effectuée à partir de la [genèse](/glossary/#genesis-block).
+La synchronisation des points de contrôle, également connue sous le nom de synchronisation à faible subjectivité, génère une expérience utilisateur supérieure pour la synchronisation du Nœud Phare. Elle est basée sur des hypothèses de [faible subjectivité](/developers/docs/consensus-mechanisms/pos/weak-subjectivity/) qui permettent de synchroniser la Chaîne phare à partir d'un point de contrôle de faible subjectivité récent au lieu de la genèse. Les synchronisations par point de contrôle rendent le temps de synchronisation initial beaucoup plus rapide avec des hypothèses de confiance similaires à la synchronisation à partir de la [genèse](/glossary/#genesis-block).
 
 En pratique, cela signifie que votre nœud se connecte à un service à distance pour télécharger les états finalisés récents et continue de vérifier les données à partir de ce point. Les tiers qui fournissent les données sont de confiance et doivent être soigneusement sélectionnés.
 
-En savoir plus sur [la synchronisation des points de contrôle](https://notes.ethereum.org/@djrtwo/ws-sync-in-practice)
+En savoir plus sur la [synchronisation par point de contrôle](https://notes.ethereum.org/@djrtwo/ws-sync-in-practice)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Le B-A-BA de l'Ethereum, 2e partie - Comprendre les nœuds](https://kauri.io/ethereum-101-part-2-understanding-nodes/48d5098292fd4f11b251d1b1814f0bba/a) _- Wil Barnes, 13 février 2019_
-- [Running Ethereum Full Nodes: A Guide for the Barely Motivated](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 novembre 2019_
+- [Ethereum 101 - 2e partie - Comprendre les nœuds](https://kauri.io/ethereum-101-part-2-understanding-nodes/48d5098292fd4f11b251d1b1814f0bba/a) _– Wil Barnes, 13 février 2019_
+- [Exécuter des nœuds complets Ethereum : un guide pour les moins motivés](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 novembre 2019_
 
 ## Sujets connexes {#related-topics}
 
@@ -312,4 +316,4 @@ En savoir plus sur [la synchronisation des points de contrôle](https://notes.et
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Transformez votre Raspberry Pi 4 en nœud de validateur en flashant une carte MicroSD – Le guide d'installation](/developers/tutorials/run-node-raspberry-pi/) _– Flashez votre Raspberry Pi 4, branchez un cable ethernet, connectez le disque SSD et alimentez l'appareil pour transformer votre Raspberry Pi 4 en un nœud Ethereum complet exécutant la couche d'exécution (réseau principal) et/ou la couche de consensus (Chaine Phare / Validateur)._
+- [Transformez votre Raspberry Pi 4 en nœud de validateur en flashant simplement la carte MicroSD – Guide d'installation](/developers/tutorials/run-node-raspberry-pi/) _– Flashez votre Raspberry Pi 4, branchez un câble Ethernet, connectez le disque SSD et mettez l'appareil sous tension pour transformer le Raspberry Pi 4 en un nœud Ethereum complet exécutant la couche d'exécution (réseau principal) et/ou la couche de consensus (Chaîne phare / validateur)._
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/light-clients/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/light-clients/index.md
index 7f4b6bcd4b2..e3ab2009400 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/light-clients/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/light-clients/index.md
@@ -1,6 +1,6 @@
 ---
-title: Clients légers
-description: Introduction aux clients légers Ethereum.
+title: "Clients légers"
+description: "Introduction aux clients légers Ethereum."
 lang: fr
 ---
 
@@ -12,7 +12,7 @@ Un nœud léger est un nœud exécutant un logiciel client léger. Au lieu de co
 
 ## Comment fonctionnent les clients légers ? {#how-do-light-clients-work}
 
-Lorsque Ethereum a commencé à utiliser un mécanisme de consensus basé sur la preuve d'enjeu, une nouvelle infrastructure a été introduite spécifiquement pour prendre en charge les clients légers. Le système fonctionne en sélectionnant au hasard un sous-ensemble de 512 validateurs tous les 1,1 jour pour agir en tant que **comité de synchronisation**. Le comité de synchronisation signe l'en-tête des blocs récents. Chaque en-tête de bloc contient la signature agrégée des validateurs du comité de synchronisation et un « champ de bits » qui indique les validateurs qui ont signé et ceux qui n'ont pas signé. Chaque en-tête comprend également une liste de validateurs censés participer à la signature du bloc suivant. Cela signifie qu'un client léger peut rapidement voir que le comité de synchronisation a approuvé les données qu'il reçoit, et il peut également vérifier que le comité de synchronisation est le bon en comparant les données qu'il reçoit à celles qu'on lui a dit d'attendre dans le bloc précédent. De cette façon, le client léger peut continuer à mettre à jour sa connaissance du dernier bloc Ethereum sans télécharger le bloc lui-même, mais seulement l'en-tête contenant des informations sommaires.
+Lorsque Ethereum a commencé à utiliser un mécanisme de consensus basé sur la preuve d'enjeu, une nouvelle infrastructure a été introduite spécifiquement pour prendre en charge les clients légers. Le système fonctionne en sélectionnant au hasard un sous-ensemble de 512 validateurs tous les 1,1 jours pour agir en tant que **comité de synchronisation**. Le comité de synchronisation signe l'en-tête des blocs récents. Chaque en-tête de bloc contient la signature agrégée des validateurs du comité de synchronisation et un "champ de bits" qui indique quels validateurs ont signé et lesquels ne l'ont pas fait. Chaque en-tête comprend également une liste de validateurs censés participer à la signature du bloc suivant. Cela signifie qu'un client léger peut rapidement voir que le comité de synchronisation a approuvé les données qu'il reçoit, et il peut également vérifier que le comité de synchronisation est le bon en comparant les données qu'il reçoit à celles qu'on lui a dit d'attendre dans le bloc précédent. De cette façon, le client léger peut continuer à mettre à jour sa connaissance du dernier bloc Ethereum sans télécharger le bloc lui-même, mais seulement l'en-tête contenant des informations sommaires.
 
 Au niveau de la couche d'exécution, il n'existe pas de spécification unique pour un client d'exécution léger. La portée d'un client d'exécution légère peut varier d'un « mode léger » d'un client d'exécution complète qui dispose de toutes les fonctionnalités EVM et réseau d'un nœud complet, mais qui vérifie uniquement les en-têtes de blocs, sans télécharger les données associées, ou il peut s'agir d'un client plus simple qui s'appuie fortement sur la transmission de demandes à un fournisseur RPC pour interagir avec Ethereum.
 
@@ -32,7 +32,7 @@ L'avantage principal des clients légers est de permettre à un plus grand nombr
 
 La possibilité d'exécuter des nœuds Ethereum sur des appareils dotés d'une capacité de stockage, d'une mémoire et d'une puissance de traitement très faibles est l'un des principaux domaines d'innovation rendus possibles par les clients légers. Alors qu'aujourd'hui les nœuds Ethereum nécessitent beaucoup de ressources informatiques, les clients légers pourraient être intégrés dans des navigateurs, fonctionner sur des téléphones portables et peut-être même sur des appareils plus petits tels que des montres intelligentes. Cela signifie que les portefeuilles Ethereum avec des clients intégrés pourraient fonctionner sur un téléphone portable. Les portefeuilles mobiles pourraient donc être beaucoup plus décentralisés, car ils n'auraient pas à faire confiance à des fournisseurs de données centralisés pour leurs données.
 
-L'activation des dispositifs de **l'internet des objets (IoT)** est une extension de ce principe. Un client léger pourrait être utilisé pour rapidement prouver la propriété d'un solde de jetons ou encore d'un NFT, avec toutes les garanties de sécurité fournies par les comités de synchronisation, déclenchant une action sur un réseau IoT. Imaginez un [service de location de vélos](https://youtu.be/ZHNrAXf3RDE?t=929) qui utilise une application avec un client léger embarqué pour vérifier rapidement que vous possédez bien le NFT du service de location, et si c'est le cas, débloque un vélo sur lequel vous pourriez filer !
+Une extension de ceci est la prise en charge des appareils de l'**internet des objets (IoT)**. Un client léger pourrait être utilisé pour rapidement prouver la propriété d'un solde de jetons ou encore d'un NFT, avec toutes les garanties de sécurité fournies par les comités de synchronisation, déclenchant une action sur un réseau IoT. Imaginez un [service de location de vélos](https://youtu.be/ZHNrAXf3RDE?t=929) qui utilise une application avec un client léger intégré pour vérifier rapidement que vous possédez bien le NFT du service de location et, si c'est le cas, déverrouiller un vélo pour que vous puissiez l'utiliser !
 
 Les rollups Ethereum bénéficieraient également des clients légers. L'un des grands problèmes pour les rollups a été les attaques ciblant les ponts qui permettent le transfert de fonds d'Ethereum vers un rollup. Une vulnérabilité concerne les oracles que les rollups utilisent pour détecter qu'un utilisateur a effectué un dépôt dans le pont. Si un oracle fournit de mauvaises données, il pourrait tromper le rollup en lui faisant croire qu'il y a eu un dépôt sur le pont et libérer incorrectement des fonds. Un client léger intégré dans le rollup pourrait être utilisé pour se protéger contre les oracles corrompus car le dépôt dans le pont pourrait venir avec une preuve qui peut être vérifiée par le rollup avant de libérer des jetons. Le même concept pourrait également être appliqué à d'autres ponts interchaînes.
 
@@ -43,19 +43,19 @@ Les clients légers pourraient également être utilisés pour mettre les portef
 Il existe plusieurs clients légers en développement, notamment des clients légers d'exécution, de consensus et des clients légers combinant exécution et consensus. Voici les implémentations de clients légers que nous connaissons au moment de la rédaction de cette page :
 
 - [Lodestar](https://github.com/ChainSafe/lodestar/tree/unstable/packages/light-client) : client léger de consensus en TypeScript
-- [Helios](https://github.com/a16z/helios) : client léger combinant les tâches d'exécution et de consensus en Rust
+- [Helios](https://github.com/a16z/helios) : client léger combiné d'exécution et de consensus en Rust
 - [Geth](https://github.com/ethereum/go-ethereum/tree/master/beacon/light) : mode léger pour le client d'exécution (en développement) en Go
 - [Nimbus](https://nimbus.guide/el-light-client.html) : client léger de consensus en Nim
 
 À notre connaissance, aucun de ces clients n'est encore considéré comme prêt pour être utilisé.
 
-Il y a aussi beaucoup de travail en cours pour améliorer l'accès des clients légers aux données Ethereum. Actuellement, les clients légers s'appuient sur des demandes RPC vers des nœuds complets en utilisant un modèle client/serveur, mais à l'avenir, les données pourraient être demandées de manière plus décentralisée en utilisant un réseau dédié tel que le [Réseau Portal](https://www.ethportal.net/) qui pourrait fournir les données aux clients légers en utilisant un protocole de bavardage pair à pair.
+Il y a aussi beaucoup de travail en cours pour améliorer l'accès des clients légers aux données Ethereum. Actuellement, les clients légers s'appuient sur des requêtes RPC vers des nœuds complets en utilisant un modèle client/serveur, mais à l'avenir, les données pourraient être demandées de manière plus décentralisée en utilisant un réseau dédié tel que le [Réseau Portal](https://www.ethportal.net/) qui pourrait servir les données aux clients légers en utilisant un protocole de bavardage pair-à-pair.
 
-D'autres éléments de la [feuille de route](/roadmap/) tels que les [arbres Verkle](/roadmap/verkle-trees/) et l'[absence d'état](/roadmap/statelessness/) apporteront finalement les garanties de sécurité des clients légers équivalentes à celles des clients complets.
+D'autres éléments de la [feuille de route](/roadmap/) tels que les [arbres Verkle](/roadmap/verkle-trees/) et l'[absence d'état](/roadmap/statelessness/) finiront par rendre les garanties de sécurité des clients légers égales à celles des clients complets.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Zsolt Felföldi sur les clients légers Geth](https://www.youtube.com/watch?v=EPZeFXau-RE)
-- [Etan Kissling sur le réseau des clients légers](https://www.youtube.com/watch?v=85MeiMA4dD8)
+- [Zsolt Felfodhi sur les clients légers Geth](https://www.youtube.com/watch?v=EPZeFXau-RE)
+- [Etan Kissling sur la mise en réseau des clients légers](https://www.youtube.com/watch?v=85MeiMA4dD8)
 - [Etan Kissling sur les clients légers après La Fusion](https://www.youtube.com/watch?v=ZHNrAXf3RDE)
-- [Piper Merriam : Le chemin sinueux vers les clients légers opérationnels](https://snakecharmers.ethereum.org/the-winding-road-to-functional-light-clients/)
+- [Piper Merriam : Le chemin sinueux vers des clients légers fonctionnels](https://snakecharmers.ethereum.org/the-winding-road-to-functional-light-clients/)
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/node-architecture/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/node-architecture/index.md
index a6adc5973b0..7692ac8f322 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/node-architecture/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/node-architecture/index.md
@@ -1,12 +1,12 @@
 ---
 title: Architecture du noeud
-description: Introduction à l'organisation des nœuds Ethereum.
+description: "Introduction à l'organisation des nœuds Ethereum."
 lang: fr
 ---
 
-Un nœud Ethereum est composé de deux clients : un [client d'exécution](/developers/docs/nodes-and-clients/#execution-clients) et un [client de consensus](/developers/docs/nodes-and-clients/#consensus-clients). Pour qu’un nœud propose un nouveau bloc, il doit également exécuter un [client validateur](#validators).
+Un nœud Ethereum est composé de deux clients : un [client d'exécution](/developers/docs/nodes-and-clients/#execution-clients) et un [client de consensus](/developers/docs/nodes-and-clients/#consensus-clients). Pour qu'un nœud propose un nouveau bloc, il doit également exécuter un [client validateur](#validators).
 
-Lorsque Ethereum utilisait la [preuve de travail](/developers/docs/consensus-mechanisms/pow/), un client d'exécution était suffisant pour exécuter un nœud Ethereum complet. Cependant, depuis la mise en œuvre de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pow/), le client d'exécution doit être utilisé en parallèle avec un autre logiciel appelé [« client de consensus »](/developers/docs/nodes-and-clients/#consensus-clients).
+Lorsque Ethereum utilisait la [preuve de travail](/developers/docs/consensus-mechanisms/pow/), un client d'exécution était suffisant pour exécuter un nœud Ethereum complet. Cependant, depuis la mise en œuvre de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pow/), le client d'exécution doit être utilisé avec un autre logiciel appelé [client de consensus](/developers/docs/nodes-and-clients/#consensus-clients).
 
 Le diagramme ci-dessous montre la relation entre les deux clients Ethereum. Les deux clients se connectent à leurs propres réseaux peer-to-peer (P2P) respectifs. Des réseaux P2P séparés sont nécessaires car les clients d'exécution propagent les transactions sur leur réseau P2P, leur permettant de gérer leur pool de transactions local, tandis que les clients de consensus propagent les blocs sur leur réseau P2P, permettant le consensus et l'accroissement de la chaîne.
 
@@ -14,15 +14,15 @@ Le diagramme ci-dessous montre la relation entre les deux clients Ethereum. Les
 
 _Il existe plusieurs options pour le client d’exécution, notamment Erigon, Nethermind et Besu_.
 
-Pour que cette structure à deux clients fonctionne, les clients de consensus doivent être en mesure de transmettre des paquets de transactions au client d'exécution. Le client d’exécution exécute les transactions localement afin de vérifier qu’elles ne violent aucune règle d’Ethereum et que la mise à jour proposée de l’état d’Ethereum est correcte. Lorsqu’un nœud est sélectionné pour devenir producteur de blocs, son instance de client de consensus demande au client d’exécution des lots de transactions à inclure dans le nouveau bloc, puis les exécute afin de mettre à jour l’état global. Le client de consensus pilote le client d’exécution via une connexion RPC locale en utilisant l’[API Engine](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md).
+Pour que cette structure à deux clients fonctionne, les clients de consensus doivent être en mesure de transmettre des paquets de transactions au client d'exécution. Le client d’exécution exécute les transactions localement afin de vérifier qu’elles ne violent aucune règle d’Ethereum et que la mise à jour proposée de l’état d’Ethereum est correcte. Lorsqu’un nœud est sélectionné pour devenir producteur de blocs, son instance de client de consensus demande au client d’exécution des lots de transactions à inclure dans le nouveau bloc, puis les exécute afin de mettre à jour l’état global. Le client de consensus pilote le client d'exécution via une connexion RPC locale en utilisant l'[API Engine](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md).
 
 ## Que fait le client d'exécution ? {#execution-client}
 
-Le client d’exécution est responsable de la validation, du traitement et de la propagation des transactions, ainsi que de la gestion de l’état et du support de la Machine Virtuelle Ethereum ([EVM](/developers/docs/evm/)). Il n'est **pas** responsable de la construction de blocs, de leur propagation ou de la gestion de la logique de consensus. Ces responsabilités relèvent du client de consensus.
+Le client d'exécution est responsable de la validation, du traitement et de la propagation des transactions, ainsi que de la gestion de l'état et du support de la Machine Virtuelle Ethereum ([EVM](/developers/docs/evm/)). Il n'est **pas** responsable de la construction des blocs, de leur propagation ou de la gestion de la logique du consensus. Ces responsabilités relèvent du client de consensus.
 
-Le client d'exécution crée des charges utiles d'exécution - la liste des transactions, la trie d'état mise à jour, et d'autres données liées à l'exécution. Les clients de consensus incluent la charge utile d'exécution dans chaque bloc. Le client d'exécution est également responsable de réexécuter les transactions dans les nouveaux blocs pour s'assurer qu'elles sont valides. L'exécution des transactions est effectuée sur l'ordinateur intégré du client d'exécution, connu sous le nom de [Machine Virtuelle Ethereum (EVM)](/developers/docs/evm).
+Le client d'exécution crée des charges utiles d'exécution - la liste des transactions, la trie d'état mise à jour, et d'autres données liées à l'exécution. Les clients de consensus incluent la charge utile d'exécution dans chaque bloc. Le client d'exécution est également responsable de réexécuter les transactions dans les nouveaux blocs pour s'assurer qu'elles sont valides. L'exécution des transactions s'effectue sur l'ordinateur intégré du client d'exécution, connu sous le nom de [Machine Virtuelle Ethereum (EVM)](/developers/docs/evm).
 
-Le client d'exécution offre également une interface utilisateur pour Ethereum via la [fonction RPC](/developers/docs/apis/json-rpc) qui permet aux utilisateurs de consulter la blockchain Ethereum, de soumettre des transactions et de déployer des contrats intelligents. Il est courant que les appels RPC soient gérés par une bibliothèque telle que [Web3js](https://docs.web3js.org/), [Web3py](https://web3py.readthedocs.io/en/v5/), ou par une interface utilisateur telle qu'un portefeuille de navigateur.
+Le client d'exécution offre également une interface utilisateur pour Ethereum via des [méthodes RPC](/developers/docs/apis/json-rpc) qui permettent aux utilisateurs d'interroger la blockchain Ethereum, de soumettre des transactions et de déployer des contrats intelligents. Il est courant que les appels RPC soient gérés par une bibliothèque comme [Web3js](https://docs.web3js.org/) ou [Web3py](https://web3py.readthedocs.io/en/v5/), ou par une interface utilisateur telle qu'un portefeuille de navigateur.
 
 En résumé, le client d'exécution est :
 
@@ -39,21 +39,21 @@ Le client de consensus ne participe pas à l'attestation ou à la proposition de
 
 La mise en jeu et l’exécution du logiciel de validation font qu'un nœud peut être sélectionné pour proposer un nouveau bloc. Les opérateurs de nœuds peuvent ajouter un validateur à leurs clients de consensus en déposant 32 ETH dans le contrat de dépôt. Le client de validation inclut le client de consensus et peut être ajouté à un nœud à tout moment. Le validateur gère les attestations et les propositions de blocs. Cela permet également à un nœud d’accumuler des récompenses ou de perdre de l’ETH via des pénalités ou des sanctions.
 
-[En savoir plus sur les mises](/staking/).
+[En savoir plus sur le staking](/staking/).
 
 ## Comparaison des composants d'un nœud {#node-comparison}
 
-| Client d'exécution                                 | Client de consensus                                                        | Validateur                         |
-| -------------------------------------------------- | -------------------------------------------------------------------------- | ---------------------------------- |
-| Diffuse les transactions via son réseau P2P        | Diffuse les blocs et les attestations via son réseau P2P                   | Propose des blocs                  |
-| Exécute/ré-exécute les transactions                | Exécute l'algorithme de choix de fourche                                   | Accumule des récompenses/pénalités |
-| Vérifie les changements d'état entrants            | Assure le suivi de la tête de chaîne                                       | Émet des attestations              |
-| Gère les essais d'état et les essais de reçus      | Gère l'état Beacon (contient les informations de consensus et d'exécution) | Nécessite 32 ETH mis en jeu        |
-| Crée la charge utile d'exécution                   | Conserve une trace de l'accumulation de l'aléatoire dans RANDAO            | Peut être pénalisé                 |
-| Expose l'API JSON-RPC pour interagir avec Ethereum | Suit la justification et la finalisation des blocs                         |                                    |
+| Client d'exécution                                 | Client de consensus                                                                                                                                                      | Validateur                         |
+| -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------- |
+| Diffuse les transactions via son réseau P2P        | Diffuse les blocs et les attestations via son réseau P2P                                                                                                                 | Propose des blocs                  |
+| Exécute/ré-exécute les transactions                | Exécute l'algorithme de choix de fourche                                                                                                                                 | Accumule des récompenses/pénalités |
+| Vérifie les changements d'état entrants            | Assure le suivi de la tête de chaîne                                                                                                                                     | Émet des attestations              |
+| Gère les essais d'état et les essais de reçus      | Gère l'état Beacon (contient les informations de consensus et d'exécution)                                                                            | Nécessite 32 ETH mis en jeu        |
+| Crée la charge utile d'exécution                   | Suit l’aléa accumulé dans RANDAO (un algorithme qui fournit un aléa vérifiable pour la sélection des validateurs et d’autres opérations de consensus) | Peut être pénalisé                 |
+| Expose l'API JSON-RPC pour interagir avec Ethereum | Suit la justification et la finalisation des blocs                                                                                                                       |                                    |
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [Preuve d'enjeu](/developers/docs/consensus-mechanisms/pos)
 - [Proposition de bloc](/developers/docs/consensus-mechanisms/pos/block-proposal)
-- [Récompenses et pénalités du validateur](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties)
+- [Récompenses et pénalités des validateurs](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties)
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
index 9b84149646f..e1fd6c894ca 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/nodes-as-a-service/index.md
@@ -1,21 +1,21 @@
 ---
-title: Les nœuds en tant que service
-description: Présentation de base des services de nœuds, de leurs avantages et inconvénients, et des fournisseurs les plus populaires.
+title: "Nœuds en tant que service"
+description: "Présentation de base des services de nœuds, de leurs avantages et inconvénients, et des fournisseurs les plus populaires."
 lang: fr
 sidebarDepth: 2
 ---
 
 ## Introduction {#Introduction}
 
-Exécuter votre propre [nœud Ethereum](/developers/docs/nodes-and-clients/#what-are-nodes-and-clients) peut être difficile, en particulier lorsque vous démarrez ou lors d'une croissance rapide. Il existe un certain [nombre de services](#popular-node-services) qui exécutent des infrastructures de nœuds optimisées pour vous, afin que vous puissiez vous concentrer sur le développement de votre application ou de votre produit. Nous vous expliquerons le fonctionnement des services de nœuds, les avantages et les inconvénients de leur utilisation et vous fournirons une liste de fournisseurs si vous souhaitez vous lancer.
+Faire fonctionner votre propre [nœud Ethereum](/developers/docs/nodes-and-clients/#what-are-nodes-and-clients) peut être un défi, surtout lorsque vous débutez ou lors d'une mise à l'échelle rapide. Il existe un [certain nombre de services](#popular-node-services) qui exécutent pour vous des infrastructures de nœuds optimisées, afin que vous puissiez vous concentrer sur le développement de votre application ou de votre produit. Nous vous expliquerons le fonctionnement des services de nœuds, les avantages et les inconvénients de leur utilisation et vous fournirons une liste de fournisseurs si vous souhaitez vous lancer.
 
 ## Prérequis {#prerequisites}
 
-Si vous ne savez pas encore ce que sont les nœuds et les clients, consultez la page [Nœuds et clients](/developers/docs/nodes-and-clients/).
+Si vous ne comprenez pas encore ce que sont les nœuds et les clients, consultez la page [Nœuds et clients](/developers/docs/nodes-and-clients/).
 
 ## Validateurs {#stakoooooooooooooors}
 
-Les validateurs individuels doivent gérer leur propre infrastructure plutôt que compter sur des fournisseurs tiers. Cela signifie qu'il est nécessaire d'utiliser un client d'exécution couplé à un client de consensus. Avant [La Fusion](/roadmap/merge), il était uniquement possible d'exécuter un client de consensus et d'utiliser un fournisseur centralisé pour les données d'exécution ; ce n'est plus possible - un validateur individuel doit exécuter les deux clients. Toutefois, des services sont disponibles pour faciliter ce processus.
+Les validateurs individuels doivent gérer leur propre infrastructure plutôt que compter sur des fournisseurs tiers. Cela signifie qu'il est nécessaire d'utiliser un client d'exécution couplé à un client de consensus. Avant [La Fusion](/roadmap/merge), il était possible d'exécuter uniquement un client de consensus et d'utiliser un fournisseur centralisé pour les données d'exécution ; ce n'est plus possible – un validateur solo doit exécuter les deux clients. Toutefois, des services sont disponibles pour faciliter ce processus.
 
 [En savoir plus sur l'exécution d'un nœud](/developers/docs/nodes-and-clients/run-a-node/).
 
@@ -25,13 +25,13 @@ Les services décrits sur cette page concernent les nœuds non mis en jeu.
 
 Les fournisseurs de services de nœuds exécutent les clients de nœuds distribués en arrière-plan pour vous, afin que vous n'ayez pas à le faire.
 
-Ces services fournissent généralement une clé API que vous pouvez utiliser pour écrire sur la blockchain et pour la lire. Ils incluent souvent un accès aux [réseaux de test Ethereum](/developers/docs/networks/#ethereum-testnets) en plus du réseau principal.
+Ces services fournissent généralement une clé API que vous pouvez utiliser pour écrire sur la blockchain et pour la lire. Ils donnent souvent accès aux [réseaux de test Ethereum](/developers/docs/networks/#ethereum-testnets) en plus du Mainnet.
 
 Certains services vous offrent votre propre nœud dédié qu'ils gèrent pour vous, tandis que d'autres utilisent des équilibreurs de charge pour répartir l'activité entre les nœuds.
 
 Presque tous les services de nœuds sont extrêmement faciles à intégrer, impliquant des modifications d'une ligne dans votre code pour échanger votre nœud auto-hébergé, ou même pour passer d'un service à l'autre.
 
-Souvent, les services de nœuds exécuteront une variété de [nœuds clients](/developers/docs/nodes-and-clients/#execution-clients) et de [types](/developers/docs/nodes-and-clients/#node-types), vous permettant d'accéder aux nœuds complets et d'archives en plus des méthodes spécifiques au client dans une API.
+Souvent, les services de nœuds exécutent une variété de [clients](/developers/docs/nodes-and-clients/#execution-clients) et de [types](/developers/docs/nodes-and-clients/#node-types) de nœuds, vous permettant d'accéder à des nœuds complets et d'archive en plus de méthodes spécifiques aux clients dans une seule API.
 
 Il est important de noter que les services de nœud ne stockent pas et ne doivent pas stocker vos clés ou informations privées.
 
@@ -45,14 +45,14 @@ L'exécution de vos propres nœuds peut s'avérer très coûteuse, qu'il s'agiss
 
 En utilisant un service de nœuds, vous centralisez l'aspect infrastructure de votre produit. C'est pourquoi les projets qui accordent la plus haute importance à la décentralisation pourraient préférer des nœuds auto-hébergés plutôt que des nœuds d'origine externe.
 
-En savoir plus sur les [avantages à exécuter votre propre nœud](/developers/docs/nodes-and-clients/#benefits-to-you).
+En savoir plus sur les [avantages d'exécuter votre propre nœud](/developers/docs/nodes-and-clients/#benefits-to-you).
 
 ## Services de nœuds populaires {#popular-node-services}
 
 Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hésitez pas à ajouter ceux qui manquent ! Chaque service de nœuds offre différents avantages et fonctionnalités en plus des niveaux gratuits ou payants : vous devez déterminer ceux qui correspondent le mieux à vos besoins avant de prendre une décision.
 
 - [**Alchemy**](https://alchemy.com/)
-  - [Documentation](https://docs.alchemyapi.io/)
+  - [Documentation](https://www.alchemy.com/docs/)
   - Fonctionnalités
     - Plus grand niveau gratuit avec 300 M d'unités de calcul par mois (~30 M de demandes getLatestBlock)
     - Support multichaînes pour Polygon, Starknet, Optimism, Arbitrum
@@ -64,6 +64,19 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Accès aux robinets testnet intégré
     - Communauté Discord active de constructeurs avec 18 k utilisateurs
 
+- [**Allnodes**](https://www.allnodes.com/)
+  - [Documentation](https://docs.allnodes.com/)
+  - Fonctionnalités
+    - Pas de limites de requêtes avec le jeton PublicNode créé sur la page portefeuille d’Allnodes.
+    - Points de terminaison RPC gratuits axés sur la confidentialité (plus de 100 blockchains) sur [PublicNode](https://www.publicnode.com)
+    - Nœuds dédiés sans limite de requête pour plus de 90 blockchains
+    - Nœuds d’archive dédiés pour plus de 30 blockchains
+    - Disponible dans 3 régions (États-Unis, UE, Asie)
+    - Instantanés pour plus de 100 blockchains sur [PublicNode](https://www.publicnode.com/snapshots)
+    - Disponibilité garantie entre 99,90 % et 99.98% selon le contrat de niveau de service (CNS).
+    - Tarification à l'heure
+    - Payer par carte de crédit, PayPal ou Crypto
+
 - [**All That Node**](https://allthatnode.com/)
   - [Documentation](https://docs.allthatnode.com/)
   - Fonctionnalités
@@ -125,14 +138,14 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
 - [**BlockPI**](https://blockpi.io/)
   - [Documentation](https://docs.blockpi.io/)
   - Fonctionnalités
-    - Structure de nœuds robuste & distribuée
+    - Structure de nœud robuste et distribuée
     - Jusqu'à 40 points de terminaison WSS, HTTPS et RPC
     - Offre d'inscription gratuite et offre mensuelle
     - Méthode de suivi + Prise en charge des données archivées
     - Validité des offres jusqu'à 90 jours
     - Abonnement personnalisé et paiement à l'usage
     - Payer en crypto-monnaie
-    - Assistance directe & support technique
+    - Support direct et support technique
 
 - [**Chainbase**](https://www.chainbase.com/)
   - [Documentation](https://docs.chainbase.com)
@@ -156,20 +169,20 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Tarification à l'heure
     - Assistance directe 24h/24 et 7j/7
 
-- [**DRPC**](https://drpc.org/)
-  - [Documentation](https://docs.drpc.org/)
-  - Fonctionnalités
-    - Nœuds RPC décentralisés
-    - Plus de 15 fournisseurs de noeuds
-    - Solde des noeuds
-    - Unités de calcul illimitées par mois sur le niveau gratuit
-    - Vérification des données
-    - Points de terminaison personnalisés
-    - Points de terminaison HTTP et WSS
-    - Clés illimitées (niveau gratuit ou payant)
-    - Options de paiement flexible
-    - [Point de terminaison public](https://eth.drpc.org)
-    - Nœuds d'archives partagés gratuits
+- [**dRPC**](https://drpc.org/)
+  - [Documentation](https://drpc.org/docs)
+  - NodeCloud : Infrastructure RPC prête à l'emploi à partir de 10 $ (USD) — vitesse maximale, sans limites
+  - Fonctionnalités de NodeCloud :
+    - Prise en charge de l'API pour 185 réseaux
+    - Pool distribué de plus de 40 fournisseurs
+    - Couverture mondiale avec neuf (9) géo-clusters
+    - Système d'équilibrage de charge basé sur l'IA
+    - Tarification forfaitaire avec paiement à l'utilisation — pas d'augmentation, pas d'expiration, pas d'engagement
+    - Clés illimitées, ajustements granulaires des clés, rôles d'équipe, protection front-end
+    - Forfait de 20 unités de calcul (UC) par méthode
+    - [Liste de chaînes de points de terminaison publics](https://drpc.org/chainlist)
+    - [Calculateur de prix](https://drpc.org/pricing#calculator)
+  - NodeCore : pile open source pour les organisations qui souhaitent un contrôle total
 
 - [**GetBlock**](https://getblock.io/)
   - [Documentation](https://getblock.io/docs/get-started/authentication-with-api-key/)
@@ -213,14 +226,14 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Plus de 500 API d'administration et de service
     - Interface REST pour la soumission de transactions Ethereum (avec Apache Kafka)
     - Flux d'événements sortants (avec Apache Kafka)
-    - Vaste catalogue de services « hors chaîne » et auxiliaires (ex : transport bilatéral de messages chiffrés)
+    - Vaste collection de services \"hors chaîne\" et auxiliaires (p. ex., transport bilatéral de messages chiffrés)
     - Intégration simple au réseau avec gouvernance et contrôle d'accès basé sur les rôles
     - Gestion pointue des utilisateurs (administrateurs et utilisateurs finaux)
     - Infrastructure hautement évolutive, résiliente et de qualité professionnelle
     - Gestion de clé privée dans le Cloud HSM
     - Connexion au réseau principal Ethereum
     - Certifications de type 2 pour ISO 27k et SOC 2
-    - Configuration dynamique en cours d'exécution (par exemple ajout d'intégrations dans le cloud, modification des entrées d'un nœud, etc.)
+    - Configuration dynamique à l'exécution (p. ex., ajout d'intégrations cloud, modification des entrées de nœud, etc.)
     - Prise en charge des orchestrations de déploiement multi-cloud, multi-région et hybride
     - Tarification à l'heure basée sur le modèle SaaS
     - Contrats SLA et support 24h/24 et 7j/7
@@ -268,15 +281,15 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Gestionnaire de compte personnel
     - Archives, sauvegardes et nœuds dédiés partagés
 
-- [**Réseau Pocket**](https://www.pokt.network/)
-  - [Documents](https://docs.pokt.network/)
+- [**Pocket Network**](https://www.pokt.network/)
+  - [Documentation](https://docs.pokt.network/)
   - Fonctionnalités
     - Protocole RPC décentralisé et marketplace
     - 1 million de requêtes gratuites par jour (par point de terminaison, max 2)
     - Programme Pre-Stake+ (si vous avez besoin de plus d'1 million de requêtes par jour)
     - Plus de 15 blockchains prises en charge
     - Plus de 6 400 nœuds alimentent POKT pour répondre aux besoins des applications
-    - Nœud d'archivage, nœud d'archivage avec traçage & assistance pour nœuds sur le réseau de test
+    - Nœud d'archive, nœud d'archive avec traçage et support de nœud de réseau de test
     - Diversité des clients des nœuds du réseau principal Ethereum
     - Aucun point unique de défaillance
     - Aucun temps d'arrêt
@@ -286,15 +299,15 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Faites évoluer à l'infini le nombre de demandes par jour et de nœuds par heure au fur et à mesure
     - Solution la plus confidentielle et la plus résistante à la censure
     - Support pratique pour les développeurs
-    - Tableau de bord et outils d'analyse [Pocket Portal](https://bit.ly/ETHorg_POKTportal)
+    - Tableau de bord et analyses du [Pocket Portal](https://bit.ly/ETHorg_POKTportal)
 
 - [**QuickNode**](https://www.quicknode.com)
-  - [Documents](https://www.quicknode.com/docs/)
+  - [Documentation](https://www.quicknode.com/docs/)
   - Fonctionnalités
-    - Support technique 24h/24 et 7j/7 & communauté de développeurs Discord
+    - Support technique 24h/24, 7j/7 et communauté de développeurs sur Discord
     - Réseau à faible latence, géographiquement équilibré, multi-cloud/métal
     - Support multichaîne (Optimisme, Arbitrum, Polygon + 11 autres)
-    - Niveaux moyens pour la vitesse & la stabilité (routage, cache, indexation)
+    - Couches intermédiaires pour la vitesse et la stabilité (routage d'appels, cache, indexation)
     - Surveillance des contrats intelligents via les Webhooks
     - Tableau de bord intuitif, suite analytique, compositeur RPC
     - Fonctionnalités de sécurité avancées (JWT, masque, liste blanche)
@@ -303,13 +316,13 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Convient aux développeurs et aux entreprises
 
 - [**Rivet**](https://rivet.cloud/)
-  - [Documents](https://rivet.readthedocs.io/en/latest/)
+  - [Documentation](https://rivet.readthedocs.io/en/latest/)
   - Fonctionnalités
     - Option de niveau gratuite
     - Évolutivité progressive
 
 - [**SenseiNode**](https://senseinode.com)
-  - [Documents](https://docs.senseinode.com/)
+  - [Documentation](https://docs.senseinode.com/)
   - Fonctionnalités
     - Nœuds dédiés et partagés
     - Tableau de bord
@@ -317,7 +330,7 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Clients Prysm et Lighthouse
 
 - [**SettleMint**](https://console.settlemint.com/)
-  - [Docs](https://docs.settlemint.com/)
+  - [Documentation](https://docs.settlemint.com/)
   - Fonctionnalités
     - Essai gratuit
     - Évolutivité progressive
@@ -331,7 +344,7 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Assistance directe
 
 - [**Tenderly**](https://tenderly.co/web3-gateway)
-  - [Docs](https://docs.tenderly.co/web3-gateway/web3-gateway)
+  - [Documentation](https://docs.tenderly.co/web3-gateway/web3-gateway)
   - Fonctionnalités
     - Niveau gratuit incluant 25 millions d'unités Tenderly par mois
     - Accès gratuit aux données historiques
@@ -346,9 +359,9 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Support technique dédié par chat, email et Discord
 
 - [**Tokenview**](https://services.tokenview.io/)
-  - [Docs](https://services.tokenview.io/docs?type=nodeService)
+  - [Documentation](https://services.tokenview.io/docs?type=nodeService)
   - Fonctionnalités
-    - Assistance technique 24h/24 et 7j/7 & communauté Dev Telegram
+    - Support technique 24h/24, 7j/7 et communauté de développeurs sur Telegram
     - Compatible multichaîne (Bitcoin, Ethereum, Tron, BNB Smart Chain, Ethereum Classic)
     - Les points de terminaison RPC et WSS sont tous deux ouverts à l'utilisation
     - Accès illimité à l'API des données archivées
@@ -358,7 +371,7 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Assistance externe pour les besoins comportementaux additionnels
 
 - [**Watchdata**](https://watchdata.io/)
-  - [Docs](https://docs.watchdata.io/)
+  - [Documentation](https://docs.watchdata.io/)
   - Fonctionnalités
     - Fiabilité des données
     - Connexion continue sans temps d'arrêt
@@ -370,7 +383,7 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Vitesses de traitement élevées
 
 - [**ZMOK**](https://zmok.io/)
-  - [Docs](https://docs.zmok.io/)
+  - [Documentation](https://docs.zmok.io/)
   - Fonctionnalités
     - Front-running comme service
     - Mempool pour les transactions internationales avec méthodes de recherche/filtrage
@@ -379,26 +392,25 @@ Voici une liste des fournisseurs de nœuds Ethereum les plus populaires. N'hési
     - Le meilleur prix garanti par appel API
 
 - [**Zeeve**](https://www.zeeve.io/)
-  - [Docs](https://www.zeeve.io/docs/)
+  - [Documentation](https://www.zeeve.io/docs/)
   - Fonctionnalités
     - Plateforme d'automatisation no code avec laquelle l'entreprise s'intègre, permettant le déploiement, la surveillance et la gestion de nœuds et de réseaux de la blockchain
-    - Plus de 30 protocoles supportés & Intégrations, avec ajouts en cours
+    - Plus de 30 protocoles et intégrations pris en charge, et d'autres sont ajoutés régulièrement
     - Services d'infrastructure web3 à valeur ajoutée tels que stockage décentralisé, identité décentralisée et API de données Blockchain Ledger pour les cas d'utilisation dans le monde réel
     - Le support 24/7 et le suivi proactif assurent la santé des nœuds en permanence.
     - Les points de terminaison RPC offrent un accès authentifié aux API, une gestion simplifiée avec un tableau de bord intuitif et des analyses.
     - Fournit à la fois un cloud géré et apporte vos propres options de cloud parmi lesquelles choisir et prend en charge tous les principaux fournisseurs de cloud tels qu'AWS, Azure, Google Cloud, Digital Ocean et sur site.
     - Nous utilisons le routage intelligent pour toujours atteindre le nœud le plus proche de votre utilisateur
 
-
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [Liste des services de nœuds Ethereum](https://ethereumnodes.com/)
 
 ## Sujets connexes {#related-topics}
 
-- [ Nœuds et clients](/developers/docs/nodes-and-clients/)
+- [Nœuds et clients](/developers/docs/nodes-and-clients/)
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Commencer le développement d'Ethereum avec Alchemy](/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/)
-- [Guide pour envoyer des transactions avec Web3 et Alchemy](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
+- [Démarrer le développement sur Ethereum avec Alchemy](/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/)
+- [Guide pour l'envoi de transactions avec web3 et Alchemy](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
diff --git a/public/content/translations/fr/developers/docs/nodes-and-clients/run-a-node/index.md b/public/content/translations/fr/developers/docs/nodes-and-clients/run-a-node/index.md
index 5188e637f49..cfce67f9325 100644
--- a/public/content/translations/fr/developers/docs/nodes-and-clients/run-a-node/index.md
+++ b/public/content/translations/fr/developers/docs/nodes-and-clients/run-a-node/index.md
@@ -1,19 +1,19 @@
 ---
-title: Créez votre propre nœud Ethereum
-description: Introduction générale à l'exécution de votre propre instance d'un client Ethereum.
+title: "Créez votre propre nœud Ethereum"
+description: "Introduction générale à l'exécution de votre propre instance d'un client Ethereum."
 lang: fr
 sidebarDepth: 2
 ---
 
 La gestion de votre propre nœud vous offre divers avantages, ouvre de nouvelles possibilités et aide à soutenir l'écosystème. Cette page vous guidera en faisant tourner votre propre nœud et en participant à la validation des transactions Ethereum.
 
-Notez que depuis [La Fusion](/roadmap/merge), deux clients sont requis pour l'exécution d'un nœud Ethereum ; un client de **couche d'exécution (EL - Execution Layer)** et un client de **couche de consensus (CL - Consensus Layer)**. Cette page va vous montrer comment installer, configurer et connecter ces deux logiciels pour constituer un nœud Ethereum.
+Notez qu'après [La Fusion](/roadmap/merge), deux clients sont requis pour faire fonctionner un nœud Ethereum : un client de **couche d’exécution (EL)** et un client de **couche de consensus (CL)**. Cette page va vous montrer comment installer, configurer et connecter ces deux logiciels pour constituer un nœud Ethereum.
 
 ## Prérequis {#prerequisites}
 
-Il est important de comprendre ce qu'est un nœud Ethereum et pourquoi vous pourriez vouloir exécuter un client. Cette section est couverte dans le chapitre [Clients et nœuds](/developers/docs/nodes-and-clients/).
+Il est important de comprendre ce qu'est un nœud Ethereum et pourquoi vous pourriez vouloir exécuter un client. Ce sujet est abordé dans [Nœuds et clients](/developers/docs/nodes-and-clients/).
 
-Si vous êtes novice quant au sujet de l'exécution d'un nœud, ou si vous cherchez une explication moins technique, nous vous recommandons de consulter en premier lieu notre introduction facile sur [l'exécution d'un nœud Ethereum](/run-a-node).
+Si vous découvrez le sujet du fonctionnement d'un nœud, ou si vous cherchez une approche moins technique, nous vous recommandons de consulter d'abord notre introduction conviviale sur [le fonctionnement d'un nœud Ethereum](/run-a-node).
 
 ## Choisir une approche {#choosing-approach}
 
@@ -21,21 +21,22 @@ La première étape pour faire tourner votre nœud est de choisir votre approche
 
 Cette page vous guidera à travers ces décisions et vous aidera à trouver le moyen le plus approprié quant à l'exécution de votre instance Ethereum.
 
-Pour choisir parmi les clients d'implémentations, vous pouvez consulter l'ensemble des [clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) ainsi que les [clients de consensus](/developers/docs/nodes-and-clients/#consensus-clients) prêts sur le réseau principal, mais également découvrir les [clients de diversité](/developers/docs/nodes-and-clients/client-diversity).
+Pour choisir parmi les implémentations de client, consultez tous les [clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) et [clients de consensus](/developers/docs/nodes-and-clients/#consensus-clients) disponibles et prêts pour le réseau principal, et informez-vous sur la [diversité des clients](/developers/docs/nodes-and-clients/client-diversity).
 
-Décidez si vous devez exécuter le logiciel sur votre propre [matériel ou dans le cloud](#local-vs-cloud), en tenant compte des [exigences des clients](#requirements).
+Décidez si vous souhaitez exécuter le logiciel sur votre propre [matériel ou dans le cloud](#local-vs-cloud), en tenant compte des [exigences](#requirements) des clients.
 
-Après avoir préparé l'environnement, installez les clients choisis soit avec [l'interface conviviale pour débutants](#automatized-setup) ou [manuellement](#manual-setup) en utilisant un terminal avec options avancées.
+Après avoir préparé l'environnement, installez les clients choisis soit avec une [interface conviviale pour les débutants](#automatized-setup) soit [manuellement](#manual-setup) à l'aide d'un terminal avec des options avancées.
 
-Lorsque le nœud est en cours d'exécution et de synchronisation, vous êtes prêt à [l'utiliser](#using-the-node), mais assurez-vous de garder un œil sur sa [maintenance](#operating-the-node).
+Lorsque le nœud est en cours d'exécution et de synchronisation, vous êtes prêt à [l'utiliser](#using-the-node), mais veillez à surveiller sa [maintenance](#operating-the-node).
 
 ![Configuration du client](./diagram.png)
 
 ### Environnement et matériel {#environment-and-hardware}
 
-#### En local ou dans le cloud {#local-vs-cloud}
+#### Local ou cloud {#local-vs-cloud}
 
-Les clients Ethereum peuvent fonctionner sur des ordinateurs grand public et ne nécessitent aucun matériel spécial, comme pour le minage par exemple. Vous disposez donc de différentes options pour le déploiement d'un nœud en fonction de vos besoins. Pour simplifier, considérons l'exécution d'un nœud à la fois sur une machine physique locale et sur un serveur cloud :
+Les clients Ethereum peuvent fonctionner sur des ordinateurs grand public et ne nécessitent aucun matériel spécial, comme pour le minage par exemple. Vous disposez donc de différentes options pour le déploiement d'un nœud en fonction de vos besoins.
+Pour simplifier, considérons l'exécution d'un nœud à la fois sur une machine physique locale et sur un serveur cloud :
 
 - Cloud
   - Les fournisseurs offrent un temps de disponibilité élevé des serveurs et des adresses IP publiques statiques
@@ -48,27 +49,27 @@ Les clients Ethereum peuvent fonctionner sur des ordinateurs grand public et ne
   - Une option pour acheter des machines préconfigurées
   - Vous devez paramétrer la machine physique, la maintenir et potentiellement résoudre les problèmes
 
-Les deux options ont différents avantages résumés plus haut. Si vous cherchez une solution cloud, outre les nombreux fournisseurs traditionnels de cloud computing, il existe également des services axés sur le déploiement de nœuds. Consultez les [nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service/) pour plus d'options sur les nœuds hébergés.
+Les deux options ont différents avantages résumés plus haut. Si vous cherchez une solution cloud, outre les nombreux fournisseurs traditionnels de cloud computing, il existe également des services axés sur le déploiement de nœuds. Consultez [les nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service/) pour plus d'options sur les nœuds hébergés.
 
 #### Matériel {#hardware}
 
-Cependant, un réseau décentralisé et résistant à la censure ne devrait pas reposer sur des fournisseurs de cloud. À l'inverse, faire tourner votre nœud avec votre propre matériel local est plus sain pour l'écosystème. [Les estimations](https://www.ethernodes.org/network-types) montrent qu'une grande proportion de nœuds tournent dans le cloud, susceptibles de constituer un point de défaillance unique.
+Cependant, un réseau décentralisé et résistant à la censure ne devrait pas reposer sur des fournisseurs de cloud. À l'inverse, faire tourner votre nœud avec votre propre matériel local est plus sain pour l'écosystème. Les [estimations](https://www.ethernodes.org/networkType/cl/Hosting) montrent qu'une grande partie des nœuds fonctionnent sur le cloud, ce qui pourrait devenir un point de défaillance unique.
 
 Les clients Ethereum peuvent être exécutés sur votre ordinateur, votre ordinateur portable, votre serveur ou même un ordinateur mono-carte. Bien que vous puissiez faire tourner des clients sur votre ordinateur personnel, utiliser une machine dédiée uniquement à votre nœud permet de grandement améliorer les performances et la sécurité tout en minimisant l'impact sur votre ordinateur principal.
 
 Utiliser votre propre matériel peut être très facile. Il existe de nombreuses options simples ainsi que des configurations avancées pour les personnes plus techniques. Examinons donc les exigences et les moyens pour exécuter des clients Ethereum sur votre machine.
 
-#### Prérequis {#requirements}
+#### Exigences {#requirements}
 
 Les exigences matérielles diffèrent selon le client, mais ne sont en général pas si élevées puisque le nœud doit simplement rester synchronisé. Attention à ne pas confondre avec le minage, qui nécessite beaucoup plus de puissance de calcul. Le temps de synchronisation et les performances s'améliorent toutefois avec un matériel plus puissant.
 
 Avant d'installer un client, assurez-vous que votre ordinateur dispose de suffisamment de ressources pour l'exécuter. Vous trouverez ci-dessous les conditions minimales recommandées.
 
-Le facteur limitant de votre matériel est généralement le stockage. La synchronisation de la blockchain Ethereum est très intense en lecture/écriture et nécessite beaucoup d'espace. Il est recommandé d'utiliser un **disque dur SSD** contenant des centaines de Go d'espace libre, même après la synchronisation.
+Le facteur limitant de votre matériel est généralement le stockage. La synchronisation de la blockchain Ethereum est très intense en lecture/écriture et nécessite beaucoup d'espace. Il est préférable d'avoir un **disque SSD (Solid-State Drive)** avec des centaines de Go d'espace libre, même après la synchronisation.
 
 La taille de la base de données et la vitesse de la synchronisation initiale dépendent du client choisi, de sa configuration et de sa [stratégie de synchronisation](/developers/docs/nodes-and-clients/#sync-modes).
 
-Assurez-vous également que votre [bande passante](https://wikipedia.org/wiki/Data_cap) vers Internet ne soit pas limitée. Il est recommandé d'utiliser une connexion illimitée car la synchronisation initiale et les données diffusées sur le réseau pourraient dépasser votre limite.
+Assurez-vous également que votre connexion Internet n'est pas limitée par un [plafond de données](https://wikipedia.org/wiki/Data_cap). Il est recommandé d'utiliser une connexion illimitée car la synchronisation initiale et les données diffusées sur le réseau pourraient dépasser votre limite.
 
 ##### Système d'exploitation
 
@@ -91,18 +92,18 @@ Tous les clients prennent en charge les principaux systèmes d'exploitation - Li
 Le mode de synchronisation et le client que vous choisissez aura une incidence sur l'espace nécessaire, mais nous avons estimé ci-dessous l'espace disque dont vous aurez besoin pour chaque client.
 
 | Client     | Taille du disque (synchro. snap) | Taille du disque (archive complète) |
-| ---------- | -------------------------------- | ----------------------------------- |
-| Besu       | 800 Go+                          | 12 To+                              |
-| Erigon     | N/A                              | 2,5 To+                             |
-| Geth       | 500 Go+                          | 12 To+                              |
-| Nethermind | 500 Go+                          | 12 To+                              |
-| Reth       | N/A                              | 2.2TB+                              |
+| ---------- | ------------------------------------------------------------------- | ------------------------------------------------------ |
+| Besu       | 800 Go+                                                             | 12 To+                                                 |
+| Erigon     | N/A                                                                 | 2,5 To+                                                |
+| Geth       | 500 Go+                                                             | 12 To+                                                 |
+| Nethermind | 500 Go+                                                             | 12 To+                                                 |
+| Reth       | N/A                                                                 | 2.2TB+                                 |
 
 - Remarque : Erigon et Reth ne proposent pas de synchronisation instantanée, mais l'élagage complet est possible (~2 To pour Erigon, ~1,2 To pour Reth)
 
-Pour les clients de consensus, les besoins d'espace dépendent également de l'implémentation du client et des fonctionnalités activées (par exemple, validator slasher) mais comptez généralement 200 Go supplémentaires pour les données de la chaîne phare. Avec un grand nombre de validateurs, la charge de bande passante augmente également. Vous trouverez [des détails sur les exigences concernant les clients de consensus dans cette analyse](https://mirror.xyz/0x934e6B4D7eee305F8C9C42b46D6EEA09CcFd5EDc/b69LBy8p5UhcGJqUAmT22dpvdkU-Pulg2inrhoS9Mbc).
+Pour les clients de consensus, l'espace requis dépend également de l'implémentation du client et des fonctionnalités activées (par ex. : slasher de validateur), mais il faut généralement compter 200 Go supplémentaires pour les données de la balise. Avec un grand nombre de validateurs, la charge de bande passante augmente également. Vous trouverez des [détails sur les exigences des clients de consensus dans cette analyse](https://mirror.xyz/0x934e6B4D7eee305F8C9C42b46D6EEA09CcFd5EDc/b69LBy8p5UhcGJqUAmT22dpvdkU-Pulg2inrhoS9Mbc).
 
-#### Les solutions Plug-and-Play {#plug-and-play}
+#### Solutions prêtes à l'emploi {#plug-and-play}
 
 L'option la plus simple pour exécuter un nœud avec votre propre matériel est d'utiliser des boites plug-and-play. Les machines préconfigurées des fournisseurs offrent l'expérience la plus simple qui soit : commande, connexion, exécution. Tout est préconfiguré et s'exécute automatiquement avec un guide intuitif et un tableau de bord pour surveiller et contrôler le logiciel.
 
@@ -111,11 +112,11 @@ L'option la plus simple pour exécuter un nœud avec votre propre matériel est
 
 #### Ethereum sur un ordinateur monocarte {#ethereum-on-a-single-board-computer}
 
-Un moyen facile et bon marché de faire fonctionner un nœud Ethereum est d'utiliser un seul ordinateur de bord, même avec une architecture ARM comme le Raspberry Pi. [Ethereum sur ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) fournit des images faciles à exécuter de multiples exécutions et du client de consensus pour Raspberry Pi et d'autres cartes ARM.
+Un moyen facile et bon marché de faire fonctionner un nœud Ethereum est d'utiliser un seul ordinateur de bord, même avec une architecture ARM comme le Raspberry Pi. La solution [Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) fournit des images faciles à exécuter de plusieurs clients d'exécution et de consensus pour Raspberry Pi et d'autres cartes ARM.
 
 Les petits appareils, abordables et efficaces comme ceux-ci, sont parfaits pour faire tourner un nœud à la maison. Néanmoins, gardez à l'esprit leur performance limitée.
 
-## Faire tourner le nœud {#spinning-up-node}
+## Lancement du nœud {#spinning-up-node}
 
 La configuration actuelle du client peut être effectuée soit avec des lanceurs automatisés, soit manuellement, en configurant directement le logiciel client.
 
@@ -127,11 +128,12 @@ Plusieurs projets conviviaux visent à améliorer l'expérience de la mise en pl
 
 Voici quelques projets qui peuvent vous aider à installer et à contrôler vos clients en quelques clics :
 
-- [DappNode](https://docs.dappnode.io/docs/user/getting-started/choose-your-path) - DappNode ne se limite pas à une machine provenant d'un fournisseur. Le logiciel, le véritable lanceur de nœuds et le centre de contrôle offrant de nombreuses fonctionnalités peuvent être utilisés sur du matériel divers.
-- [eth-docker](https://eth-docker.net/) - Configuration automatisée à l'aide de Docker et axée sur une mise en jeu facile et sécurisée. Requiert des connaissances de base sur le terminal et Docker. Recommandée pour des utilisateurs plus aguerris.
-- [Stereum](https://stereum.net/ethereum-node-setup/) - Lanceur automatisé pour installer des clients sur un serveur à distance via une connexion SSH comprenant un guide de configuration GUI, un centre de contrôle et bien d'autres fonctionnalités.
-- [NiceNode](https://www.nicenode.xyz/) - Lanceur offrant une expérience utilisateur simple pour exécuter un nœud sur votre ordinateur. Il vous suffit de choisir vos clients et de les démarrer en quelques clics. Toujours en développement.
-- [Sedge](https://docs.sedge.nethermind.io/docs/intro) - Outil de configuration de nœud qui génère automatiquement une configuration Docker à l'aide de l'assistant CLI. Écrit en Go par Nethermind.
+- [DappNode](https://docs.dappnode.io/docs/user/getting-started/choose-your-path) - DappNode n'est pas seulement fourni avec une machine d'un fournisseur. Le logiciel, le véritable lanceur de nœuds et le centre de contrôle offrant de nombreuses fonctionnalités peuvent être utilisés sur du matériel divers.
+- [EthPillar](https://www.coincashew.com/coins/overview-eth/ethpillar) - Le moyen le plus rapide et le plus simple de configurer un nœud complet. Outil d’installation en une ligne et interface TUI de gestion de nœuds. Gratuit. Open Source. Biens publics pour Ethereum, fournis par les validateurs indépendants. Prise en charge de ARM64 et AMD64.
+- [eth-docker](https://eth-docker.net/) - Configuration automatisée à l'aide de Docker, axée sur la facilité et la sécurité de la mise en jeu, qui nécessite des connaissances de base du terminal et de Docker, et est recommandée pour les utilisateurs un peu plus avancés.
+- [Stereum](https://stereum-dev.github.io/ethereum-node-web-docs) - Lanceur pour installer des clients sur un serveur distant via une connexion SSH avec un guide de configuration GUI, un centre de contrôle et de nombreuses autres fonctionnalités.
+- [NiceNode](https://www.nicenode.xyz/) - Lanceur avec une expérience utilisateur simple pour exécuter un nœud sur votre ordinateur. Il vous suffit de choisir vos clients et de les démarrer en quelques clics. Toujours en développement.
+- [Sedge](https://docs.sedge.nethermind.io/docs/intro) - Outil de configuration de nœud qui génère automatiquement une configuration Docker à l'aide d'un assistant CLI. Écrit en Go par Nethermind.
 
 ### Configuration manuelle des clients {#manual-setup}
 
@@ -139,9 +141,9 @@ L'autre option est de télécharger, vérifier et configurer le logiciel client
 
 Comme expliqué précédemment, la mise en place de votre propre nœud Ethereum nécessitera l'exécution de deux clients, un de consensus et un d'exécution. Certains clients peuvent inclure un client léger de l'autre type et se synchroniser sans autre logiciel nécessaire. Cependant, une vérification totale de confiance nécessite les deux implémentations.
 
-#### Obtenir le logiciel client {#getting-the-client}
+#### Obtention du logiciel client {#getting-the-client}
 
-Tout d'abord, vous devez obtenir vos logiciels [client d'exécution](/developers/docs/nodes-and-clients/#execution-clients) ainsi que [client de consensus](/developers/docs/nodes-and-clients/#consensus-clients) préférés.
+Tout d'abord, vous devez obtenir le logiciel de votre [client d'exécution](/developers/docs/nodes-and-clients/#execution-clients) et de votre [client de consensus](/developers/docs/nodes-and-clients/#consensus-clients) préférés.
 
 Vous pouvez simplement télécharger une application exécutable ou un pack d'installation qui convient à votre système d'exploitation et à votre architecture. Vérifiez toujours les signatures et les sommes de contrôle des packs téléchargés. Certains clients proposent également des répertoires ou des images Docker pour faciliter l'installation et les mises à jour. Tous les clients sont Open source, vous pouvez donc également les compiler à partir de leur source. C'est une méthode plus avancée, mais dans certains cas, elle peut être requise.
 
@@ -157,25 +159,25 @@ Voici les pages de publication des clients sur lesquelles vous pouvez trouver le
 - [Nethermind](https://downloads.nethermind.io/)
 - [Reth](https://reth.rs/installation/installation.html)
 
-Il convient également de noter que la diversité de clients est un problème [pour la couche d'exécution](/developers/docs/nodes-and-clients/client-diversity/#execution-layer). Il est recommandé aux lecteurs d'envisager d'exécuter un client d'exécution minoritaire.
+Il convient également de noter que la diversité des clients est un [problème sur la couche d’exécution](/developers/docs/nodes-and-clients/client-diversity/#execution-layer). Il est recommandé aux lecteurs d'envisager d'exécuter un client d'exécution minoritaire.
 
 ##### Clients de consensus
 
 - [Lighthouse](https://github.com/sigp/lighthouse/releases/latest)
-- [Lodestar](https://chainsafe.github.io/lodestar/run/getting-started/installation#build-from-source/) (ne fournit pas de binaire pré-compilé, seulement une image Docker ou à construire à partir de la source)
+- [Lodestar](https://chainsafe.github.io/lodestar/run/getting-started/installation#build-from-source) (ne fournit pas de binaire pré-compilé, uniquement une image Docker ou à compiler à partir des sources)
 - [Nimbus](https://github.com/status-im/nimbus-eth2/releases/latest)
 - [Prysm](https://github.com/prysmaticlabs/prysm/releases/latest)
 - [Teku](https://github.com/ConsenSys/teku/releases)
 
-[La diversité des clients](/developers/docs/nodes-and-clients/client-diversity/) est critique pour les nœuds de consensus exécutés par des validateurs. Si la majorité des validateurs exécute un unique client d'implémentation, la sécurité du réseau est menacée. Il est donc recommandé d'envisager de choisir un client minoritaire.
+La [diversité des clients](/developers/docs/nodes-and-clients/client-diversity/) est essentielle pour les nœuds de consensus qui exécutent des validateurs. Si la majorité des validateurs exécute un unique client d'implémentation, la sécurité du réseau est menacée. Il est donc recommandé d'envisager de choisir un client minoritaire.
 
-[Voir les dernières utilisations de clients réseau](https://clientdiversity.org/) et en apprendre plus sur [la diversité des clients](/developers/docs/nodes-and-clients/client-diversity).
+[Voir l'utilisation la plus récente des clients du réseau](https://clientdiversity.org/) et en savoir plus sur la [diversité des clients](/developers/docs/nodes-and-clients/client-diversity).
 
 ##### Vérification du logiciel
 
 Lorsque vous téléchargez des logiciels depuis Internet, il est recommandé de vérifier leur intégrité. Cette étape est facultative, mais avec une infrastructure cruciale comme le client Ethereum, Il est important d'être conscient des vecteurs d'attaque potentiels et de les éviter. Si vous avez téléchargé un binaire pré-compilé, vous devez avoir confiance en la source et courir le risque qu'un attaquant puisse avoir échangé l'exécutable contre un exécutable malveillant.
 
-Les développeurs signent les binaires publiés avec leurs clés PGP afin de pouvoir vérifier cryptographiquement que vous exécutez exactement le logiciel qu'ils ont créé. Il vous suffit d'obtenir les clés publiques utilisées par les développeurs : celles-ci peuvent être trouvées sur les pages de publication du client ou dans la documentation. Après avoir téléchargé la version client et sa signature, vous pouvez utiliser une implémentation PGP, par exemple [GnuPG](https://gnupg.org/download/index.html) pour les vérifier facilement. Consultez un tutoriel sur la vérification de logiciels open-source avec `gpg` sur [linux](https://www.tecmint.com/verify-pgp-signature-downloaded-software/) ou [Windows/MacOS](https://freedom.press/training/verifying-open-source-software/).
+Les développeurs signent les binaires publiés avec leurs clés PGP afin de pouvoir vérifier cryptographiquement que vous exécutez exactement le logiciel qu'ils ont créé. Il vous suffit d'obtenir les clés publiques utilisées par les développeurs : celles-ci peuvent être trouvées sur les pages de publication du client ou dans la documentation. Après avoir téléchargé la version du client et sa signature, vous pouvez utiliser une implémentation PGP, par exemple [GnuPG](https://gnupg.org/download/index.html), pour les vérifier facilement. Consultez un tutoriel sur la vérification de logiciels open-source à l'aide de `gpg` sur [Linux](https://www.tecmint.com/verify-pgp-signature-downloaded-software/) ou [Windows/MacOS](https://freedom.press/training/verifying-open-source-software/).
 
 Une autre forme de vérification est de s'assurer que le hachage, une empreinte cryptographique unique du logiciel que vous avez téléchargé, correspond à celle fournie par les développeurs. C'est encore plus simple que d'utiliser PGP, et certains clients n'offrent que cette option. Il vous suffit d'exécuter la fonction de hachage sur le logiciel téléchargé et de la comparer à celle de la page de publication. Par exemple :
 
@@ -189,15 +191,15 @@ sha256sum teku-22.6.1.tar.gz
 
 Après avoir installé, téléchargé ou compilé le logiciel client, vous êtes prêt à l'exécuter. Cela signifie seulement qu'il doit être exécuté avec la configuration appropriée. Les clients offrent de riches options de configuration, qui permettent d'activer diverses fonctionnalités.
 
-Commençons par les options susceptibles d'influencer de manière significative la performance du client et l'utilisation de données. [Les modes de synchronisation](/developers/docs/nodes-and-clients/#sync-modes) représentent différentes méthodes de téléchargement et de validation des données blockchain. Avant de commencer le nœud, vous devez décider du réseau et du mode de synchronisation à utiliser. Les choses les plus importantes à considérer sont l'espace disque et le temps de synchronisation dont le client a besoin. Lisez attentivement la documentation du client pour connaître le mode de synchronisation par défaut. Choisissez celui qui vous convient le mieux en fonction du niveau de sécurité, des données disponibles et du coût. En dehors de l'algorithme de synchronisation, vous pouvez configurer l'élagage de différents types de données anciennes. L'élagage permet de supprimer les données obsolètes, par exemple supprimer les nœuds d'arborescence d'état qui ne sont pas joignables depuis des blocs récents.
+Commençons par les options susceptibles d'influencer de manière significative la performance du client et l'utilisation de données. [Les modes de synchronisation](/developers/docs/nodes-and-clients/#sync-modes) représentent différentes méthodes de téléchargement et de validation des données de la blockchain. Avant de commencer le nœud, vous devez décider du réseau et du mode de synchronisation à utiliser. Les choses les plus importantes à considérer sont l'espace disque et le temps de synchronisation dont le client a besoin. Lisez attentivement la documentation du client pour connaître le mode de synchronisation par défaut. Choisissez celui qui vous convient le mieux en fonction du niveau de sécurité, des données disponibles et du coût. En dehors de l'algorithme de synchronisation, vous pouvez configurer l'élagage de différents types de données anciennes. L'élagage (« pruning ») permet de supprimer les données obsolètes, c'est-à-dire de supprimer les nœuds du « trie » d'état qui sont inaccessibles depuis les blocs récents.
 
-Parmi les autres options de configuration de base, citons, par exemple, le choix du réseau - réseau principal ou réseau de test - l'activation d'un point de terminaison HTTP pour RPC ou WebSockets, etc. Vous pouvez trouver toutes les fonctionnalités et options dans la documentation du client. Diverses configurations de client peuvent être définies en exécutant le client avec les options correspondantes directement dans le CLI ou le fichier de configuration. Chaque client est un peu différent ; veuillez toujours vous référer à sa documentation officielle ou à sa page d'aide pour plus de détails sur les options de configuration.
+D'autres options de configuration de base sont, par exemple, le choix d'un réseau (Mainnet ou réseaux de test), l'activation du point de terminaison HTTP pour les RPC ou les WebSockets, etc. Vous pouvez trouver toutes les fonctionnalités et options dans la documentation du client. Diverses configurations de client peuvent être définies en exécutant le client avec les options correspondantes directement dans le CLI ou le fichier de configuration. Chaque client est un peu différent ; veuillez toujours vous référer à sa documentation officielle ou à sa page d'aide pour plus de détails sur les options de configuration.
 
 À des fins de test, vous pouvez exécuter un client sur un des réseaux de test. [Voir l'aperçu des réseaux pris en charge](/developers/docs/nodes-and-clients/#execution-clients).
 
 Des exemples de clients d'exécution dotés d'une configuration de base peuvent être trouvés dans la section suivante.
 
-#### Démarrer le client d'exécution {#starting-the-execution-client}
+#### Démarrage du client d'exécution {#starting-the-execution-client}
 
 Avant de démarrer le logiciel client Ethereum, vérifiez une dernière fois que votre environnement est prêt. Par exemple, assurez-vous que :
 
@@ -211,34 +213,34 @@ Exécutez d'abord votre client sur un réseau de test pour vous assurer que tout
 
 Au démarrage, vous devez déclarer tous les paramètres du client qui ne sont pas par défaut. Vous pouvez utiliser les drapeaux ou le fichier de configuration pour indiquer votre configuration préférée. Le jeu de fonctionnalités et la syntaxe de configuration de chaque client diffèrent. Consultez la documentation de votre client pour plus de détails.
 
-Les clients d'exécution et de consensus communiquent par l'intermédiaire d'un point de terminaison authentifié spécifié dans [l'API Moteur](https://github.com/ethereum/execution-apis/tree/main/src/engine). Afin de se connecter à un client de consensus, le client d'exécution doit générer un [`jwtsecret`](https://jwt.io/) à un chemin connu. Pour des raisons de sécurité et de stabilité, les clients doivent être exécutés sur la même machine, et les deux clients doivent connaître ce chemin dans la mesure où il est utilisé pour authentifier une connexion RPC locale. Le client d'exécution doit aussi définir un port d'écoute pour les API authentifiées.
+Les clients d'exécution et de consensus communiquent via un point de terminaison authentifié spécifié dans l'[API Engine](https://github.com/ethereum/execution-apis/tree/main/src/engine). Pour se connecter à un client de consensus, le client d'exécution doit générer un [`jwtsecret`](https://jwt.io/) à un chemin d'accès connu. Pour des raisons de sécurité et de stabilité, les clients doivent être exécutés sur la même machine, et les deux clients doivent connaître ce chemin dans la mesure où il est utilisé pour authentifier une connexion RPC locale. Le client d'exécution doit aussi définir un port d'écoute pour les API authentifiées.
 
-Ce jeton est généré automatiquement par le logiciel client, mais dans certains cas, vous pourriez avoir besoin de le faire vous-même. Vous pouvez le générer à l'aide d'[OpenSSL](https://www.openssl.org/):
+Ce jeton est généré automatiquement par le logiciel client, mais dans certains cas, vous pourriez avoir besoin de le faire vous-même. Vous pouvez le générer en utilisant [OpenSSL](https://www.openssl.org/) :
 
 ```sh
 openssl rand -hex 32 > jwtsecret
 ```
 
-#### Démarrer le client d'exécution {#running-an-execution-client}
+#### Exécuter un client d'exécution {#running-an-execution-client}
 
 Cette section vous guidera dans le démarrage des clients d'exécution. Elle sert uniquement d'exemple de configuration de base, qui démarrera le client avec ces paramètres :
 
 - Spécifie le réseau auquel se connecter, le Réseau principal dans nos exemples
-  - Vous pouvez à la place choisir [l'un des réseaux de test](/developers/docs/networks/) pour faire un premier test de votre configuration
+  - Vous pouvez choisir l'un des [réseaux de test](/developers/docs/networks/) pour les tests préliminaires de votre configuration
 - Définit le répertoire de données, où toutes les données, y compris la blockchain, seront enregistrées
-  - Assurez-vous de remplacer le chemin par un chemin réel, par exemple pointant vers votre disque externe
+  - Veillez à remplacer le chemin d'accès par un chemin réel, par exemple pointant vers votre disque externe
 - Active les interfaces pour communiquer avec le client
   - Y compris JSON-RPC et Engine API pour la communication avec le client de consensus
-- Définit le chemin vers `jwtsecret` pour l'API authentifiée
-  - Assurez-vous de remplacer le chemin exemple par un chemin réel accessible par les clients, par exemple `/tmp/jwtsecret`
+- Définit le chemin d'accès au `jwtsecret` pour l'API authentifiée
+  - Veillez à remplacer le chemin d'accès de l'exemple par un chemin réel accessible par les clients, par exemple `/tmp/jwtsecret`
 
 Gardez à l'esprit que ce n'est qu'un exemple de base, tous les autres paramètres seront définis par défaut. Référez-vous à la documentation de chaque client pour en savoir plus sur les valeurs par défaut, les paramètres et les fonctionnalités. Pour plus de fonctionnalités, par exemple concernant l'exécution des validateurs, la surveillance, etc., veuillez vous référer à la documentation du client spécifique.
 
-> Veuillez noter que les antislashes `\` visibles dans les exemples ne sont présents qu'à des fins de formatage ; les options de configuration peuvent être définies en une seule ligne.
+> Notez que les barres obliques inverses (``) dans les exemples ne sont utilisées qu'à des fins de formatage ; les indicateurs de configuration peuvent être définis sur une seule ligne.
 
 ##### Exécuter Besu
 
-Cet exemple fait démarrer Besu sur le Réseau principal, stocke les données blockchain au format par défaut dans `/data/ethereum`, active JSON RPC et Engine RPC pour connecter le client de consensus. Engine API est authentifié avec le jeton `jwtsecret` et seuls les appels de `localhost` sont autorisés.
+Cet exemple démarre Besu sur le réseau principal, stocke les données de la blockchain au format par défaut dans `/data/ethereum`, et active les RPC JSON et Engine pour connecter le client de consensus. L'API Engine est authentifiée avec le jeton `jwtsecret` et seuls les appels depuis `localhost` sont autorisés.
 
 ```sh
 besu --network=mainnet \
@@ -256,11 +258,11 @@ Besu est également fourni avec un lanceur optionnel qui posera une série de qu
 besu --Xlauncher
 ```
 
-[La documentation de Besu](https://besu.hyperledger.org/public-networks/get-started/start-node/) contient des options supplémentaires et des détails de configuration.
+La [documentation de Besu](https://besu.hyperledger.org/public-networks/get-started/start-node/) contient des options et des détails de configuration supplémentaires.
 
 ##### Exécuter Erigon
 
-Cet exemple fait démarrer Erigon sur le Réseau principal, stocke les données blockchain dans `/data/ethereum`, active JSON-RPC, définit les espaces de noms autorisés et active l'authentification pour connecter le client de consensus défini par le chemin `jwtsecret`.
+Cet exemple démarre Erigon sur le réseau principal, stocke les données de la blockchain dans `/data/ethereum`, active le JSON-RPC, définit quels espaces de noms sont autorisés et active l'authentification pour la connexion du client de consensus, qui est définie par le chemin d'accès du `jwtsecret`.
 
 ```sh
 erigon --chain mainnet \
@@ -269,11 +271,11 @@ erigon --chain mainnet \
     --authrpc.jwtsecret=/path/to/jwtsecret
 ```
 
-Erigon effectue par défaut une synchronisation complète avec un disque dur de 8 Go qui se traduira par plus de 2 To de données d'archivage. Assurez-vous que `datadir` pointe sur un disque avec assez d'espace libre ou utilisez le drapeau `--prune` pour réduire différents types de données. Consultez la documentation d'Erigon `--help` pour en savoir plus.
+Erigon effectue par défaut une synchronisation complète avec un disque dur de 8 Go qui se traduira par plus de 2 To de données d'archivage. Veillez à ce que `datadir` pointe vers un disque avec suffisamment d'espace libre ou examinez l'indicateur `--prune` qui peut réduire différents types de données. Consultez l'aide d'Erigon (`--help`) pour en savoir plus.
 
 ##### Exécuter Geth
 
-Cet exemple fait démarrer Geth sur le Réseau principal, stocke les données blockchain dans `/data/ethereum`, active JSON RPC et définit les espaces de noms autorisés. Il active également l'authentification pour connecter le client de consensus qui nécessite le chemin vers `jwtsecret` ainsi que l'option définissant les connexions autorisées, dans notre exemple uniquement à partir de `localhost`.
+Cet exemple démarre Geth sur le réseau principal, stocke les données de la blockchain dans `/data/ethereum`, active le JSON-RPC et définit les espaces de noms autorisés. Il active également l'authentification pour la connexion du client de consensus, ce qui nécessite le chemin d'accès au `jwtsecret` ainsi qu'une option définissant les connexions autorisées, dans notre exemple, uniquement depuis `localhost`.
 
 ```sh
 geth --mainnet \
@@ -284,11 +286,11 @@ geth --mainnet \
     --authrpc.jwtsecret=/path/to/jwtsecret
 ```
 
-Vérifiez la documentation [pour toutes les options de configuration](https://geth.ethereum.org/docs/fundamentals/command-line-options) et apprenez-en plus sur [l'exécution de Geth avec un client de consensus](https://geth.ethereum.org/docs/getting-started/consensus-clients).
+Consultez la [documentation pour toutes les options de configuration](https://geth.ethereum.org/docs/fundamentals/command-line-options) et apprenez-en plus sur [l'exécution de Geth avec un client de consensus](https://geth.ethereum.org/docs/getting-started/consensus-clients).
 
 ##### Exécuter Nethermind
 
-Nethermind offre diverses [options d'installation](https://docs.nethermind.io/get-started/installing-nethermind). Le paquet est fourni avec divers binaires, y compris un lanceur doté d'une installation guidée, qui vous aidera à créer votre configuration de manière interactive. Autrement, vous trouverez Runner, qui est l'exécutable lui-même, et pouvez simplement l'exécuter en utilisant des options de configuration. JSON-RPC est activé par défaut.
+Nethermind propose différentes [options d'installation](https://docs.nethermind.io/get-started/installing-nethermind). Le paquet est fourni avec divers binaires, y compris un lanceur doté d'une installation guidée, qui vous aidera à créer votre configuration de manière interactive. Autrement, vous trouverez Runner, qui est l'exécutable lui-même, et pouvez simplement l'exécuter en utilisant des options de configuration. JSON-RPC est activé par défaut.
 
 ```sh
 Nethermind.Runner --config mainnet \
@@ -296,13 +298,13 @@ Nethermind.Runner --config mainnet \
     --JsonRpc.JwtSecretFile=/path/to/jwtsecret
 ```
 
-La documentation de Nethermind offre un [guide complet](https://docs.nethermind.io/get-started/running-node/) sur le fonctionnement de Nethermind avec un client de consensus.
+La documentation de Nethermind propose un [guide complet](https://docs.nethermind.io/get-started/running-node/) sur l'exécution de Nethermind avec un client de consensus.
 
 Un client d'exécution initiera ses fonctions principales, ses points de terminaison choisis, et commencera à rechercher des pairs. Après avoir réussi à trouver des pairs, le client débute la synchronisation. Le client d'exécution attendra une connexion du client de consensus. Les données actuelles de la blockchain seront disponibles une fois le client correctement synchronisé avec l'état actuel.
 
 ##### Exécuter Reth
 
-Cet exemple fait démarrer Reth sur le réseau principal, en utilisant l'emplacement de données par défaut. Active l'authentification JSON-RPC et Engine RPC pour la connexion au client de consensus, qui est définie par le chemin `jwtsecret`, seuls les appels provenant de `localhost` étant autorisés.
+Cet exemple fait démarrer Reth sur le réseau principal, en utilisant l'emplacement de données par défaut. Active l'authentification RPC JSON et Engine pour la connexion au client de consensus, qui est définie par le chemin d'accès du `jwtsecret`, seuls les appels provenant de `localhost` étant autorisés.
 
 ```sh
 nœud reth \
@@ -311,23 +313,23 @@ nœud reth \
     --authrpc.port 8551
 ```
 
-Voir [Configurer Reth](https://reth.rs/run/config.html?highlight=data%20directory#configuring-reth) pour en savoir plus sur les répertoires de données par défaut. [La documentation de Reth](https://reth.rs/run/mainnet.html) contient des options supplémentaires et des détails de configuration.
+Consultez [Configuration de Reth](https://reth.rs/run/config.html?highlight=data%20directory#configuring-reth) pour en savoir plus sur les répertoires de données par défaut. [La documentation de Reth](https://reth.rs/run/mainnet.html) contient des options et des détails de configuration supplémentaires.
 
-#### Démarrer le client de consensus {#starting-the-consensus-client}
+#### Démarrage du client de consensus {#starting-the-consensus-client}
 
 Le client de consensus doit être démarré avec la bonne configuration de port pour établir une connexion RPC locale avec le client d'exécution. Le client de consensus doit être exécuté avec le port du client d'exécution exposé en tant qu'argument de configuration.
 
-Le client de consensus a également besoin du chemin vers le `jwt-secret` du client d'exécution afin d'authentifier la connexion RPC entre eux. Comme pour les exemples d'exécution ci-dessus, chaque client de consensus possède une option de configuration qui prend le chemin du fichier jwt token comme argument. Celui-ci doit être compatible avec le chemin `jwtsecret` fourni au client d'exécution.
+Le client de consensus a également besoin du chemin d'accès au `jwt-secret` du client d'exécution afin d'authentifier la connexion RPC entre eux. Comme pour les exemples d'exécution ci-dessus, chaque client de consensus possède une option de configuration qui prend le chemin du fichier jwt token comme argument. Ce chemin doit être cohérent avec le chemin d'accès du `jwtsecret` fourni au client d'exécution.
 
 Si vous prévoyez d'exécuter un validateur, assurez-vous d'ajouter une option de configuration spécifiant l'adresse Ethereum du destinataire des frais. C'est là que s'accumulent les récompenses en ether de votre validateur. Chaque client de consensus a une option, par exemple `--suggested-fee-recipient=0xabcd1`, qui prend une adresse Ethereum comme argument.
 
-Lorsque vous démarrez un nœud phare sur un réseau de test, vous pouvez gagner un temps de synchronisation significatif en utilisant un point de terminaison public pour [la synchronisation Checkpoint](https://notes.ethereum.org/@launchpad/checkpoint-sync).
+Lorsque vous démarrez un nœud de balise (Beacon Node) sur un réseau de test, vous pouvez gagner un temps de synchronisation significatif en utilisant un point de terminaison public pour la [synchronisation par point de contrôle (Checkpoint sync)](https://notes.ethereum.org/@launchpad/checkpoint-sync).
 
 #### Exécuter un client de consensus {#running-a-consensus-client}
 
 ##### Exécuter Lighthouse
 
-Avant d'exécuter Lighthouse, apprenez-en plus sur la façon de l'installer et de le configurer dans [la documentation Lighthouse](https://lighthouse-book.sigmaprime.io/installation.html).
+Avant d'exécuter Lighthouse, apprenez-en plus sur la façon de l'installer et de le configurer dans le [Livre Lighthouse](https://lighthouse-book.sigmaprime.io/installation.html).
 
 ```sh
 lighthouse beacon_node \
@@ -340,11 +342,11 @@ lighthouse beacon_node \
 
 ##### Exécuter Lodestar
 
-Installez le logiciel Lodestar en le compilant ou en téléchargeant l'image Docker. Apprenez-en plus dans [la documentation](https://chainsafe.github.io/lodestar/) et le [guide d'installation](https://hackmd.io/@philknows/rk5cDvKmK) approfondi.
+Installez le logiciel Lodestar en le compilant ou en téléchargeant l'image Docker. Apprenez-en plus dans la [documentation](https://chainsafe.github.io/lodestar/) et le [guide d'installation](https://hackmd.io/@philknows/rk5cDvKmK) plus complet.
 
 ```sh
 lodestar beacon \
-    --rootDir="/data/ethereum" \
+    --dataDir="/data/ethereum" \
     --network=mainnet \
     --eth1.enabled=true \
     --execution.urls="http://127.0.0.1:8551" \
@@ -353,7 +355,8 @@ lodestar beacon \
 
 ##### Exécuter Nimbus
 
-Nimbus est fourni avec les clients de consensus et d'exécution. Il peut être exécuté sur différents appareils, même avec une puissance informatique très modeste. Après [avoir installé les dépendances et Nimbus lui-même](https://nimbus.guide/quick-start.html), vous pouvez exécuter son client de consensus :
+Nimbus est fourni avec les clients de consensus et d'exécution. Il peut être exécuté sur différents appareils, même avec une puissance informatique très modeste.
+Après avoir [installé les dépendances et Nimbus lui-même](https://nimbus.guide/quick-start.html), vous pouvez exécuter son client de consensus :
 
 ```sh
 nimbus_beacon_node \
@@ -365,7 +368,7 @@ nimbus_beacon_node \
 
 ##### Exécuter Prysm
 
-Prysm est livré avec un script qui permet une installation automatique facile. Les détails peuvent être trouvés dans [la documentation Prysm](https://prysm.offchainlabs.com/docs/install-prysm/install-with-script/).
+Prysm est livré avec un script qui permet une installation automatique facile. Vous trouverez des détails dans la [documentation de Prysm](https://prysm.offchainlabs.com/docs/install-prysm/install-with-script/).
 
 ```sh
 ./prysm.sh beacon-chain \
@@ -384,51 +387,51 @@ teku --network mainnet \
     --ee-jwt-secret-file "/path/to/jwtsecret"
 ```
 
-Lorsqu'un client de consensus se connecte au client d'exécution pour lire le contrat de dépôt et identifier les validateurs, il se connecte également à d'autres nœuds phares et commence à synchroniser les créneaux de consensus à partir de la genèse. Une fois la période actuelle atteinte par le nœud phare, l'API phare devient utilisable pour vos validateurs. En savoir plus sur [l'API des nœuds phares](https://eth2docs.vercel.app/).
+Lorsqu'un client de consensus se connecte au client d'exécution pour lire le contrat de dépôt et identifier les validateurs, il se connecte également à d'autres nœuds phares et commence à synchroniser les créneaux de consensus à partir de la genèse. Une fois la période actuelle atteinte par le nœud phare, l'API phare devient utilisable pour vos validateurs. En savoir plus sur les [API de nœud de balise](https://eth2docs.vercel.app/).
 
-### Ajouter des Validateurs {#adding-validators}
+### Ajout de validateurs {#adding-validators}
 
 Un client de consensus joue le rôle de nœud phare pour que les validateurs puissent se connecter. Chaque client de consensus a son propre logiciel de validateur décrit en détail dans sa documentation respective.
 
-Exécuter votre propre validateur permet la [mise en jeu individuelle](/staking/solo/), la méthode la plus efficace et la plus fiable pour soutenir le réseau Ethereum. Cependant, cela nécessite un dépôt de 32 ETH. Pour exécuter un validateur sur votre propre nœud avec un montant moindre, un groupe d'enjeu décentralisé comportant des opérateurs de nœuds sans intermédiaire de confiance, comme [Rocket Pool](https://rocketpool.net/node-operators), pourrait vous intéresser.
+Exécuter votre propre validateur permet la [mise en jeu en solo](/staking/solo/), la méthode la plus percutante et sans confiance pour soutenir le réseau Ethereum. Cependant, cela nécessite un dépôt de 32 ETH. Pour exécuter un validateur sur votre propre nœud avec un montant plus petit, un pool décentralisé avec des opérateurs de nœuds sans permission, tel que [Rocket Pool](https://rocketpool.net/node-operators), pourrait vous intéresser.
 
-La façon la plus simple de commencer avec la mise en jeu et la génération de clés de validateur est d'utiliser [la plateforme de lancement de mise en jeu du réseau de test Holesky](https://holesky.launchpad.ethereum.org/), qui vous permet de tester votre configuration en [exécutant des nœuds sur Holesky](https://notes.ethereum.org/@launchpad/holesky). Lorsque vous êtes prêt pour le réseau principal, vous pouvez répéter ces étapes en utilisant la [plateforme de lancement de mise en jeu du réseau principal](https://launchpad.ethereum.org/).
+Le moyen le plus simple de démarrer avec la mise en jeu et la génération de clés de validateur est d'utiliser la [plateforme de lancement de la mise en jeu sur le réseau de test Hoodi](https://hoodi.launchpad.ethereum.org/), qui vous permet de tester votre configuration en [exécutant des nœuds sur Hoodi](https://notes.ethereum.org/@launchpad/hoodi). Lorsque vous êtes prêt pour le réseau principal, vous pouvez répéter ces étapes en utilisant la [plateforme de lancement de la mise en jeu sur le réseau principal](https://launchpad.ethereum.org/).
 
-Consultez la page [de mise en jeu](/staking) pour obtenir un aperçu des options de mise en jeu.
+Consultez la [page sur la mise en jeu](/staking) pour un aperçu des options de mise en jeu.
 
-### Utiliser le nœud {#using-the-node}
+### Utilisation du nœud {#using-the-node}
 
-Les clients d'exécution offrent des [terminaux RPC API](/developers/docs/apis/json-rpc/) que vous pouvez utiliser pour soumettre des transactions, interagir avec des contrats intelligents ou les déployer sur le réseau Ethereum de différentes manières :
+Les clients d'exécution offrent des [points de terminaison d'API RPC](/developers/docs/apis/json-rpc/) que vous pouvez utiliser pour soumettre des transactions, interagir avec des contrats intelligents ou les déployer sur le réseau Ethereum de différentes manières :
 
-- Les appeler manuellement avec un protocole approprié (par exemple en utilisant `curl`)
-- Attacher une console fournie (par exemple `geth attach`)
-- Les implémenter dans des applications utilisant des bibliothèques web3, par exemple [web3.py](https://web3py.readthedocs.io/en/stable/overview.html#overview), [ethers](https://github.com/ethers-io/ethers.js/)
+- En les appelant manuellement avec un protocole approprié (par exemple, en utilisant `curl`)
+- En attachant une console fournie (par exemple, `geth attach`)
+- En les implémentant dans des applications utilisant des bibliothèques web3, par exemple [web3.py](https://web3py.readthedocs.io/en/stable/overview.html#overview), [ethers](https://github.com/ethers-io/ethers.js/)
 
-Chaque client dispose d'une implémentation différente des points de terminaison RPC. Mais il existe un standard JSON-RPC que vous pouvez utiliser avec chaque client. Pour une vue d'ensemble [lisez la documentation JSON-RPC](/developers/docs/apis/json-rpc/). Les applications ayant besoin d'informations du réseau Ethereum peuvent utiliser ce RPC. Par exemple, le portefeuille populaire MetaMask vous permet [de vous connecter à votre propre terminal RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node), celui-ci offrant de solides avantages en termes de confidentialité et de sécurité.
+Chaque client dispose d'une implémentation différente des points de terminaison RPC. Mais il existe un standard JSON-RPC que vous pouvez utiliser avec chaque client. Pour un aperçu, [lisez la documentation JSON-RPC](/developers/docs/apis/json-rpc/). Les applications ayant besoin d'informations du réseau Ethereum peuvent utiliser ce RPC. Par exemple, le portefeuille populaire MetaMask vous permet de [vous connecter à votre propre point de terminaison RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node), ce qui offre de solides avantages en matière de confidentialité et de sécurité.
 
-Les clients de consensus exposent tous une [API phare](https://ethereum.github.io/beacon-APIs) qui peut être utilisée pour vérifier l'état du client de consensus ou télécharger des blocs et des données de consensus en envoyant des requêtes à l'aide d'outils tels que [Curl](https://curl.se). Vous trouverez plus d'informations à ce sujet dans la documentation de chaque client de consensus.
+Les clients de consensus exposent tous une [API de balise](https://ethereum.github.io/beacon-APIs) qui peut être utilisée pour vérifier l'état du client de consensus ou télécharger des blocs et des données de consensus en envoyant des requêtes à l'aide d'outils tels que [Curl](https://curl.se). Vous trouverez plus d'informations à ce sujet dans la documentation de chaque client de consensus.
 
-#### Atteindre le RPC {#reaching-rpc}
+#### Accéder au RPC {#reaching-rpc}
 
-Le port par défaut pour l'exécution du client JSON-RPC est `8545`, mais vous pouvez modifier les ports des terminaux locaux dans la configuration. Par défaut, l'interface RPC n'est accessible que sur l'hôte local de votre ordinateur. Pour le rendre accessible à distance, vous pourriez vouloir le montrer au public en modifiant l'adresse en `0.0.0.0`. Cela le rendra accessible via les adresses IP locales et publiques. Dans la plupart des cas, vous devrez également configurer la redirection de port sur votre routeur.
+Le port par défaut pour le JSON-RPC du client d'exécution est `8545`, mais vous pouvez modifier les ports des points de terminaison locaux dans la configuration. Par défaut, l'interface RPC n'est accessible que sur l'hôte local de votre ordinateur. Pour le rendre accessible à distance, vous pouvez l'exposer au public en changeant l'adresse à `0.0.0.0`. Cela le rendra accessible via les adresses IP locales et publiques. Dans la plupart des cas, vous devrez également configurer la redirection de port sur votre routeur.
 
 Soyez vigilant lorsque vous rendez les ports accessibles à distance, car cela permettra à quiconque sur Internet de contrôler votre nœud. Des acteurs malveillants pourraient accéder à votre nœud pour neutraliser votre système ou voler vos fonds si vous utilisez votre client comme portefeuille.
 
-Un moyen de contourner ce problème est d'éviter que des méthodes RPC potentiellement dangereuses ne soient modifiables. Par exemple, avec Geth, vous pouvez indiquer des méthodes modifiables via une option : `--http.api web3,eth,txpool`.
+Un moyen de contourner ce problème est d'éviter que des méthodes RPC potentiellement dangereuses ne soient modifiables. Par exemple, avec Geth, vous pouvez déclarer des méthodes modifiables avec un indicateur : `--http.api web3,eth,txpool`.
 
-L'accès à l'interface RPC peut être étendu via le développement d'API de couche périphérique ou d'applications de serveur web, comme Nginx, et en les connectant à l'adresse locale et au port de votre client. L'utilisation d'une couche intermédiaire peut également permettre aux développeurs de configurer un certificat pour les connexions `https` sécurisées sur l'interface RPC.
+L'accès à l'interface RPC peut être étendu via le développement d'API de couche périphérique ou d'applications de serveur web, comme Nginx, et en les connectant à l'adresse locale et au port de votre client. L'utilisation d'une couche intermédiaire peut également permettre aux développeurs de configurer un certificat pour des connexions `https` sécurisées à l'interface RPC.
 
-Configurer un serveur web, un proxy, ou l'API Rest externe n'est pas le seul moyen de fournir un accès au point de terminaison RPC de votre nœud. Une façon respectueuse de la vie privée de créer un point de terminaison accessible au public est de l'héberger sur votre propre service d'oignon [Tor](https://www.torproject.org/). Cela vous permettra d'atteindre le RPC en dehors de votre réseau local sans adresse IP publique statique ni ports ouverts. Cependant, utiliser cette configuration peut ne permettre l'accès au point de terminaison RPC que via le réseau Tor, qui n'est pas supporté par toutes les applications et peut entraîner des problèmes de connexion.
+Configurer un serveur web, un proxy, ou l'API Rest externe n'est pas le seul moyen de fournir un accès au point de terminaison RPC de votre nœud. Une autre façon de préserver la confidentialité pour configurer un point de terminaison accessible au public est d'héberger le nœud sur votre propre service onion [Tor](https://www.torproject.org/). Cela vous permettra d'atteindre le RPC en dehors de votre réseau local sans adresse IP publique statique ni ports ouverts. Cependant, utiliser cette configuration peut ne permettre l'accès au point de terminaison RPC que via le réseau Tor, qui n'est pas supporté par toutes les applications et peut entraîner des problèmes de connexion.
 
-Pour cela, vous devez créer votre propre [service d'oignon](https://community.torproject.org/onion-services/). Consultez [la documentation](https://community.torproject.org/onion-services/setup/) sur la configuration du service oignon pour héberger la vôtre. Vous pouvez le diriger vers un serveur web avec un proxy vers le port RPC ou simplement directement vers le RPC.
+Pour ce faire, vous devez créer votre propre [service onion](https://community.torproject.org/onion-services/). Consultez [la documentation](https://community.torproject.org/onion-services/setup/) sur la configuration du service onion pour héberger le vôtre. Vous pouvez le diriger vers un serveur web avec un proxy vers le port RPC ou simplement directement vers le RPC.
 
-Enfin, l'un des moyens les plus populaires de fournir un accès aux réseaux internes est d'utiliser une connexion VPN. Selon les cas d'utilisation et la quantité d'utilisateurs ayant besoin d'accéder à votre nœud, une connexion VPN sécurisée pourrait être une option. [OpenVPN](https://openvpn.net/) est un VPN SSL complet qui implémente l'extension réseau sécurisée OSI de couche 2 ou 3 en utilisant le protocole standard SSL/TLS, supporte les méthodes d'authentification client flexibles basées sur des certificats, cartes à puce, et/ou identifiants d’utilisateur/mot de passe, et admet des politiques de contrôle d’accès spécifiques à l’utilisateur ou au groupe en utilisant les règles de pare-feu appliquées à l’interface virtuelle VPN.
+Enfin, l'un des moyens les plus populaires de fournir un accès aux réseaux internes est d'utiliser une connexion VPN. Selon les cas d'utilisation et la quantité d'utilisateurs ayant besoin d'accéder à votre nœud, une connexion VPN sécurisée pourrait être une option. [OpenVPN](https://openvpn.net/) est un VPN SSL complet qui implémente une extension de réseau sécurisée de couche 2 ou 3 OSI en utilisant le protocole standard SSL/TLS, prend en charge des méthodes d'authentification client flexibles basées sur des certificats, des cartes à puce et/ou des identifiants d'utilisateur/mot de passe, et permet des politiques de contrôle d'accès spécifiques à l'utilisateur ou au groupe en utilisant des règles de pare-feu appliquées à l'interface virtuelle du VPN.
 
-### Maintenir le nœud {#operating-the-node}
+### Fonctionnement du nœud {#operating-the-node}
 
 Vous devriez surveiller régulièrement votre nœud pour vous assurer qu'il fonctionne correctement. Vous devrez peut-être effectuer un entretien occasionnel.
 
-#### Garder le nœud en ligne {#keeping-node-online}
+#### Maintenir un nœud en ligne {#keeping-node-online}
 
 Votre nœud ne doit pas rester en ligne en permanence, mais vous devriez le maintenir en ligne le plus souvent possible pour qu'il reste synchronisé avec le réseau. Vous pouvez l'éteindre pour le redémarrer, mais gardez en tête que :
 
@@ -436,45 +439,46 @@ Votre nœud ne doit pas rester en ligne en permanence, mais vous devriez le main
 - L'arrêt forcé peut endommager la base de données, vous obligeant à resynchroniser le nœud entier.
 - Votre client sera désynchronisé du réseau et devra donc rétablir sa synchronisation lors du redémarrage. Bien que le nœud puisse commencer à synchroniser là où il a été éteint, le processus peut prendre un certain temps selon la durée passée hors ligne.
 
-_Ceci ne s'applique pas pour les nœuds de validateur de couche de consensus._ Mettre votre nœud hors ligne affectera tous les services qui en dépendent. Si vous exécutez un nœud pour _miser_, vous devriez essayer de minimiser le temps d'arrêt autant que possible.
+_Cela ne s'applique pas aux nœuds validateurs de la couche de consensus._ Mettre votre nœud hors ligne affectera tous les services qui en dépendent. Si vous exécutez un nœud à des fins de _mise en jeu_, vous devriez essayer de minimiser autant que possible les temps d'arrêt.
 
-#### Créer des services client {#creating-client-services}
+#### Création de services client {#creating-client-services}
 
-Envisagez de créer un service pour exécuter automatiquement vos clients au démarrage. Par exemple, sur les serveurs Linux, la bonne pratique consisterait à créer un service, par exemple avec `systemd`, qui exécute le client avec une configuration appropriée, sous un utilisateur aux privilèges limités, et redémarre automatiquement.
+Envisagez de créer un service pour exécuter automatiquement vos clients au démarrage. Par exemple, sur les serveurs Linux, une bonne pratique consiste à créer un service, par exemple avec `systemd`, qui exécute le client avec une configuration appropriée, sous un utilisateur avec des privilèges limités et qui redémarre automatiquement.
 
-#### Mettre à jour les clients {#updating-clients}
+#### Mise à jour des clients {#updating-clients}
 
-Vous devez conserver votre logiciel client à jour avec les derniers patchs de sécurité, les dernières fonctionnalités et les [EIP](/eips/). Tout particulièrement avant [les fourches majeures](/ethereum-forks/), assurez-vous d'utiliser les bonnes versions client.
+Vous devez maintenir votre logiciel client à jour avec les derniers correctifs de sécurité, les dernières fonctionnalités et les [EIP](/eips/). Surtout avant les [fourches majeures (hard forks)](/ethereum-forks/), assurez-vous que vous exécutez les bonnes versions du client.
 
-> Avant les mises à jour importantes du réseau, EF publie un message sur son [blog](https://blog.ethereum.org). Vous pouvez [vous abonner à ces annonces](https://blog.ethereum.org/category/protocol#subscribe) pour recevoir une notification par email lorsque votre nœud a besoin d'une mise à jour.
+> Avant les mises à jour importantes du réseau, l'EF publie un article sur son [blog](https://blog.ethereum.org). Vous pouvez [vous abonner à ces annonces](https://blog.ethereum.org/category/protocol#subscribe) pour recevoir une notification par e-mail lorsque votre nœud a besoin d'une mise à jour.
 
 La mise à jour des clients est très simple. Chaque client a des instructions spécifiques dans sa documentation, mais le processus consiste généralement à simplement télécharger la dernière version et à redémarrer le client avec le nouvel exécutable. Le client devrait reprendre là où il s'est arrêté, mais avec les mises à jour appliquées.
 
 Chaque implémentation client dispose d'un identifiant de version lisible par un humain et utilisé dans le protocole de pair-à-pair, mais également accessible depuis la ligne de commande. Cet identifiant permet aux utilisateurs de vérifier qu'ils utilisent la bonne version et aux explorateurs de blocs et autres outils d'analyse de mesurer la distribution des différents clients sur le réseau. Veuillez vous référer à la documentation de chaque client pour plus d'informations sur les chaînes de version.
 
-#### Faire fonctionner des services supplémentaires {#running-additional-services}
+#### Exécution de services supplémentaires {#running-additional-services}
 
-Exécuter votre propre nœud vous permet d'utiliser des services qui nécessitent un accès direct au client RPC Ethereum. Ce sont des services construits sur Ethereum comme les [solutions de couche 2](/developers/docs/scaling/#layer-2-scaling), de backend pour les portefeuilles, des explorateurs de blocs, des outils de développement et d'autre infrastructure Ethereum.
+Exécuter votre propre nœud vous permet d'utiliser des services qui nécessitent un accès direct au client RPC Ethereum. Ce sont des services construits sur Ethereum, comme les [solutions de couche 2](/developers/docs/scaling/#layer-2-scaling), le backend pour les portefeuilles, les explorateurs de blocs, les outils de développement et d'autres infrastructures Ethereum.
 
-#### Surveiller le nœud {#monitoring-the-node}
+#### Surveillance du nœud {#monitoring-the-node}
 
-Pour bien surveiller votre nœud, envisagez de collecter des mesures. Les clients fournissent des points de terminaison métriques pour que vous puissiez obtenir des données complètes sur votre nœud. Utilisez des outils comme [InfluxDB](https://www.influxdata.com/get-influxdb/) ou [Prometheus](https://prometheus.io/) pour créer des bases de données susceptibles d'être transformées en visualisations et graphiques dans des logiciels tels que [Grafana](https://grafana.com/). Il existe de nombreuses configurations pour utiliser ce logiciel et différents tableaux de bord Grafana pour visualiser votre nœud et le réseau dans son ensemble. Par exemple, consultez le tutoriel [sur la surveillance de Geth](/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/).
+Pour bien surveiller votre nœud, envisagez de collecter des mesures. Les clients fournissent des points de terminaison métriques pour que vous puissiez obtenir des données complètes sur votre nœud. Utilisez des outils comme [InfluxDB](https://www.influxdata.com/get-influxdb/) ou [Prometheus](https://prometheus.io/) pour créer des bases de données que vous pourrez transformer en visualisations et en graphiques dans des logiciels comme [Grafana](https://grafana.com/). Il existe de nombreuses configurations pour utiliser ce logiciel et différents tableaux de bord Grafana pour visualiser votre nœud et le réseau dans son ensemble. Par exemple, consultez le [tutoriel sur la surveillance de Geth](/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/).
 
-Dans le cadre de votre surveillance, assurez-vous de garder un œil sur les performances de votre machine. Lors de la synchronisation initiale de votre nœud, le logiciel client peut être très lourd en CPU et en RAM. Pour ce faire, outre Grafana, vous pouvez utiliser les outils proposés par votre système d'exploitation comme `htop` ou `uptime`.
+Dans le cadre de votre surveillance, assurez-vous de garder un œil sur les performances de votre machine. Lors de la synchronisation initiale de votre nœud, le logiciel client peut être très lourd en CPU et en RAM. En plus de Grafana, vous pouvez utiliser les outils proposés par votre système d'exploitation, comme `htop` ou `uptime`, pour ce faire.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Ethereum Staking Guides](https://github.com/SomerEsat/ethereum-staking-guides) - _Somer Esat, régulièrement mis à jour_
-- [Guide | How to setup a validator for Ethereum staking on mainnet](https://www.coincashew.com/coins/overview-eth/guide-or-how-to-setup-a-validator-on-eth2-mainnet) _– CoinCashew, régulièrement mis à jour_
-- [ETHStaker guides on running validators on testnets](https://github.com/remyroy/ethstaker#guides) – _ETHStaker, régulièrement mis à jour_
-- [The Merge FAQ for node operators](https://notes.ethereum.org/@launchpad/node-faq-merge) - _Juillet 2022_
-- [Analyzing the hardware requirements to be an Ethereum full validated node](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _– Albert Palau, 24 Septembre 2018_
-- [Running Ethereum Full Nodes: A Guide for the Barely Motivated](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 novembre 2019_
-- [Running a Hyperledger Besu Node on the Ethereum Mainnet: Benefits, Requirements, and Setup](https://pegasys.tech/running-a-hyperledger-besu-node-on-the-ethereum-mainnet-benefits-requirements-and-setup/) _- Felipe Faraggi, 7 mai 2020_
-- [Déploiement du client Nethermind Ethereum avec la pile de surveillance](https://medium.com/nethermind-eth/deploying-nethermind-ethereum-client-with-monitoring-stack-55ce1622edbd) _– Nethermind.eth, 8 juillet 2020_
+- [Guides de mise en jeu Ethereum](https://github.com/SomerEsat/ethereum-staking-guides) - _Somer Esat, mis à jour souvent_
+- [Guide | Comment configurer un validateur pour la mise en jeu Ethereum sur le réseau principal](https://www.coincashew.com/coins/overview-eth/guide-or-how-to-setup-a-validator-on-eth2-mainnet) _– CoinCashew, mis à jour souvent_
+- [Guides ETHStaker sur l'exécution de validateurs sur des réseaux de test](https://github.com/remyroy/ethstaker#guides) – _ETHStaker, mis à jour régulièrement_
+- [Exemple d'application AWS Blockchain Node Runner pour les nœuds Ethereum](https://aws-samples.github.io/aws-blockchain-node-runners/docs/Blueprints/Ethereum) - _AWS, mis à jour souvent_
+- [FAQ sur La Fusion pour les opérateurs de nœuds](https://notes.ethereum.org/@launchpad/node-faq-merge) - _Juillet 2022_
+- [Analyser les exigences matérielles pour être un nœud entièrement validé d'Ethereum](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _– Albert Palau, 24 septembre 2018_
+- [Exécuter des nœuds complets Ethereum : un guide pour les moins motivés](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 novembre 2019_
+- [Exécuter un nœud Hyperledger Besu sur le réseau principal d'Ethereum : avantages, exigences et configuration](https://pegasys.tech/running-a-hyperledger-besu-node-on-the-ethereum-mainnet-benefits-requirements-and-setup/) _– Felipe Faraggi, 7 mai 2020_
+- [Déploiement du client Ethereum Nethermind avec une pile de surveillance](https://medium.com/nethermind-eth/deploying-nethermind-ethereum-client-with-monitoring-stack-55ce1622edbd) _– Nethermind.eth, 8 juillet 2020_
 
 ## Sujets connexes {#related-topics}
 
-- [ Nœuds et clients](/developers/docs/nodes-and-clients/)
+- [Nœuds et clients](/developers/docs/nodes-and-clients/)
 - [Blocs](/developers/docs/blocks/)
 - [Réseaux](/developers/docs/networks/)
diff --git a/public/content/translations/fr/developers/docs/oracles/index.md b/public/content/translations/fr/developers/docs/oracles/index.md
index 170660c969d..26fc7ac5807 100644
--- a/public/content/translations/fr/developers/docs/oracles/index.md
+++ b/public/content/translations/fr/developers/docs/oracles/index.md
@@ -1,6 +1,6 @@
 ---
-title: Oracles
-description: Les oracles permettent aux contrats intelligents d'Ethereum d'accéder à des données du monde réel, débloquant ainsi davantage de cas d'utilisation et une plus grande valeur pour les utilisateurs.
+title: Oracle
+description: "Les oracles permettent aux contrats intelligents d'Ethereum d'accéder à des données du monde réel, débloquant ainsi davantage de cas d'utilisation et une plus grande valeur pour les utilisateurs."
 lang: fr
 ---
 
@@ -10,11 +10,11 @@ Le fait de donner aux contrats intelligents la possibilité de s'exécuter en ut
 
 ## Prérequis {#prerequisites}
 
-Cette page suppose que le lecteur est familier avec les principes fondamentaux d'Ethereum, notamment des [nœuds](/developers/docs/nodes-and-clients/), [ des mécanismes de consensus](/developers/docs/consensus-mechanisms/), et de [l'EVM](/developers/docs/evm/). Vous devez également avoir une bonne connaissance des [contrats intelligents](/developers/docs/smart-contracts/) et de [l'anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/), notamment des [événements](/glossary/#events).
+Cette page suppose que le lecteur est familier avec les principes fondamentaux d'Ethereum, notamment les [nœuds](/developers/docs/nodes-and-clients/), les [mécanismes de consensus](/developers/docs/consensus-mechanisms/) et l'[EVM](/developers/docs/evm/). Vous devriez également avoir une bonne compréhension des [contrats intelligents](/developers/docs/smart-contracts/) et de l'[anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/), en particulier des [événements](/glossary/#events).
 
 ## Qu'est-ce qu'un oracle blockchain ? {#what-is-a-blockchain-oracle}
 
-Les oracles sont des applications qui trouvent, vérifient et transmettent des informations externes (c'est-à-dire des informations stockées hors chaîne) aux contrats intelligents fonctionnant sur la blockchain. En plus « d'intégrer » des données hors chaîne et de les diffuser sur Ethereum, les oracles peuvent également faire « remonter » des informations de la blockchain vers des systèmes externes, comme par exemple déverrouiller un verrou intelligent une fois les frais envoyés par l'utilisateur par le biais d'une transaction Ethereum.
+Les oracles sont des applications qui recherchent, vérifient et transmettent des informations externes (c'est-à-dire des informations stockées hors chaîne) à des contrats intelligents fonctionnant sur la blockchain. En plus « d'intégrer » des données hors chaîne et de les diffuser sur Ethereum, les oracles peuvent également faire « remonter » des informations de la blockchain vers des systèmes externes, comme par exemple déverrouiller un verrou intelligent une fois les frais envoyés par l'utilisateur par le biais d'une transaction Ethereum.
 
 Sans oracle, un contrat intelligent serait entièrement limité aux données en chaîne.
 
@@ -22,17 +22,17 @@ Les oracles diffèrent en fonction de la source des données (une ou plusieurs s
 
 ## Pourquoi les contrats intelligents ont-ils besoin d'oracles ? {#why-do-smart-contracts-need-oracles}
 
-Beaucoup de développeurs considèrent les contrats intelligents comme du code exécutés sur des adresses spécifiques de la blockchain. Cependant, une vision plus [générale des contrats intelligents](/smart-contracts/) est qu'il s'agit de programmes logiciels auto-exécutoires capables de faire respecter les accords entre les parties une fois que des conditions spécifiques sont remplies - d'où le terme « smart contracts. »
+Beaucoup de développeurs considèrent les contrats intelligents comme du code exécutés sur des adresses spécifiques de la blockchain. Cependant, une vision plus générale des [contrats intelligents](/smart-contracts/) est qu'il s'agit de programmes logiciels auto-exécutoires capables de faire respecter les accords entre les parties une fois que des conditions spécifiques sont remplies - d'où le terme « contrats intelligents ».
 
-Mais l'utilisation de contrats intelligents pour faire respecter des accords entre personnes n'est pas simple, étant donné qu'Ethereum est déterministe. Un [système déterministe](https://en.wikipedia.org/wiki/Deterministic_algorithm) est un système qui produit toujours les mêmes résultats compte tenu d'un état initial et d'une entrée particulière, c'est à dire quil n'y a pas de caractère aléatoire ou de variation dans le processus de calcul des sorties à partir des entrées.
+Mais l'utilisation de contrats intelligents pour faire respecter des accords entre personnes n'est pas simple, étant donné qu'Ethereum est déterministe. Un [système déterministe](https://en.wikipedia.org/wiki/Deterministic_algorithm) est un système qui produit toujours les mêmes résultats à partir d'un état initial et d'une entrée particulière, ce qui signifie qu'il n'y a pas de caractère aléatoire ou de variation dans le processus de calcul des sorties à partir des entrées.
 
-Pour parvenir à une exécution déterministe, les blockchains limitent les nœuds visant à atteindre un consensus sur des questions binaires simples (vrai/faux) en utilisant _uniquement_ les données stockées sur la blockchain elle-même. Voici quelques exemples de ces questions :
+Pour parvenir à une exécution déterministe, les blockchains limitent les nœuds à l'atteinte d'un consensus sur des questions binaires simples (vrai/faux) en utilisant _uniquement_ les données stockées sur la blockchain elle-même. Voici quelques exemples de ces questions :
 
 - « Le propriétaire du compte (identifié par une clé publique) a-t-il signé cette transaction avec la clé privée appariée ? »
 - « Ce compte dispose-t-il de suffisamment de fonds pour couvrir la transaction ? »
 - « Cette transaction est-elle valable dans le contexte de ce contrat intelligent ? », etc.
 
-Si les blockchains recevaient des informations de sources externes (c'est-à-dire, du monde réel), le déterminisme serait impossible à atteindre, ce qui empêcherait les nœuds de s'accorder sur la validité des modifications apportées à l'état de la blockchain. Prenons l'exemple d'un contrat intelligent qui exécute une transaction sur la base du taux de change actuel ETH-USD obtenu à partir d'une API de prix traditionnelle. Ce chiffre est susceptible de changer fréquemment (sans compter que l'API peut être dépréciée ou piratée), ce qui signifie que des nœuds exécutant le même code de contrat arriveraient à des résultats différents.
+Si les blockchains recevaient des informations de sources externes (c'est-à-dire du monde réel), le déterminisme serait impossible à atteindre, ce qui empêcherait les nœuds de s'accorder sur la validité des modifications apportées à l'état de la blockchain. Prenons l'exemple d'un contrat intelligent qui exécute une transaction sur la base du taux de change actuel ETH-USD obtenu à partir d'une API de prix traditionnelle. Ce chiffre est susceptible de changer fréquemment (sans compter que l'API peut être dépréciée ou piratée), ce qui signifie que des nœuds exécutant le même code de contrat arriveraient à des résultats différents.
 
 Pour une blockchain publique comme Ethereum, avec des milliers de nœuds dans le monde traitant des transactions, le déterminisme est essentiel. Sans autorité centrale servant de source de vérité, les nœuds ont besoin de mécanismes pour arriver au même état après avoir appliqué les mêmes transactions. Un cas où le nœud A exécute le code d'un contrat intelligent et obtient « 3 » comme résultat, alors que le nœud B obtient « 7 » après avoir exécuté la même transaction, provoquerait la rupture du consensus et éliminerait la valeur d'Ethereum en tant que plateforme informatique décentralisée.
 
@@ -42,7 +42,7 @@ Pour ce faire, un oracle est généralement constitué d'un contrat intelligent
 
 Essentiellement, un oracle de blockchain comble le fossé informationnel entre la blockchain et l'environnement externe, créant ainsi des « contrats intelligents hybrides ». Un contrat intelligent hybride est un contrat qui fonctionne sur la base d'une combinaison de code de contrat en chaîne et d'infrastructure hors chaîne. Les marchés de prédiction décentralisés sont un excellent exemple de contrats intelligents hybrides. Parmi les autres exemples, on peut citer les contrats intelligents d'assurance récolte qui versent des indemnités lorsqu'un ensemble d'oracles détermine que certains phénomènes météorologiques ont eu lieu.
 
-## Quel est le problème de l'oracle ? {#the-oracle-problem}
+## Quel est le problème de l'oracle ? Le problème de l'oracle {#the-oracle-problem}
 
 Les oracles résolvent un problème important, mais introduisent également certaines complications, par exemple :
 
@@ -54,11 +54,11 @@ Le « problème de l'oracle » illustre les problèmes liés à l'utilisation de
 
 Différents oracles proposent différentes solutions au problème de l'oracle, que nous explorerons plus tard. Les oracles sont généralement évalués sur leur capacité à gérer les défis suivants :
 
-1. **Exactitude** : Un oracle ne doit pas amener les contrats intelligents à déclencher des changements d'état basés sur des données hors chaîne invalides. Un oracle doit garantir l'_authenticité_ et l'_intégrité_ des données. L'authenticité signifie que les données ont été obtenues de la bonne source, tandis que l'intégrité signifie que les données sont restées intactes (c'est-à-dire qu'elles n'ont pas été modifiées) avant d'être envoyées sur la chaîne.
+1. **Exactitude** : Un oracle ne doit pas amener les contrats intelligents à déclencher des changements d'état basés sur des données hors chaîne invalides. Un oracle doit garantir l'_authenticité_ et l'_intégrité_ des données. L'authenticité signifie que les données ont été obtenues de la bonne source, tandis que l'intégrité signifie que les données sont restées intactes (c'est-à-dire qu'elles n'ont pas été modifiées) avant d'être envoyées en chaîne.
 
-2. **Disponibilité** : Un oracle ne doit pas retarder ou empêcher les contrats intelligents d'exécuter des actions et de déclencher des changements d'état. Cela veut dire que les données d'un oracle doivent être _disponibles sur demande_ sans interruption.
+2. **Disponibilité** : Un oracle ne doit pas retarder ou empêcher les contrats intelligents d'exécuter des actions et de déclencher des changements d'état. Cela signifie que les données d'un oracle doivent être _disponibles sur demande_ sans interruption.
 
-3. **Compatibilité incitative** : Un oracle devrait inciter les fournisseurs de données hors chaîne à soumettre des informations correctes aux contrats intelligents. La compatibilité incitative implique _l'imputabilité_ et _la responsabilité_. L'attribuabilité permet de lier un élément d'information externe à son fournisseur, tandis que la responsabilité lie les fournisseurs de données aux informations qu'ils fournissent, pour qu'ils puissent être récompensés ou pénalisés en fonction de la qualité des informations fournies.
+3. **Compatibilité des incitations** : Un oracle devrait inciter les fournisseurs de données hors chaîne à soumettre des informations correctes aux contrats intelligents. La compatibilité des incitations implique l'_imputabilité_ et la _responsabilité_. L'attribuabilité permet de lier un élément d'information externe à son fournisseur, tandis que la responsabilité lie les fournisseurs de données aux informations qu'ils fournissent, pour qu'ils puissent être récompensés ou pénalisés en fonction de la qualité des informations fournies.
 
 ## Comment fonctionne un service oracle blockchain ? {#how-does-a-blockchain-oracle-service-work}
 
@@ -76,11 +76,11 @@ Les utilisateurs sont des entités (c'est-à-dire des contrats intelligents) qui
 
 5. Quelle méthode doit être mise en œuvre pour filtrer les soumissions et agréger les rapports en une seule valeur ?
 
-### Contrat Oracle {#oracle-contract}
+### Contrat oracle {#oracle-contract}
 
 Le contrat d'oracle est le composant en chaîne du service de l'oracle. Il écoute les demandes de données provenant d'autres contrats, transmet les requêtes de données aux nœuds de l'oracle et diffuse les données renvoyées aux contrats clients. Ce contrat peut également effectuer des calculs sur les points de données renvoyés pour produire une valeur agrégée à envoyer au contrat demandeur.
 
-Le contrat de l'oracle expose certaines fonctions que les contrats clients appellent lorsqu'ils font une demande de données. À la réception d'une nouvelle requête, le contrat intelligent émettra un [événement de journal](/developers/docs/smart-contracts/anatomy/#events-and-logs) avec les détails de la demande de données. Cela permet de notifier les nœuds hors chaîne abonnés au journal (généralement en utilisant une commande de type JSON-RPC `eth_subscribe`), qui procèdent à la récupération des données définies dans l'événement du journal.
+Le contrat de l'oracle expose certaines fonctions que les contrats clients appellent lorsqu'ils font une demande de données. À la réception d'une nouvelle requête, le contrat intelligent émettra un [événement de journal](/developers/docs/smart-contracts/anatomy/#events-and-logs) avec les détails de la demande de données. Cela notifie les nœuds hors chaîne abonnés au journal (généralement en utilisant quelque chose comme la commande JSON-RPC `eth_subscribe`), qui procèdent à la récupération des données définies dans l'événement de journal.
 
 Vous trouverez ci-dessous un [exemple de contrat oracle](https://medium.com/@pedrodc/implementing-a-blockchain-oracle-on-ethereum-cedc7e26b49e) par Pedro Costa. Il s'agit d'un simple service d'oracle capable d'interroger des API hors chaîne à la demande d'autres contrats intelligents et de stocker les informations demandées sur la blockchain :
 
@@ -88,29 +88,29 @@ Vous trouverez ci-dessous un [exemple de contrat oracle](https://medium.com/@ped
 pragma solidity >=0.4.21 <0.6.0;
 
 contract Oracle {
-  Request[] requests; //list of requests made to the contract
-  uint currentId = 0; //increasing request id
-  uint minQuorum = 2; //minimum number of responses to receive before declaring final result
-  uint totalOracleCount = 3; // Hardcoded oracle count
+  Request[] requests; //liste des requêtes effectuées auprès du contrat
+  uint currentId = 0; //id de requête croissant
+  uint minQuorum = 2; //nombre minimum de réponses à recevoir avant de déclarer le résultat final
+  uint totalOracleCount = 3; // Nombre d'oracles codé en dur
 
-  // defines a general api request
+  // définit une requête API générale
   struct Request {
-    uint id;                            //request id
-    string urlToQuery;                  //API url
-    string attributeToFetch;            //json attribute (key) to retrieve in the response
-    string agreedValue;                 //value from key
-    mapping(uint => string) answers;     //answers provided by the oracles
-    mapping(address => uint) quorum;    //oracles which will query the answer (1=oracle hasn't voted, 2=oracle has voted)
+    uint id;                            //id de la requête
+    string urlToQuery;                  //url de l'API
+    string attributeToFetch;            //attribut json (clé) à récupérer dans la réponse
+    string agreedValue;                 //valeur de la clé
+    mapping(uint => string) answers;     //réponses fournies par les oracles
+    mapping(address => uint) quorum;    //oracles qui interrogeront la réponse (1=l'oracle n'a pas voté, 2=l'oracle a voté)
   }
 
-  //event that triggers oracle outside of the blockchain
+  //événement qui déclenche un oracle en dehors de la blockchain
   event NewRequest (
     uint id,
     string urlToQuery,
     string attributeToFetch
   );
 
-  //triggered when there's a consensus on the final result
+  //déclenché lorsqu'il y a un consensus sur le résultat final
   event UpdatedRequest (
     uint id,
     string urlToQuery,
@@ -127,23 +127,23 @@ contract Oracle {
     uint length = requests.push(Request(currentId, _urlToQuery, _attributeToFetch, ""));
     Request storage r = requests[length-1];
 
-    // Hardcoded oracles address
+    // Adresse des oracles codée en dur
     r.quorum[address(0x6c2339b46F41a06f09CA0051ddAD54D1e582bA77)] = 1;
     r.quorum[address(0xb5346CF224c02186606e5f89EACC21eC25398077)] = 1;
     r.quorum[address(0xa2997F1CA363D11a0a35bB1Ac0Ff7849bc13e914)] = 1;
 
-    // launch an event to be detected by oracle outside of blockchain
+    // lance un événement qui sera détecté par un oracle en dehors de la blockchain
     emit NewRequest (
       currentId,
       _urlToQuery,
       _attributeToFetch
     );
 
-    // increase request id
+    // augmente l'id de la requête
     currentId++;
   }
 
-  //called by the oracle to record its answer
+  //appelé par l'oracle pour enregistrer sa réponse
   function updateRequest (
     uint _id,
     string memory _valueRetrieved
@@ -151,18 +151,18 @@ contract Oracle {
 
     Request storage currRequest = requests[_id];
 
-    //check if oracle is in the list of trusted oracles
-    //and if the oracle hasn't voted yet
+    //vérifie si l'oracle est dans la liste des oracles de confiance
+    //et si l'oracle n'a pas encore voté
     if(currRequest.quorum[address(msg.sender)] == 1){
 
-      //marking that this address has voted
+      //indique que cette adresse a voté
       currRequest.quorum[msg.sender] = 2;
 
-      //iterate through "array" of answers until a position if free and save the retrieved value
+      //itère sur le \"tableau\" de réponses jusqu'à ce qu'une position soit libre et enregistre la valeur récupérée
       uint tmpI = 0;
       bool found = false;
       while(!found) {
-        //find first empty slot
+        //trouve le premier emplacement vide
         if(bytes(currRequest.answers[tmpI]).length == 0){
           found = true;
           currRequest.answers[tmpI] = _valueRetrieved;
@@ -172,8 +172,8 @@ contract Oracle {
 
       uint currentQuorum = 0;
 
-      //iterate through oracle list and check if enough oracles(minimum quorum)
-      //have voted the same answer as the current one
+      //itère sur la liste des oracles et vérifie si suffisamment d'oracles (quorum minimum)
+      //ont voté pour la même réponse que la réponse actuelle
       for(uint i = 0; i < totalOracleCount; i++){
         bytes memory a = bytes(currRequest.answers[i]);
         bytes memory b = bytes(_valueRetrieved);
@@ -196,23 +196,23 @@ contract Oracle {
 }
 ```
 
-### Nœuds Oracle {#oracle-nodes}
+### Nœuds oracles {#oracle-nodes}
 
 Le noeud d'oracle est le composant hors chaîne du service de l'oracle. Il extrait des informations de sources externes, telles que des API hébergées sur des serveurs tiers, et les met sur la chaîne pour être utilisé par des contrats intelligents. Les nœuds de l'oracle écoutent les événements provenant du contrat d'oracle sur la chaîne et procèdent à l'exécution de la tâche décrite dans le journal.
 
-Une tâche courante des nœuds d'oracle consiste à envoyer une requête [HTTP GET](https://www.w3schools.com/tags/ref_httpmethods.asp) à un service d'API, à analyser la réponse pour en extraire les données pertinentes, à la formater en une sortie lisible par la blockchain et à l'envoyer sur la chaîne en l'incluant dans une transaction vers le contrat d'oracle. Le nœud oracle peut également être tenu d'attester de la validité et de l'intégrité des informations soumises à l'aide de « preuves d'authenticité », que nous étudierons plus loin.
+Une tâche courante pour les nœuds oracles est d'envoyer une requête [HTTP GET](https://www.w3schools.com/tags/ref_httpmethods.asp) à un service d'API, d'analyser la réponse pour en extraire les données pertinentes, de la formater en une sortie lisible par la blockchain et de l'envoyer en chaîne en l'incluant dans une transaction vers le contrat oracle. Le nœud oracle peut également être tenu d'attester de la validité et de l'intégrité des informations soumises à l'aide de « preuves d'authenticité », que nous étudierons plus loin.
 
 Les oracles informatiques s'appuient également sur des nœuds hors chaîne pour effectuer des calculs qu'il ne serait pas pratique d'exécuter sur la chaîne, compte tenu des coûts du gaz et des limites de taille des blocs. Par exemple, le nœud Oracle peut être chargé de générer un chiffre aléatoire vérifiable (par exemple, pour les jeux basés sur la blockchain).
 
-## Modèles de conception Oracle {#oracle-design-patterns}
+## Modèles de conception d'oracles {#oracle-design-patterns}
 
-Il existe différents types d'oracles, notamment _lecture-immédiate_, _publier-s'abonner_, et _demande-réponse_. Les deux derniers sont les plus populaires parmi les contrats intelligents Ethereum. Ici, nous décrivons brièvement les modèles de « publier-s'abonner » et de « requête-réponse ».
+Il existe différents types d'oracles, notamment _lecture-immédiate_, _publier-s'abonner_, et _demande-réponse_, ces deux derniers étant les plus populaires parmi les contrats intelligents Ethereum. Ici, nous décrivons brièvement les modèles de « publier-s'abonner » et de « requête-réponse ».
 
 ### Oracles publier-s'abonner {#publish-subscribe-oracles}
 
 Ce type d'oracle expose un « flux de données » que d'autres contrats peuvent régulièrement lire pour obtenir des informations. Dans ce cas, les données sont censées changer fréquemment, de sorte que les contrats clients doivent écouter les mises à jour des données dans le stockage de l'oracle. Un exemple est un oracle qui fournit les dernières informations sur le prix ETH en USD aux utilisateurs.
 
-### Oracles requête-réponse {#request-response-oracles}
+### Oracles demande-réponse {#request-response-oracles}
 
 Une configuration requête-réponse permet au contrat client de demander des données arbitraires autres que celles fournies par un oracle de type publier-s'abonner. Les oracles de type requête-réponse sont idéaux lorsque l'ensemble de données est trop volumineux pour être stocké dans un contrat intelligent, et/ou que les utilisateurs n'auront besoin que d'une petite partie des données à un moment donné.
 
@@ -220,13 +220,13 @@ Bien que plus complexes que les modèles publier-s'abonner, les oracles de requ
 
 Les utilisateurs qui interrogent les données doivent couvrir le coût de la récupération des informations à partir de la source hors chaîne. Le contrat du client doit également fournir des fonds pour couvrir les frais de gaz encourus par le contrat de l'oracle pour renvoyer la réponse via la fonction de rappel spécifiée dans la demande.
 
-## Oracles centralisés vs décentralisés {#types-of-oracles}
+## Oracles centralisés ou décentralisés {#types-of-oracles}
 
 ### Oracles centralisés {#centralized-oracles}
 
 Un oracle centralisé est contrôlé par une seule entité chargée d'agréger les informations hors chaîne et de mettre à jour les données du contrat de l'oracle selon les demandes. Les oracles centralisés sont efficaces car ils reposent sur une seule source de vérité. Ils pourraient même mieux fonctionner pour les jeux de données propriétaires qui sont publiés directement par le propriétaire avec une signature largement acceptée. Cependant, ils présentent également des inconvénients :
 
-#### Faibles garanties de correction {#low-correctness-guarantees}
+#### Faibles garanties d'exactitude {#low-correctness-guarantees}
 
 Avec les oracles centralisés, il n'y a aucun moyen de confirmer si l'information fournie est correcte ou non. Même les fournisseurs « honorables » peuvent devenir malhonnêtes ou être piratés. Si l'oracle est corrompu, les contrats intelligents seront exécutés sur la base de mauvaises données.
 
@@ -234,7 +234,7 @@ Avec les oracles centralisés, il n'y a aucun moyen de confirmer si l'informatio
 
 Il n'est pas garanti que les oracles centralisés mettent systématiquement les données hors chaîne à la disposition des autres contrats intelligents. Si le fournisseur décide de désactiver le service ou si un pirate informatique détourne le composant hors chaîne de l'oracle, votre contrat intelligent risque de subir une attaque par déni de service (DoS).
 
-#### Mauvaise compatibilité des incitations {#poor-incentive-compatibility}
+#### Faible compatibilité des incitations {#poor-incentive-compatibility}
 
 Les oracles centralisés ont souvent des incitations mal conçues ou inexistantes pour que le fournisseur de données envoie des informations exactes/altérées. Payer un oracle pour son exactitude ne garantit pas l'honnêteté. Ce problème s'aggrave à mesure que la valeur contrôlée par les contrats intelligents augmente.
 
@@ -246,7 +246,7 @@ Un oracle décentralisé devrait (idéalement) être sans permission, sans confi
 
 L'utilisation d'oracles décentralisés présente les avantages suivants :
 
-### Hautes garanties de correction {#high-correctness-guarantees}
+### Garanties d'exactitude élevées {#high-correctness-guarantees}
 
 Les oracles décentralisés tentent d'assurer l'exactitude des données en utilisant différentes approches. Il s'agit notamment d'utiliser des preuves attestant de l'authenticité et de l'intégrité des informations renvoyées et de demander à plusieurs entités de s'accorder collectivement sur la validité des données hors chaîne.
 
@@ -256,13 +256,13 @@ Les preuves d'authenticité sont des mécanismes cryptographiques qui permettent
 
 Voici quelques exemples de preuves d'authenticité :
 
-**Preuves de la sécurité de la couche de transport (TLS)** : Les nœuds Oracle récupèrent souvent des données à partir de sources externes en utilisant une connexion HTTP sécurisée basée sur le protocole TLS (Transport Layer Security). Certains oracles décentralisés utilisent des preuves d'authenticité pour vérifier les sessions TLS (c'est-à-dire confirmer l'échange d'informations entre un nœud et un serveur spécifique) et confirmer que le contenu de la session n'a pas été modifié.
+**Preuves de sécurité de la couche de transport (TLS)** : Les nœuds oracles récupèrent souvent des données de sources externes en utilisant une connexion HTTP sécurisée basée sur le protocole de sécurité de la couche de transport (TLS). Certains oracles décentralisés utilisent des preuves d'authenticité pour vérifier les sessions TLS (c'est-à-dire confirmer l'échange d'informations entre un nœud et un serveur spécifique) et confirmer que le contenu de la session n'a pas été modifié.
 
-**Attestations de l'environnement d'exécution de confiance (TEE)** : Un [environnement d'exécution de confiance](https://en.wikipedia.org/wiki/Trusted_execution_environment) (TEE) est un environnement de calcul en bac à sable qui est isolé des processus opérationnels de son système hôte. Les TEE garantissent que tout code d'application ou toute donnée stockée/utilisée dans l'environnement de calcul conserve son intégrité, sa confidentialité et son immuabilité. Les utilisateurs peuvent également générer une attestation pour prouver qu'une instance d'application est exécutée dans l'environnement d'exécution de confiance.
+**Attestations d'environnement d'exécution de confiance (TEE)** : Un [environnement d'exécution de confiance](https://en.wikipedia.org/wiki/Trusted_execution_environment) (TEE) est un environnement de calcul en bac à sable qui est isolé des processus opérationnels de son système hôte. Les TEE garantissent que tout code d'application ou toute donnée stockée/utilisée dans l'environnement de calcul conserve son intégrité, sa confidentialité et son immuabilité. Les utilisateurs peuvent également générer une attestation pour prouver qu'une instance d'application est exécutée dans l'environnement d'exécution de confiance.
 
 Certaines classes d'oracles décentralisés exigent que les opérateurs de nœuds d'oracle fournissent des attestations TEE. Cela confirme à un utilisateur que l'opérateur du nœud exécute une instance du client oracle dans un environnement d'exécution de confiance. Les TEE empêchent les processus externes de modifier ou de lire le code et les données d'une application. Par conséquent, ces attestations prouvent que le nœud oracle a conservé les informations intactes et confidentielles.
 
-#### Validation consensuelle des informations {#consensus-based-validation-of-information}
+#### Validation des informations basée sur le consensus {#consensus-based-validation-of-information}
 
 Les oracles centralisés reposent sur une source unique de vérité lorsqu'ils fournissent des données aux contrats intelligents, ce qui introduit la possibilité de publier des informations inexactes. Les oracles décentralisés résolvent ce problème en s'appuyant sur plusieurs nœuds d'oracle pour interroger les informations hors chaîne. En comparant les données provenant de plusieurs sources, les oracles décentralisés réduisent le risque de transmettre des informations invalides aux contrats sur la chaîne.
 
@@ -274,17 +274,17 @@ Certains réseaux d'oracles décentralisés demandent aux participants de voter
 
 Les nœuds dont les réponses s'écartent de la réponse majoritaire sont pénalisés en voyant leurs jetons distribués à d'autres qui fournissent des valeurs plus correctes. Le fait d'obliger les nœuds à fournir une caution avant de fournir des données incite à des réponses honnêtes puisqu'on suppose qu'ils sont des acteurs économiques rationnels qui cherchent à maximiser les retours.
 
-La mise en jeu / le vote protège également les oracles décentralisés contre les [attaques Sybil](/glossary/#sybil-attack), où des acteurs malveillants créent des identités multiples pour déjouer le système de consensus. Cependant, le staking ne peut empêcher le « freeloading » (les nœuds d'oracle copiant les informations des autres) et la « validation paresseuse » (les nœuds d'oracle suivant la majorité sans vérifier eux-mêmes les informations).
+La mise en jeu/le vote protège également les oracles décentralisés des [attaques Sybil](/glossary/#sybil-attack), où des acteurs malveillants créent des identités multiples pour déjouer le système de consensus. Cependant, le staking ne peut empêcher le « freeloading » (les nœuds d'oracle copiant les informations des autres) et la « validation paresseuse » (les nœuds d'oracle suivant la majorité sans vérifier eux-mêmes les informations).
 
 ##### Mécanismes du point de Schelling
 
-[Le point de Schelling](https://en.wikipedia.org/wiki/Focal_point_(game_theory)) est un concept de la théorie des jeux qui suppose que plusieurs entités trouveront toujours par défaut une solution commune à un problème en l'absence de toute communication. Les mécanismes du point de Schelling sont souvent utilisés dans les réseaux d'oracles décentralisés pour permettre aux nœuds d'atteindre un consensus sur les réponses aux demandes de données.
+Le [point de Schelling](https://en.wikipedia.org/wiki/Focal_point_\(game_theory\)) est un concept de la théorie des jeux qui suppose que plusieurs entités trouveront toujours par défaut une solution commune à un problème en l'absence de toute communication. Les mécanismes du point de Schelling sont souvent utilisés dans les réseaux d'oracles décentralisés pour permettre aux nœuds d'atteindre un consensus sur les réponses aux demandes de données.
 
-Une première idée était le [SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed), une proposition de flux de données où les participants soumettent des réponses à des questions « scalaires » (questions dont les réponses sont décrites par une magnitude, par exemple « quel est le prix de l'ETH ? »), accompagnées d'un dépôt. Les utilisateurs qui fournissent des valeurs comprises entre le 25e et le 75e [percentile](https://en.wikipedia.org/wiki/Percentile) sont récompensés, tandis que ceux dont les valeurs s'écartent largement de la valeur médiane sont pénalisés.
+Une première idée était le [SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed/), une proposition de flux de données où les participants soumettent des réponses à des questions « scalaires » (questions dont les réponses sont décrites par une magnitude, par exemple, « quel est le prix de l'ETH ? »), accompagnées d'un dépôt. Les utilisateurs qui fournissent des valeurs comprises entre le 25e et le 75e [percentile](https://en.wikipedia.org/wiki/Percentile) sont récompensés, tandis que ceux dont les valeurs s'écartent largement de la valeur médiane sont pénalisés.
 
-Bien que SchellingCoin n'existe pas aujourd'hui, un certain nombre d'oracles décentralisés - notamment [les oracles du protocole Maker](https://docs.makerdao.com/smart-contract-modules/oracle-module) - utilisent le mécanisme du point de Schelling pour améliorer la précision des données de l'oracle. Chaque Maker Oracle est constitué d'un réseau P2P hors chaîne de nœuds (« relayeurs » et « alimenteurs ») qui soumettent des prix de marché pour les actifs donnés en garantie et d'un contrat « Medianizer » en chaîne qui calcule la médiane de toutes les valeurs fournies. Une fois le délai spécifié écoulé, cette valeur médiane devient le nouveau prix de référence de l'actif associé.
+Bien que SchellingCoin n'existe pas aujourd'hui, un certain nombre d'oracles décentralisés, notamment les [oracles du protocole Maker](https://docs.makerdao.com/smart-contract-modules/oracle-module), utilisent le mécanisme du point de Schelling pour améliorer la précision des données de l'oracle. Chaque Maker Oracle est constitué d'un réseau P2P hors chaîne de nœuds (« relayeurs » et « alimenteurs ») qui soumettent des prix de marché pour les actifs donnés en garantie et d'un contrat « Medianizer » en chaîne qui calcule la médiane de toutes les valeurs fournies. Une fois le délai spécifié écoulé, cette valeur médiane devient le nouveau prix de référence de l'actif associé.
 
-Parmi les autres exemples d'oracles qui utilisent les mécanismes du point de Schelling, citons [Chainlink OffChain Reporting](https://docs.chain.link/docs/offchain-reporting/) et [Witnet](https://witnet.io/). Dans les deux systèmes, les réponses des nœuds oracle du réseau pair-à-pair sont agrégées en une seule valeur agrégée, telle qu'une moyenne ou une médiane. Les nœuds sont récompensés ou punis en fonction de la mesure dans laquelle leurs réponses s'alignent ou s'écartent de la valeur globale.
+D'autres exemples d'oracles qui utilisent les mécanismes de point de Schelling incluent [Chainlink Offchain Reporting](https://docs.chain.link/architecture-overview/off-chain-reporting) et [Witnet](https://witnet.io/). Dans les deux systèmes, les réponses des nœuds oracle du réseau pair-à-pair sont agrégées en une seule valeur agrégée, telle qu'une moyenne ou une médiane. Les nœuds sont récompensés ou punis en fonction de la mesure dans laquelle leurs réponses s'alignent ou s'écartent de la valeur globale.
 
 Les mécanismes du point de Schelling sont intéressants car ils minimisent l'empreinte sur la chaîne (une seule transaction doit être envoyée) tout en garantissant la décentralisation. Ce dernier cas est possible parce que les nœuds doivent approuver la liste des réponses soumises avant qu'elle ne soit introduite dans l'algorithme qui produit la valeur moyenne/médiane.
 
@@ -292,15 +292,15 @@ Les mécanismes du point de Schelling sont intéressants car ils minimisent l'em
 
 Les services décentralisés d'oracle assurent une haute disponibilité des données hors chaîne pour les contrats intelligents. Cela est possible en décentralisant à la fois la source d'information hors chaîne et les nœuds responsables du transfert de l'information dans la chaîne.
 
-Cela garantit la tolérance aux pannes puisque le contrat de l'oracle peut s'appuyer sur plusieurs nœuds (qui s'appuient également sur plusieurs sources de données) pour exécuter des requêtes provenant d'autres contrats. La décentralisation au niveau de la source _et_ de l'opérateur de nœud est cruciale - un réseau de nœuds d'oracle servant des informations extraites de la même source se heurtera au même problème qu'un oracle centralisé.
+Cela garantit la tolérance aux pannes puisque le contrat de l'oracle peut s'appuyer sur plusieurs nœuds (qui s'appuient également sur plusieurs sources de données) pour exécuter des requêtes provenant d'autres contrats. La décentralisation au niveau de la source _et_ de l'opérateur de nœud est cruciale. Un réseau de nœuds oracles servant des informations extraites de la même source se heurtera au même problème qu'un oracle centralisé.
 
 Il est également possible pour les oracles basés sur la mise en jeu de sanctionner les opérateurs de nœuds qui ne répondent pas rapidement aux demandes de données. Cela incite fortement les nœuds d'oracle à investir dans une infrastructure tolérante aux pannes et à fournir des données en temps voulu.
 
 ### Bonne compatibilité des incitations {#good-incentive-compatibility}
 
-Les oracles décentralisés implémentent diverses conceptions d'incitation pour prévenir le comportement [Byzantin](https://en.wikipedia.org/wiki/Byzantine_fault) parmi les noeuds Oracle. Plus précisément, ils atteignent _l'attribuabilité_ et _la responsabilité_ :
+Les oracles décentralisés mettent en œuvre diverses conceptions d'incitation pour empêcher le comportement [byzantin](https://en.wikipedia.org/wiki/Byzantine_fault) des nœuds oracles. Plus précisément, ils atteignent l'_imputabilité_ et la _responsabilité_ :
 
-1. Les nœuds Oracle décentralisés sont souvent tenus de signer les données qu'ils fournissent en réponse aux demandes de données. Ces informations aident à évaluer les performances historiques des nœuds Oracle, de sorte que les utilisateurs puissent filtrer les nœuds Oracle non fiables lorsqu'ils font des demandes de données. Un exemple est le [Système de réputation algorithmique](https://docs.witnet.io/intro/about/architecture#algorithmic-reputation-system) de Witnet.
+1. Les nœuds Oracle décentralisés sont souvent tenus de signer les données qu'ils fournissent en réponse aux demandes de données. Ces informations aident à évaluer les performances historiques des nœuds Oracle, de sorte que les utilisateurs puissent filtrer les nœuds Oracle non fiables lorsqu'ils font des demandes de données. Un exemple est le [système de réputation algorithmique](https://docs.witnet.io/intro/about/architecture#algorithmic-reputation-system) de Witnet.
 
 2. Les oracles décentralisés - comme expliqué précédemment - peuvent exiger des nœuds qu'ils placent un enjeu sur leur confiance dans la véracité des données qu'ils soumettent. Si la demande est acceptée, cette mise peut être restituée avec des récompenses pour service honnête. Mais il peut également être réduit en cas d'information incorrecte, ce qui permet une certaine responsabilisation.
 
@@ -310,13 +310,13 @@ Voici les cas d'utilisation courants des oracles dans Ethereum :
 
 ### Récupération des données financières {#retrieving-financial-data}
 
-Les applications de [finance décentralisée](/defi/) (DeFi) permettent de prêter, d'emprunter et d'échanger des actifs de pair à pair. Cela nécessite souvent d'obtenir différentes informations sur la finance, notamment des données sur les taux de change (pour calculer la valeur en monnaie fiduciaire des crypto-monnaies ou comparer les prix des jetons) et des données sur les marchés de capitaux (pour calculer la valeur d'actifs tokenisés, comme l'or ou le dollar américain).
+Les applications de [finance décentralisée](/defi/) (DeFi) permettent le prêt, l'emprunt et l'échange d'actifs de pair à pair. Cela nécessite souvent d'obtenir différentes informations sur la finance, notamment des données sur les taux de change (pour calculer la valeur en monnaie fiduciaire des crypto-monnaies ou comparer les prix des jetons) et des données sur les marchés de capitaux (pour calculer la valeur d'actifs tokenisés, comme l'or ou le dollar américain).
 
 Un protocole de prêt DeFi, par exemple, a besoin d'interroger les prix actuels du marché pour les actifs (par exemple, ETH) déposés en garantie. Cela permet au contrat de déterminer la valeur des actifs donnés en garantie et de déterminer le montant qu'ils peuvent emprunter au système.
 
-Les « oracles de prix » (comme on les appelle souvent) les plus populaires dans DeFi comprennent les flux de prix Chainlink, le [flux de prix ouvert](https://compound.finance/docs/prices) de Compound Protocol, les [prix moyens pondérés dans le temps (TWAP)](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) d'Uniswap et les [Oracles Maker](https://docs.makerdao.com/smart-contract-modules/oracle-module).
+Les « oracles de prix » populaires (comme on les appelle souvent) dans la DeFi incluent les flux de prix Chainlink, l'[Open Price Feed](https://compound.finance/docs/prices) du protocole Compound, les [prix moyens pondérés dans le temps (TWAP)](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) d'Uniswap, et les [oracles Maker](https://docs.makerdao.com/smart-contract-modules/oracle-module).
 
-Les développeurs devraient comprendre les réserves qui accompagnent ces oracles de prix avant de les intégrer à leur projet. Cet [article](https://blog.openzeppelin.com/secure-smart-contract-guidelines-the-dangers-of-price-oracles/) fournit une analyse détaillée des éléments à prendre en compte lorsque vous envisagez d'utiliser l'un des oracles de prix mentionnés.
+Les développeurs devraient comprendre les réserves qui accompagnent ces oracles de prix avant de les intégrer à leur projet. Cet [article](https://blog.openzeppelin.com/secure-smart-contract-guidelines-the-dangers-of-price-oracles/) fournit une analyse détaillée de ce qu'il faut prendre en compte lors de la planification de l'utilisation de l'un des oracles de prix mentionnés.
 
 Vous trouverez ci-dessous un exemple de la façon dont vous pouvez récupérer le dernier prix de l'ETH dans votre contrat intelligent en utilisant un flux de prix Chainlink :
 
@@ -354,15 +354,15 @@ contract PriceConsumerV3 {
 }
 ```
 
-### Génération d'un caractère aléatoire vérifiable {#generating-verifiable-randomness}
+### Générer un caractère aléatoire vérifiable {#generating-verifiable-randomness}
 
 Certaines applications blockchain, telles que les jeux ou les systèmes de loterie basés sur la blockchain, nécessitent un niveau élevé d'imprévisibilité et de nature aléatoire pour fonctionner efficacement. Cependant, l'exécution déterministe des blockchains élimine l'aléa.
 
-L'approche initiale consistait à utiliser des fonctions cryptographiques pseudo-aléatoires, telles que le `blockhash`, mais elles pouvaient être [manipulées par des mineurs](https://ethereum.stackexchange.com/questions/3140/risk-of-using-blockhash-other-miners-preventing-attack#:~:text=So%20while%20the%20miners%20can,to%20one%20of%20the%20players.) résolvant l'algorithme de preuve de travail. De plus, le [passage d'Ethereum à la preuve d'enjeu](/roadmap/merge/) signifie que les développeurs ne peuvent plus compter sur le `blockhash` pour obtenir des valeurs aléatoires sur la chaîne. Le [ mécanisme RANDAO](https://eth2book.info/altair/part2/building_blocks/randomness) de la chaîne phare fournit une autre source d'aléatoire.
+L'approche originale consistait à utiliser des fonctions cryptographiques pseudo-aléatoires, telles que `blockhash`, mais celles-ci pouvaient être [manipulées par les mineurs](https://ethereum.stackexchange.com/questions/3140/risk-of-using-blockhash-other-miners-preventing-attack#:~:text=So%20while%20the%20miners%20can,to%20one%20of%20the%20players.) résolvant l'algorithme de preuve de travail. De plus, le [passage d'Ethereum à la preuve d'enjeu](/roadmap/merge/) signifie que les développeurs ne peuvent plus compter sur `blockhash` pour le caractère aléatoire en chaîne. Le [mécanisme RANDAO](https://eth2book.info/altair/part2/building_blocks/randomness) de la chaîne phare offre une autre source de caractère aléatoire.
 
 Il est possible de générer la valeur aléatoire hors chaîne et de l'envoyer sur la chaîne, mais cela impose des exigences de confiance élevées pour les utilisateurs. Ils doivent croire que la valeur a réellement été générée par des mécanismes imprévisibles et qu'elle n'a pas été altérée en cours de route.
 
-Les oracles conçus pour le calcul hors chaîne résolvent ce problème en générant de manière sécurisée des résultats aléatoires hors chaîne qu'ils diffusent sur la chaîne avec des preuves cryptographiques attestant de l'imprévisibilité du processus. Un exemple est le [VRF (Verifiable Random Function) de Chainlink](https://docs.chain.link/docs/chainlink-vrf/), qui est un générateur de nombres aléatoires (RNG) à l'épreuve de la falsification et d'une équité prouvée, utile pour construire des contrats intelligents fiables pour des applications qui reposent sur des résultats imprévisibles.
+Les oracles conçus pour le calcul hors chaîne résolvent ce problème en générant de manière sécurisée des résultats aléatoires hors chaîne qu'ils diffusent sur la chaîne avec des preuves cryptographiques attestant de l'imprévisibilité du processus. Un exemple est [Chainlink VRF](https://docs.chain.link/docs/chainlink-vrf/) (Verifiable Random Function), qui est un générateur de nombres aléatoires (RNG) dont l'équité est prouvable et qui est inviolable, utile pour construire des contrats intelligents fiables pour des applications qui reposent sur des résultats imprévisibles.
 
 ### Obtenir des résultats pour les événements {#getting-outcomes-for-events}
 
@@ -374,59 +374,64 @@ En utilisant des oracles pour récupérer des données basées sur des résultat
 
 Les contrats intelligents ne s'exécutent pas automatiquement : un compte externe (EOA), ou un autre compte de contrat, doit déclencher les bonnes fonctions pour exécuter le code du contrat. Dans la plupart des cas, l'essentiel des fonctions du contrat sont publiques et peuvent être invoquées par les EOA et d'autres contrats.
 
-Mais il existe également des _fonctions privées_ au sein d'un contrat qui sont inaccessibles aux autres ; mais elles sont généralement essentielles au fonctionnement global de la dApp. Par exemple, citons une fonction `mintERC721Token()` qui frappe périodiquement de nouveaux NFT pour les utilisateurs, une fonction d'attribution des gains dans un marché prédictif ou une fonction de déblocage des jetons mis en jeu dans un DEX.
+Mais il existe également des _fonctions privées_ au sein d'un contrat qui sont inaccessibles aux autres, mais qui sont essentielles à la fonctionnalité globale d'une dapp. Les exemples incluent une fonction `mintERC721Token()` qui frappe périodiquement de nouveaux NFT pour les utilisateurs, une fonction pour l'attribution des gains sur un marché prédictif ou une fonction pour débloquer des jetons mis en jeu dans un DEX.
 
 Les développeurs devront déclencher ces fonctions à intervalles réguliers pour assurer le bon fonctionnement de l'application. Toutefois, cela pourrait entraîner une augmentation du nombre d'heures perdues sur des tâches banales pour les développeurs, d'où l'intérêt d'automatiser l'exécution des contrats intelligents.
 
 Certains réseaux d'oracle décentralisés offrent des services d'automatisation, qui permettent aux nœuds d'oracle hors chaîne de déclencher des fonctions de contrat intelligent en fonction de paramètres définis par l'utilisateur. En général, il faut pour cela « enregistrer » le contrat cible auprès du service d'oracle, fournir des fonds pour payer l'opérateur d'oracle et spécifier les conditions ou les moments de déclenchement du contrat.
 
-Le [réseau Keeper](https://chain.link/keepers) de Chainlink, offre aux contrats intelligents la possibilité d'externaliser les tâches de maintenance régulières d'une manière décentralisée et avec un minimum de confiance. Lisez la [documentation officielle de Keepers](https://docs.chain.link/docs/chainlink-keepers/introduction/) pour savoir comment rendre votre contrat compatible avec Keeper et utiliser le service Upkeep.
+Le [Keeper Network](https://chain.link/keepers) de Chainlink offre aux contrats intelligents la possibilité d'externaliser les tâches de maintenance régulières d'une manière décentralisée et avec un minimum de confiance. Lisez la [documentation officielle de Keeper](https://docs.chain.link/docs/chainlink-keepers/introduction/) pour savoir comment rendre votre contrat compatible avec Keeper et utiliser le service Upkeep.
 
-## Comment utiliser les oracles de la blockchain {#use-blockchain-oracles}
+## Comment utiliser les oracles blockchain {#use-blockchain-oracles}
 
 Il existe de multiples applications oracle que vous pouvez intégrer dans votre dApp Ethereum :
 
-**[Chainlink](https://chain.link/)** - _Les réseaux d'oracles décentralisés Chainlink fournissent des entrées, des sorties et des calculs inviolables pour prendre en charge des contrats intelligents avancés sur n'importe quelle blockchain._
+**[Chainlink](https://chain.link/)** - _Les réseaux d'oracles décentralisés de Chainlink fournissent des entrées, des sorties et des calculs inviolables pour prendre en charge des contrats intelligents avancés sur n'importe quelle blockchain._
 
-**[RedStone Oracles](https://redstone.finance/)** – _RedStone est un oracle modulaire décentralisé qui fournit des flux de données optimisés pour le gaz. Il est spécialisé dans la fourniture de flux de prix pour des actifs émergents, tels que les jetons de mise en jeu liquide (LST), les jetons de restaking liquide (LRT) et les dérivés de mise en jeu de Bitcoin._
+**[RedStone Oracles](https://redstone.finance/)** - _RedStone est un oracle modulaire décentralisé qui fournit des flux de données optimisés pour le gaz._ Il est spécialisé dans la fourniture de flux de prix pour des actifs émergents, tels que les jetons de mise en jeu liquide (LST), les jetons de restaking liquide (LRT) et les dérivés de mise en jeu de Bitcoin._
 
-**[Chronicle](https://chroniclelabs.org/)** - _Chronicle surmonte les limitations actuelles du transfert de données sur la chaîne en développant des oracles véritablement évolutifs, rentables, décentralisés et vérifiables._
+**[Chronicle](https://chroniclelabs.org/)** - _Chronicle surmonte les limitations actuelles du transfert de données en chaîne en développant des oracles véritablement évolutifs, rentables, décentralisés et vérifiables._
 
 **[Witnet](https://witnet.io/)** - _Witnet est un oracle sans permission, décentralisé et résistant à la censure, qui aide les contrats intelligents à réagir aux événements du monde réel avec de solides garanties crypto-économiques._
 
-**[UMA Oracle](https://uma.xyz)** - _L'oracle optimiste d'UMA permet aux contrats intelligents de recevoir rapidement tout type de données pour différentes applications, notamment les assurances, les produits dérivés financiers et les marchés prédictifs._
+**[Oracle UMA](https://uma.xyz)** - _L'oracle optimiste d'UMA permet aux contrats intelligents de recevoir rapidement tout type de données pour différentes applications, notamment les assurances, les produits financiers dérivés et les marchés prédictifs._
 
 **[Tellor](https://tellor.io/)** - _Tellor est un protocole oracle transparent et sans permission permettant à votre contrat intelligent d'obtenir facilement toutes les données dont il a besoin._
 
 **[Band Protocol](https://bandprotocol.com/)** - _Band Protocol est une plateforme d'oracle de données inter-chaînes qui agrège et connecte les données du monde réel et les API aux contrats intelligents._
 
-**[Pyth Network](https://pyth.network/)** - _Pyth network est un réseau d'oracles financiers de premier ordre conçu pour publier des données réelles continues sur la chaîne dans un environnement inviolable, décentralisé et autonome._
+**[Pyth Network](https://pyth.network/)** - _Le réseau Pyth est un réseau d'oracles financiers de premier ordre conçu pour publier des données du monde réel en continu et en chaîne dans un environnement inviolable, décentralisé et autonome._
 
-**[API3 DAO](https://www.api3.org/)** - _L'API3 DAO permet d'apporter des solutions de service d'oracle de premier plan, et d'optimiser la transparence, la fiabilité, la sécurité et la scalabilité des données, dans une solution décentralisée dédiée aux contrats intelligents._
+**[API3 DAO](https://www.api3.org/)** - _L'API3 DAO fournit des solutions d'oracle de première partie qui offrent une plus grande transparence des sources, une sécurité et une évolutivité accrues dans une solution décentralisée pour les contrats intelligents_
 
-**[Supra](https://supra.com/)** - Un ensemble d'outils vertical intégré de solutions inter-chaînes qui relient toutes les blockchains, publiques (couches de niveau 1 et 2) ou privées (entreprises), fournissant des flux de prix d'oracle décentralisés pouvant être employés dans des cas d'utilisation sur la chaîne et hors chaîne.
+**[Supra](https://supra.com/)** - Une boîte à outils verticalement intégrée de solutions inter-chaînes qui relient toutes les blockchains, publiques (L1 et L2) ou privées (entreprises), fournissant des flux de prix d'oracle décentralisés qui peuvent être utilisés pour des cas d'utilisation en chaîne et hors chaîne.
 
-## Lecture complémentaire {#further-reading}
+**[Gas Network](https://gas.network/)** - Une plateforme d'oracle distribuée fournissant des données en temps réel sur le prix du gaz à travers la blockchain. En apportant en chaîne les données des principaux fournisseurs de données sur le prix du gaz, Gas Network contribue à l'interopérabilité. Gas Network prend en charge les données de plus de 35 chaînes, y compris le réseau principal Ethereum et de nombreuses L2 de premier plan.
+
+**[DIA](https://www.diadata.org/)** - A cross-chain oracle network delivering verifiable data feeds for 20,000+ assets across all major asset classes. DIA sources raw trade data directly from 100+ primary markets and computes it onchain, ensuring complete data transparency and verifiability with custom configurations for any use case.
+
+**[Stork](https://stork.network)** - Stork delivers price data at ultra-low latency, supporting a wide range of use cases including perpetuals markets, lending protocols, and DeFi ecosystems, with new assets supported rapidly on listing.
+
+## En savoir plus {#further-reading}
 
 **Articles**
 
-- [Qu'est-ce qu'un Oracle Blockchain ?](https://chain.link/education/blockchain-oracles) — _Chainlink_
-- [Qu'est-ce qu'un Oracle Blockchain ?](https://betterprogramming.pub/what-is-a-blockchain-oracle-f5ccab8dbd72) — _Patrick Collins_
-- [Oracles décentralisés : un aperçu complet](https://medium.com/fabric-ventures/decentralised-oracles-a-comprehensive-overview-d3168b9a8841) — _Julien Thevenard_
-- [Implémentation d'un Oracle Blockchain sur Ethereum](https://medium.com/@pedrodc/implementing-a-blockchain-oracle-on-ethereum-cedc7e26b49e) – _Pedro Costa_
-- [Pourquoi les contrats intelligents ne peuvent-ils pas faire d'appels d'API ?](https://ethereum.stackexchange.com/questions/301/why-cant-contracts-make-api-calls) — _StackExchange_
-- [Vous voulez donc utiliser un oracle de prix](https://samczsun.com/so-you-want-to-use-a-price-oracle/) — _samczsun_
+- [Qu'est-ce qu'un oracle de blockchain ?](https://chain.link/education/blockchain-oracles) — _Chainlink_
+- [Qu'est-ce qu'un oracle de blockchain ?](https://medium.com/better-programming/what-is-a-blockchain-oracle-f5ccab8dbd72) — _Patrick Collins_
+- [Oracles décentralisés : une vue d'ensemble complète](https://medium.com/fabric-ventures/decentralised-oracles-a-comprehensive-overview-d3168b9a8841) — _Julien Thevenard_
+- [Implémenter un oracle de blockchain sur Ethereum](https://medium.com/@pedrodc/implementing-a-blockchain-oracle-on-ethereum-cedc7e26b49e) – _Pedro Costa_
+- [Pourquoi les contrats intelligents ne peuvent-ils pas effectuer d'appels API ?](https://ethereum.stackexchange.com/questions/301/why-cant-contracts-make-api-calls) — _StackExchange_
+- [Alors vous voulez utiliser un oracle de prix](https://samczsun.com/so-you-want-to-use-a-price-oracle/) — _samczsun_
 
 **Vidéos**
 
 - [Les oracles et l'expansion de l'utilité de la blockchain](https://youtu.be/BVUZpWa8vpw) — _Real Vision Finance_
-- [Les divergences conceptuelles entre des services d'oracles de premier plan et ses services tiers](https://blockchainoraclesummit.io/first-party-vs-third-party-oracles/) - _Blockchain Summit autour du sujet des Oracles_
 
 **Tutoriels**
 
-- [Comment obtenir le prix actuel d'Ethereum dans Solidity ?](https://blog.chain.link/fetch-current-crypto-price-data-solidity/) — _Chainlink_
-- [Consommation de données d'oracle](https://docs.chroniclelabs.org/Developers/tutorials/Remix) — _Chronicle_
+- [Comment récupérer le prix actuel d'Ethereum en Solidity](https://blog.chain.link/fetch-current-crypto-price-data-solidity/) — _Chainlink_
+- [Consommer les données d'un oracle](https://docs.chroniclelabs.org/Developers/tutorials/Remix) — _Chronicle_
 
 **Exemples de projets**
 
-- [Projet de démarrage complet Chainlink pour Ethereum en Solidity](https://github.com/hackbg/chainlink-fullstack) — _HackBG_
+- [Projet de démarrage Chainlink complet pour Ethereum en Solidity](https://github.com/hackbg/chainlink-fullstack) — _HackBG_
diff --git a/public/content/translations/fr/developers/docs/programming-languages/dart/index.md b/public/content/translations/fr/developers/docs/programming-languages/dart/index.md
index 8c915968829..f77a484d4b5 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/dart/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/dart/index.md
@@ -1,28 +1,32 @@
 ---
-title: Ethereum pour les développeurs Dart
-description: Apprendre à développer pour Ethereum avec le langage de programmation Dart
+title: "Ethereum pour les développeurs Dart"
+description: "Apprendre à développer pour Ethereum avec le langage de programmation Dart"
 lang: fr
 incomplete: true
 ---
 
-## Débuter avec les Contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
+## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
 
-## Tutos {#tutorials}
+## Tutoriels {#tutorials}
 
-- [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.  Écrire un contrat intelligent avec [Solidity](https://soliditylang.org/)
-  2.  É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
-- 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égration de MetaMask dans l'application Flutter avec Web3Modal de WalletConnect](https://www.youtube.com/watch?v=v_M2buHCpc4). Cette courte vidéo vous explique les étapes d'intégration de MetaMask dans vos applications Flutter avec la bibliothèque [Web3Modal](https://pub.dev/packages/web3modal_flutter) de WalletConnect
-- [Bootcamp pour développeurs Blockchain Mobile avec Solidity & Flutter](https://youtube.com/playlist?list=PL4V4Unlk5luhQ26ERO6hWEbcUwHDSSmVH) - Liste de cours pour développeurs blockchain full stack mobile
+- [Flutter and Blockchain – Hello World Dapp](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) vous guide à travers toutes les étapes pour commencer :
+  1. Écrire un contrat intelligent en [Solidity](https://soliditylang.org/)
+  2. Écrire une interface utilisateur avec Dart
+- [Building a Mobile dapp with Flutter](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) est beaucoup plus court, ce qui peut être préférable
+  si vous connaissez déjà les bases
+- Si vous préférez apprendre en regardant une vidéo, vous pouvez regarder [Build Your First Blockchain Flutter App](https://www.youtube.com/watch?v=3Eeh3pJ6PeA), qui dure environ une heure
+- Si vous êtes impatient, vous préférerez peut-être [Building a Blockchain Decentralized-app with Flutter and Dart on Ethereum](https://www.youtube.com/watch?v=jaMFEOCq_1s), qui ne dure qu'une vingtaine de minutes
+- [Integrating MetaMask in Flutter application with Web3Modal by WalletConnect](https://www.youtube.com/watch?v=v_M2buHCpc4) – cette courte vidéo vous présente les étapes de l'intégration de MetaMask dans vos applications Flutter avec la bibliothèque [Web3Modal](https://pub.dev/packages/web3modal_flutter) de WalletConnect
+- [Mobile Blockchain Developer Bootcamp Course With Solidity & Flutter](https://youtube.com/playlist?list=PL4V4Unlk5luhQ26ERO6hWEbcUwHDSSmVH) – playlist de cours pour développeur blockchain mobile full-stack
 
-## Travailler avec des clients Ethereum {#working-with-ethereum-clients}
+## Travailler avec les clients Ethereum {#working-with-ethereum-clients}
 
-Vous pouvez utiliser Ethereum pour créer des applications décentralisées (ou « dApps ») qui utilisent les avantages de la technologie des cryptomonnaies et de la blockchain. Il existe au moins deux bibliothèques actuellement maintenues pour Dart permettant d'utiliser l'API [JSON-RPC](/developers/docs/apis/json-rpc/) pour Ethereum.
+Vous pouvez utiliser Ethereum pour créer des applications décentralisées (ou « dApps ») qui utilisent les avantages de la technologie des cryptomonnaies et de la blockchain.
+Il existe au moins deux bibliothèques actuellement maintenues pour Dart pour utiliser l'
+[API JSON-RPC](/developers/docs/apis/json-rpc/) pour Ethereum.
 
-1. [Web3dart par simonbutler.eu](https://pub.dev/packages/web3dart)
-1. [Ethereum 5.0.0 par darticulate.com](https://pub.dev/packages/ethereum)
+1. [Web3dart par pwa.ir](https://pub.dev/packages/web3dart)
+2. [Ethereum 5.0.0 par darticulate.com](https://pub.dev/packages/ethereum)
 
-Il existe également des bibliothèques supplémentaires qui vous permettent de manipuler des adresses Ethereum spécifiques, ou qui vous permettent de récupérer les prix de différentes cryptomonnaies. [Vous pouvez consulter la liste complète ici](https://pub.dev/dart/packages?q=ethereum).
+Il existe également des bibliothèques supplémentaires qui vous permettent de manipuler des adresses Ethereum spécifiques, ou qui vous permettent de récupérer les prix de différentes cryptomonnaies.
+[Vous pouvez consulter la liste complète ici](https://pub.dev/dart/packages?q=ethereum).
diff --git a/public/content/translations/fr/developers/docs/programming-languages/delphi/index.md b/public/content/translations/fr/developers/docs/programming-languages/delphi/index.md
index 54577f0c86c..eb301a8f98b 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/delphi/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/delphi/index.md
@@ -1,6 +1,6 @@
 ---
-title: Ethereum pour les développeurs Delphi
-description: Apprendre à développer pour Ethereum avec le langage de programmation Delphi
+title: "Ethereum pour les développeurs Delphi"
+description: "Apprendre à développer pour Ethereum avec le langage de programmation Delphi"
 lang: fr
 incomplete: true
 ---
@@ -11,7 +11,7 @@ Apprendre à développer pour Ethereum avec le langage de programmation Delphi
 
 </FeaturedText>
 
-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.
+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 !
 
@@ -19,38 +19,38 @@ Créez des applications décentralisées sur Ethereum et interagissez avec des c
 
 **Commencer à intégrer Delphi à Ethereum**
 
-Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
+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 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)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment compiler et déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
 
-## Références et liens pour les débutants {#beginner-references-and-links}
+## Références et liens pour débutants {#beginner-references-and-links}
 
 **Présentation de la bibliothèque Delphereum**
 
 - [Qu'est-ce que Delphereum ?](https://github.com/svanas/delphereum/blob/master/README.md)
-- [Connecter Delphi à une blockchain locale (en mémoire)](https://medium.com/@svanas/connecting-delphi-to-a-local-in-memory-blockchain-9a1512d6c5b0)
-- [Connecter Delphi au réseau principal Ethereum](https://medium.com/@svanas/connecting-delphi-to-the-ethereum-main-net-5faf1feffd83)
-- [Connecter Delphi à des contrats intelligents](https://medium.com/@svanas/connecting-delphi-to-smart-contracts-3146b12803a1)
+- [Connexion de Delphi à une blockchain locale (en mémoire)](https://medium.com/@svanas/connecting-delphi-to-a-local-in-memory-blockchain-9a1512d6c5b0)
+- [Connexion de Delphi au réseau principal d'Ethereum](https://medium.com/@svanas/connecting-delphi-to-the-ethereum-main-net-5faf1feffd83)
+- [Connexion de Delphi aux contrats intelligents](https://medium.com/@svanas/connecting-delphi-to-smart-contracts-3146b12803a1)
 
 **Vous voulez éviter toute configuration pour l'instant et accéder directement aux échantillons ?**
 
-- [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)
+- [Un contrat intelligent en 3 minutes avec Delphi - Partie 1](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-61d998571d)
+- [Un contrat intelligent en 3 minutes avec Delphi - Partie 2](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-part-2-446925faa47b)
 
 ## 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)
+- [Génération d'une signature de message signé 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)
 - [Transfert de jetons ERC-20 avec Delphi](https://medium.com/@svanas/transferring-erc-20-tokens-with-delphi-bb44c05b295d)
 
 ## Modèles d'utilisation avancés {#advanced-use-patterns}
 
-- [Delphi et Ethereum Name Service (ENS)](https://medium.com/@svanas/delphi-and-ethereum-name-service-ens-4443cd278af7)
+- [Delphi et l'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)
+- [Échanger un jeton contre un autre dans Delphi](https://svanas.medium.com/swap-one-token-for-another-in-delphi-bcb999c47f7)
 
-Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/).
+Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers](/developers/).
diff --git a/public/content/translations/fr/developers/docs/programming-languages/dot-net/index.md b/public/content/translations/fr/developers/docs/programming-languages/dot-net/index.md
index d59f4a7bfe5..8ce7c773acd 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/dot-net/index.md
+++ b/public/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 pour Ethereum avec des projets et des outils basés sur .NET
+title: "Ethereum pour les développeurs .NET"
+description: "Apprendre à développer pour Ethereum avec des projets et des outils basés sur .NET"
 lang: fr
 incomplete: true
 ---
 
-<FeaturedText>Apprendre à développer pour Ethereum avec des projets et des outils basés sur .NET</FeaturedText>
+<FeaturedText>Apprenez à développer pour Ethereum en utilisant des projets et des outils basés sur .NET</FeaturedText>
 
-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.
+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 !
 
@@ -15,44 +15,44 @@ Construisez des applications décentralisées sur Ethereum et interagissez avec
 
 **Commencer à intégrer .NET à Ethereum**
 
-Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/).
+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 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)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment compiler et déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
 
-## Références et liens pour les débutants {#beginner-references-and-links}
+## Références et liens pour débutants {#beginner-references-and-links}
 
 **Présentation de la bibliothèque Nethereum et de VS Code Solidity**
 
-- [Commencer avec Nethereum](https://docs.nethereum.com/en/latest/getting-started/)
-- [Installation VS code Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
-- [Flux de travail du développeur .NET pour la création et l'appel de contrats intelligents Ethereum](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
+- [Nethereum, Getting Started](https://docs.nethereum.com/en/latest/getting-started/)
+- [Installation de VS Code Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
+- [Flux de travail d'un développeur .NET pour la création et l'appel de contrats intelligents Ethereum](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
 - [Intégration de contrats intelligents avec Nethereum](https://kauri.io/#collections/Getting%20Started/smart-contracts-integration-with-nethereum/#smart-contracts-integration-with-nethereumm)
-- [Interfacer .NET et les contrats intelligents de la blockchain Ethereum avec Nethereum](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933), également en [中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1)
-- [Nethereum : une bibliothèque d'intégration .NET open source pour la blockchain](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
-- [Écriture de transactions Ethereum dans une base de données SQL à l'aide de Nethereum](https://medium.com/coinmonks/writing-ethereum-transactions-to-sql-database-using-nethereum-fd94e0e4fa36)
-- [See how to easily deploy Ethereum smart contracts using C# and VisualStudio](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
+- [Interfaçage de .NET et des contrats intelligents de la blockchain Ethereum avec Nethereum](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933), également en [中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1)
+- [Nethereum - Une bibliothèque d'intégration .NET open source pour la blockchain](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
+- [Écriture de transactions Ethereum dans une base de données SQL avec Nethereum](https://medium.com/coinmonks/writing-ethereum-transactions-to-sql-database-using-nethereum-fd94e0e4fa36)
+- [Découvrez comment déployer facilement des contrats intelligents Ethereum en utilisant C# et VisualStudio](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
 
 **Vous voulez éviter toute configuration pour l'instant et accéder directement aux échantillons ?**
 
-- [Playground](http://playground.nethereum.com/) - Interagir avec Ethereum et apprendre à utiliser Nethereum dans le navigateur
-  - Requête de solde d'un compte [C#](http://playground.nethereum.com/csharp/id/1001) [VB.NET](http://playground.nethereum.com/vb/id/2001)
-  - Requête de solde d'un contrat intelligent ERC20[C#](http://playground.nethereum.com/csharp/id/1005) [VB.NET](http://playground.nethereum.com/vb/id/2004)
-  - 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)
+- [Playground](http://playground.nethereum.com/) - Interagissez avec Ethereum et apprenez à utiliser Nethereum via le navigateur.
+  - Interroger le solde du compte [C#](http://playground.nethereum.com/csharp/id/1001) [VB.NET](http://playground.nethereum.com/vb/id/2001)
+  - Interroger le solde d'un contrat intelligent ERC20 [C#](http://playground.nethereum.com/csharp/id/1005) [VB.NET](http://playground.nethereum.com/vb/id/2004)
+  - Transférer de l'éther vers un compte [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
   - ... Et bien plus encore !
 
 ## 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)
+- [Classeur/Liste d'exemples Nethereum](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
+- [Déployez vos propres chaînes de test de développement](https://github.com/Nethereum/Testchains)
 - [Plugin VSCode Codegen pour Solidity](https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/)
-- [Unity et Ethereum : pourquoi et comment](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
-- [Créer une API Web ASP.NET Core pour les dApps Ethereum](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
+- [Unity et Ethereum : pourquoi et comment](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
+- [Créer une API Web ASP.NET Core pour les dapps Ethereum](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
 - [Utilisation de Nethereum Web3 pour mettre en œuvre un système de suivi de la chaîne d'approvisionnement](http://blog.pomiager.com/post/using-nethereum-web3-to-implement-a-supply-chain-traking-system4)
-- [Traitement des blocs de Nethereum](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/), avec échantillon [C# Playground](http://playground.nethereum.com/csharp/id/1025)
-- [Diffusion du Websocket de Nethereum](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
+- [Traitement des blocs Nethereum](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/), avec [exemple sur C# Playground](http://playground.nethereum.com/csharp/id/1025)
+- [Streaming Websocket Nethereum](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
 - [Kaleido et Nethereum](https://kaleido.io/kaleido-and-nethereum/)
 - [Quorum et Nethereum](https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.Quorum/README.md)
 
@@ -60,27 +60,27 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea
 
 - [Azure Key Vault et Nethereum](https://github.com/Azure-Samples/bc-community-samples/tree/master/akv-nethereum)
 - [Nethereum.DappHybrid](https://github.com/Nethereum/Nethereum.DappHybrid)
-- [Architecture de référence backend Ujo Nethereum](https://docs.nethereum.com/en/latest/nethereum-ujo-backend-sample/)
+- [Architecture de référence du backend Ujo Nethereum](https://docs.nethereum.com/en/latest/nethereum-ujo-backend-sample/)
 
-## Projets .NET, outils et autres trucs amusants {#dot-net-projects-tools-and-other-fun-stuff}
+## Projets .NET, outils et autres choses amusantes {#dot-net-projects-tools-and-other-fun-stuff}
 
 - [Nethereum Playground](http://playground.nethereum.com/) - _Compilez, créez et exécutez des extraits de code Nethereum dans le navigateur_
-- [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_
+- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) - _Codegen Nethereum avec une interface utilisateur en Blazor_
+- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) - _Un explorateur de blockchain léger Wasm SPA .NET et un portefeuille simple_
+- [Wonka Business Rules Engine](https://docs.nethereum.com/en/latest/wonka/) - _Un moteur de règles métier (pour la plateforme .NET et la plateforme Ethereum) qui est intrinsèquement piloté par les métadonnées_
+- [Nethermind](https://github.com/NethermindEth/nethermind) - _Un client Ethereum .NET Core 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)_
 
-Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/).
+Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers](/developers/).
 
-## Contributeurs de la Communauté .NET {#dot-net-community-contributors}
+## 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 à 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) !
+Chez Nethereum, nous nous retrouvons principalement sur [Gitter](https://gitter.im/Nethereum/Nethereum), où tout le monde est le bienvenu pour poser des questions ou y répondre, obtenir de l'aide ou 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 retrouver sur [Discord](https://discord.gg/jQPrR58FxX) !
 
-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).
+Si vous découvrez Nethermind et avez besoin d'aide pour commencer, 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 [dépôt GitHub de Nethermind](https://github.com/NethermindEth/nethermind).
 
-## Autres ressources {#other-aggregated-lists}
+## Autres listes agrégées {#other-aggregated-lists}
 
 [Site officiel de Nethereum](https://nethereum.com/)  
 [Site officiel de Nethermind](https://nethermind.io/)
diff --git a/public/content/translations/fr/developers/docs/programming-languages/elixir/index.md b/public/content/translations/fr/developers/docs/programming-languages/elixir/index.md
index 8aa8af88a20..4b9fb386c03 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/elixir/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/elixir/index.md
@@ -1,13 +1,13 @@
 ---
-title: Ethereum pour les Développeurs Elixir
-description: Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Elixir.
+title: "Ethereum pour les Développeurs Elixir"
+description: "Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Elixir."
 lang: fr
 incomplete: false
 ---
 
 <FeaturedText>Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Elixir.</FeaturedText>
 
-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.
+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}
 
diff --git a/public/content/translations/fr/developers/docs/programming-languages/golang/index.md b/public/content/translations/fr/developers/docs/programming-languages/golang/index.md
index 4ea67e73853..3a898d43684 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/golang/index.md
+++ b/public/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 pour Ethereum avec des projets et des outils basés sur Go
+title: "Ethereum pour les développeurs Go"
+description: "Apprendre à développer pour Ethereum avec des projets et des outils basés sur Go"
 lang: fr
 incomplete: true
 ---
 
-<FeaturedText>Apprendre à développer pour Ethereum avec des projets et des outils basés sur Go</FeaturedText>
+<FeaturedText>Apprenez à développer pour Ethereum en utilisant des projets et des outils basés sur Go</FeaturedText>
 
-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}
 
@@ -15,70 +15,70 @@ 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 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)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment compiler et déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
 - [Tutoriel de contrat](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial)
 
-## Articles et livres pour les débutants {#beginner-articles-and-books}
+## Articles et livres pour débutants {#beginner-articles-and-books}
 
-- [Commencer avec Geth](https://medium.com/@tzhenghao/getting-started-with-geth-c1a30b8d6458)
+- [Démarrer avec Geth](https://medium.com/@tzhenghao/getting-started-with-geth-c1a30b8d6458)
 - [Utiliser Golang pour se connecter à Ethereum](https://www.youtube.com/watch?v=-7uChuO_VzM)
 - [Déployer des contrats intelligents Ethereum en utilisant Golang](https://www.youtube.com/watch?v=pytGqQmDslE)
-- [Un guide étape par étape pour tester et déployer des contrats intelligents Ethereum avec Go](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
-- [eBook&nbsp;: Développement d'Ethereum avec Go](https://goethereumbook.org/) - _Développer des applications Ethereum avec Go_
+- [Un guide étape par étape pour tester et déployer des contrats intelligents Ethereum en Go](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
+- [eBook : Développement Ethereum avec Go](https://goethereumbook.org/) - _Développer des applications Ethereum avec Go_
 
-## Articles et documentation de niveau intermédiaire {#intermediate-articles-and-docs}
+## Articles et documents intermédiaires {#intermediate-articles-and-docs}
 
-- [Documentation Go Ethereum](https://geth.ethereum.org/docs/) - _Documentation Ethereum officielle pour Go_
-- [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 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)
+- [Documentation Go Ethereum](https://geth.ethereum.org/docs/) - _La documentation officielle d'Ethereum pour Golang_
+- [Guide du programmeur Erigon](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _Guide illustré incluant l'arbre d'état, les preuves multiples 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)_
+- [Go Ethereum GoDoc](https://godoc.org/github.com/ethereum/go-ethereum)
+- [Créer une dapp en Go avec Geth](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
+- [Travailler avec un 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)
+- [Tests unitaires de contrats Solidity sur Ethereum avec Go](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281)
+- [Référence rapide pour l'utilisation de Geth comme bibliothèque](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
 
 ## Modèles d'utilisation avancés {#advanced-use-patterns}
 
-- [Le backend GETH simulé](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
-- [Applications de type blockchain en tant que service utilisant Ethereum et Quorum](https://blockchain.dcwebmakers.com/blockchain-as-a-service-apps-using-ethereum-and-quorum.html)
+- [Le backend simulé de GETH](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
+- [Applications Blockchain-as-a-Service utilisant Ethereum et Quorum](https://blockchain.dcwebmakers.com/blockchain-as-a-service-apps-using-ethereum-and-quorum.html)
 - [Stockage distribué IPFS et Swarm dans les applications de la blockchain Ethereum](https://blockchain.dcwebmakers.com/work-with-distributed-storage-ipfs-and-swarm-in-ethereum.html)
-- [Clients mobiles : bibliothèques et nœuds Ethereum d'Inproc](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
-- [dApps natives : liaisons Go aux contrats Ethereum](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
-
-## Outils et projets Go {#go-projects-and-tools}
-
-- [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, 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_
-- [Eth Tweet](https://github.com/yep/eth-tweet) - _Twitter décentralisé&nbsp;: 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_
-- [SDK Golang Covalent](https://github.com/covalenthq/covalent-api-sdk-go) - _Accès efficace aux données blockchain via Go SDK pour plus de 200 blockchains_
-
-Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/)
+- [Clients mobiles : bibliothèques et nœuds Ethereum Inproc](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
+- [Dapps natives : liaisons Go vers des contrats Ethereum](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
+
+## Projets et outils Go {#go-projects-and-tools}
+
+- [Geth / Go Ethereum](https://github.com/ethereum/go-ethereum) - _Implémentation Go officielle du protocole Ethereum_
+- [Analyse du code de Go Ethereum](https://github.com/ZtesoftCS/go-ethereum-code-analysis) - _Examen et analyse du code source de Go Ethereum_
+- [Erigon](https://github.com/ledgerwatch/erigon) - _Dérivé plus rapide de Go Ethereum, axé sur les nœuds d'archive_
+- [Golem](https://github.com/golemfactory/golem) - _Golem crée un marché mondial pour la puissance de calcul_
+- [Quorum](https://github.com/jpmorganchase/quorum) - _Une implémentation d'Ethereum soumise à des autorisations, qui prend en charge la confidentialité des données_
+- [Prysm](https://github.com/prysmaticlabs/prysm) - _Implémentation Go d'Ethereum « Serenity » 2.0_
+- [Eth Tweet](https://github.com/yep/eth-tweet) - _Twitter décentralisé : un 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) - _Un pool de minage Ethereum open source_
+- [Portefeuille HD Ethereum](https://github.com/miguelmota/go-ethereum-hdwallet) - _Dérivations de portefeuille HD Ethereum en Go_
+- [Multi Geth](https://github.com/multi-geth/multi-geth) - _Prise en charge de nombreux types de réseaux Ethereum_
+- [Client léger Geth](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) - _Implémentation Geth du sous-protocole léger d'Ethereum_
+- [SDK Ethereum Golang](https://github.com/everFinance/goether) - _Une implémentation simple de portefeuille Ethereum et des utilitaires en Golang_
+- [SDK Golang Covalent](https://github.com/covalenthq/covalent-api-sdk-go) - _Accès efficace aux données de la blockchain via le SDK Go pour plus de 200 blockchains_
+
+Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers](/developers/)
 
 ## Contributeurs de la communauté Go {#go-community-contributors}
 
-- [Discord de Geth](https://discordapp.com/invite/nthXNEv)
-- [Gist de Geth](https://gitter.im/ethereum/go-ethereum)
-- [Slack de Gophers](https://invite.slack.golangbridge.org/) - [#ethereum channel](https://gophers.slack.com/messages/C9HP1S9V2)
+- [Geth Discord](https://discordapp.com/invite/nthXNEv)
+- [Geth Gitter](https://gitter.im/ethereum/go-ethereum)
+- [Slack Gophers](https://invite.slack.golangbridge.org/) - [Canal #ethereum](https://gophers.slack.com/messages/C9HP1S9V2)
 - [StackExchange - Ethereum](https://ethereum.stackexchange.com/)
-- [Gitter de Multi Geth](https://gitter.im/ethoxy/multi-geth)
-- [Gitter d'Ethereum](https://gitter.im/ethereum/home)
-- [Client Gitter Light de Geth](https://gitter.im/ethereum/light-client)
+- [Multi Geth Gitter](https://gitter.im/ethoxy/multi-geth)
+- [Ethereum Gitter](https://gitter.im/ethereum/home)
+- [Gitter du client léger Geth](https://gitter.im/ethereum/light-client)
 
-## Autres ressources {#other-aggregated-lists}
+## Autres listes agrégées {#other-aggregated-lists}
 
-- [Génial Ethereum](https://github.com/btomashvili/awesome-ethereum)
-- [Consensys : une liste définitive des outils pour les développeurs d'Ethereum](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [Source GitHub](https://github.com/ConsenSys/ethereum-developer-tools-list)
+- [Awesome Ethereum](https://github.com/btomashvili/awesome-ethereum)
+- [Consensys : une liste définitive des outils de développement Ethereum](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [Source GitHub](https://github.com/ConsenSys/ethereum-developer-tools-list)
diff --git a/public/content/translations/fr/developers/docs/programming-languages/index.md b/public/content/translations/fr/developers/docs/programming-languages/index.md
index 0070122f248..f7133d73b66 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/index.md
@@ -1,10 +1,11 @@
 ---
 title: Langages de programmation
-description:
+description: "Découvrez les ressources de développement Ethereum pour divers langages de programmation, tels que JavaScript, Python, Go, Rust, etc."
 lang: fr
 ---
 
-On croit souvent à tort que les développeurs doivent écrire des [contrats intelligents](/developers/docs/smart-contracts/) pour participer à Ethereum. C'est faux. L'une des choses formidables concernant le réseau et la communauté Ethereum, c'est que vous pouvez [participer](/community/) en utilisant presque n'importe quel langage de programmation.
+Une idée reçue courante est que les développeurs doivent écrire des [contrats intelligents](/developers/docs/smart-contracts/) pour pouvoir développer sur Ethereum. C'est faux.
+L'un des grands avantages du réseau et de la communauté Ethereum est que vous pouvez [participer](/community/) avec quasiment n'importe quel langage de programmation.
 
 Ethereum et sa communauté ont adopté l'open source. Vous pouvez trouver des projets communautaires (implémentations de clients, API, frameworks de développement, outils de test) dans une grande variété de langages.
 
@@ -23,8 +24,9 @@ Sélectionnez le langage de programmation qui vous intéresse pour trouver des p
 - [Ethereum pour les développeurs Ruby](/developers/docs/programming-languages/ruby/)
 - [Ethereum pour les développeurs Rust](/developers/docs/programming-languages/rust/)
 
-### Que faire si ma langue n'est pas prise en charge {#other-lang}
+### Que faire si mon langage n'est pas pris en charge {#other-lang}
 
-Si vous souhaitez créer un lien vers des ressources ou pointer vers une communauté virtuelle pour un langage de programmation supplémentaire, vous pouvez demander une nouvelle page en [signalant un problème](https://github.com/ethereum/ethereum-org-website/issues/new/choose).
+Si vous souhaitez ajouter des liens vers des ressources ou indiquer une communauté virtuelle pour un langage de programmation supplémentaire, vous pouvez demander une nouvelle page en [ouvrant une issue](https://github.com/ethereum/ethereum-org-website/issues/new/choose).
 
-Si vous souhaitez juste écrire du code pour interfacer avec la blockchain en utilisant une langue actuellement non prise en charge vous pouvez utiliser l'interface [JSON-RPC](/developers/docs/apis/json-rpc/) pour vous connecter au réseau Ethereum. N'importe quel langage de programmation pouvant utiliser TCP/IP peut utiliser cette interface.
+Si vous voulez simplement écrire du code pour interagir avec la blockchain en utilisant un langage actuellement non pris en charge,
+vous pouvez utiliser l'interface [JSON-RPC](/developers/docs/apis/json-rpc/) pour vous connecter au réseau Ethereum. N'importe quel langage de programmation pouvant utiliser TCP/IP peut utiliser cette interface.
diff --git a/public/content/translations/fr/developers/docs/programming-languages/java/index.md b/public/content/translations/fr/developers/docs/programming-languages/java/index.md
index 18a28016b41..7e0e37152ae 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/java/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/java/index.md
@@ -1,57 +1,58 @@
 ---
-title: Ethereum pour les développeurs Java
-description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java
+title: "Ethereum pour les développeurs Java"
+description: "Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java"
 lang: fr
 incomplete: true
 ---
 
-<FeaturedText>Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java</FeaturedText>
+<FeaturedText>Apprenez à développer pour Ethereum en utilisant des projets et des outils basés sur Java</FeaturedText>
 
-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.
+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}
 
 **Première étapes pour intégrer Java à Ethereum**
 
-Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/)
+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 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)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment compiler et déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
 
-## Travailler avec des clients Ethereum {#working-with-ethereum-clients}
+## Travailler avec les clients Ethereum {#working-with-ethereum-clients}
 
-Apprenez à utiliser [Web3J](https://github.com/web3j/web3j) et Hyperledger Besu, deux des principaux clients Ethereum Java.
+Apprenez à utiliser [Web3J](https://github.com/web3j/web3j) et Hyperledger Besu, deux des principaux clients Ethereum Java
 
-- [Connexion à un client Ethereum avec Java, Eclipse et Web3J](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j)
+- [Se connecter à un client Ethereum avec Java, Eclipse et Web3J](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j)
 - [Gérer un compte Ethereum avec Java et Web3j](https://kauri.io/article/925d923e12c543da9a0a3e617be963b4/manage-an-ethereum-account-with-java-and-web3j)
 - [Générer un wrapper Java à partir de votre contrat intelligent](https://kauri.io/article/84475132317d4d6a84a2c42eb9348e4b/generate-a-java-wrapper-from-your-smart-contract)
 - [Interagir avec un contrat intelligent Ethereum](https://kauri.io/article/14dc434d11ef4ee18bf7d57f079e246e/interacting-with-an-ethereum-smart-contract-in-java)
-- [Écoute des événements du contrat intelligent Ethereum](https://kauri.io/article/760f495423db42f988d17b8c145b0874/listening-for-ethereum-smart-contract-events-in-java)
-- [Utilisation de Besu (Pantheon), le client Java d'Ethereum avec Linux](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
-- [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](https://kauri.io/web3j-cheat-sheet-(java-ethereum)/5dfa1ea941ac3d0001ce1d90/c)
+- [Écouter les événements de contrat intelligent Ethereum](https://kauri.io/article/760f495423db42f988d17b8c145b0874/listening-for-ethereum-smart-contract-events-in-java)
+- [Utiliser Besu (Pantheon), le client Ethereum Java avec Linux](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
+- [Exécuter un nœud Hyperledger Besu (Pantheon) dans des tests d'intégration Java](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
+- [Aide-mémoire Web3j](https://kauri.io/web3j-cheat-sheet-\(java-ethereum\)/5dfa1ea941ac3d0001ce1d90/c)
 
-Apprenez à utiliser [ethers-kt](https://github.com/Kr1ptal/ethers-kt), une bibliothèque Kotlin asynchrone et de haute performance pour interagir avec les blockchains basées sur l'EVM. Ciblez les plateformes JVM et Android.
-- [Transfert de jetons ERC20](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/abi/TransferERC20.kt)
-- [Échange UniswapV2 avec événements audio](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
-- [Suivi ETH / ERC20](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
+Apprenez à utiliser [ethers-kt](https://github.com/Kr1ptal/ethers-kt), une bibliothèque Kotlin asynchrone et très performante pour interagir avec les blockchains basées sur l'EVM. Ciblez les plateformes JVM et Android.
+
+- [Transférer des jetons ERC20](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/abi/TransferERC20.kt)
+- [Échange UniswapV2 avec écoute d'événements](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
+- [Suivi de solde ETH / ERC20](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
 
 ## 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)
-- [Web3j Transaction Managers](https://kauri.io/article/4cb780bb4d0846438d11885a25b6d7e7/web3j-transaction-managers)
+- [Gérer le stockage dans une application Java avec IPFS](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
+- [Gérer les jetons ERC20 en Java avec Web3j](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j)
+- [Gestionnaires de transactions Web3j](https://kauri.io/article/4cb780bb4d0846438d11885a25b6d7e7/web3j-transaction-managers)
 
 ## Modèles d'utilisation avancés {#advanced-use-patterns}
 
-- [Utiliser Eventeum pour construire un cache de données de contrat intelligent Java](https://kauri.io/article/fe81ee9612eb4e5a9ab72790ef24283d/using-eventeum-to-build-a-java-smart-contract-data-cache)
+- [Utiliser Eventeum pour créer un cache de données de contrat intelligent Java](https://kauri.io/article/fe81ee9612eb4e5a9ab72790ef24283d/using-eventeum-to-build-a-java-smart-contract-data-cache)
 
-## Outils et projets Java {#java-projects-and-tools}
+## Projets et outils Java {#java-projects-and-tools}
 
 - [Web3J (Bibliothèque pour interagir avec les clients Ethereum)](https://github.com/web3j/web3j)
-- [ethers-kt (bibliothèque Kotlin/Java/Android asynchrone et de haute performance pour les blockchains basées sur l'EVM.)](https://github.com/Kr1ptal/ethers-kt)
+- [ethers-kt (bibliothèque Kotlin/Java/Android asynchrone et très performante pour les blockchains basées sur l'EVM.)](https://github.com/Kr1ptal/ethers-kt)
 - [Eventeum (Écouteur d'événements)](https://github.com/ConsenSys/eventeum)
 - [Mahuta (Outils de développement IPFS)](https://github.com/ConsenSys/mahuta)
 
diff --git a/public/content/translations/fr/developers/docs/programming-languages/javascript/index.md b/public/content/translations/fr/developers/docs/programming-languages/javascript/index.md
index 10cff7bf7dc..cfd265073a8 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/javascript/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/javascript/index.md
@@ -1,38 +1,39 @@
 ---
-title: Ethereum pour les développeurs JavaScript
-description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur JavaScript.
+title: "Ethereum pour les développeurs JavaScript"
+description: "Apprendre à développer pour Ethereum avec des projets et des outils basés sur JavaScript."
 lang: fr
 ---
 
-JavaScript est l'un des langages les plus populaires de l'écosystème Ethereum. Il existe même une [équipe](https://github.com/ethereumjs) dont le but est de développer autant d'Ethereum que possible en JavaScript.
+JavaScript est l'un des langages les plus populaires de l'écosystème Ethereum. En fait, il existe une [équipe](https://github.com/ethereumjs) qui se consacre à porter autant d'Ethereum que possible sur JavaScript.
 
-Il est possible de rédiger en JavaScript (ou en quelque chose d'approchant) à [tous les niveaux de la pile](/developers/docs/ethereum-stack/).
+Il est possible d'écrire du JavaScript (ou un langage approchant) à [tous les niveaux de la pile](/developers/docs/ethereum-stack/).
 
 ## Interagir avec Ethereum {#interact-with-ethereum}
 
 ### Bibliothèques d'API JavaScript {#javascript-api-libraries}
 
-Si vous souhaitez rédiger du JavaScript pour interroger la blockchain, envoyer des transactions et plus encore, la façon la plus pratique est d'utiliser une [bibliothèque d'API JavaScript](/developers/docs/apis/javascript/). Ces API permettent aux développeurs d'interagir facilement avec les [nœuds du réseau Ethereum](/developers/docs/nodes-and-clients/).
+Si vous souhaitez écrire du JavaScript pour interroger la blockchain, envoyer des transactions et plus encore, la façon la plus pratique est d'utiliser une [bibliothèque d'API JavaScript](/developers/docs/apis/javascript/). Ces API permettent aux développeurs d'interagir facilement avec les [nœuds du réseau Ethereum](/developers/docs/nodes-and-clients/).
 
 Exploitez ces bibliothèques pour interagir avec des contrats intelligents sur Ethereum afin de pouvoir construire une DApp dans laquelle vous utilisez juste JavaScript pour interagir avec des contrats existants.
 
-**N'hésitez pas à consulter les ressources suivantes :**
+**Découvrez**
 
-- [Web3.js](https://web3js.readthedocs.io/)
-- [Ethers.js](https://docs.ethers.io/) _- Comprend l'implémentation d'un portefeuille Ethereum et des utilitaires en JavaScript et TypeScript._
-- [viem](https://viem.sh) –est une proposition d'interface TypeScript pour Ethereum, fournissant des primitives permettant de programmer des opérations spécifiques, qui sont nécessaires pour interagir avec Ethereum.
+- [Web3.js](https://web3js.readthedocs.io)
+- [Ethers.js](https://ethers.org) – _comprend l'implémentation d'un portefeuille Ethereum et des utilitaires en JavaScript et en TypeScript._
+- [viem](https://viem.sh) – _une interface TypeScript pour Ethereum qui fournit des primitives de bas niveau sans état pour interagir avec Ethereum._
+- [Drift](https://ryangoree.github.io/drift/) – _une méta-bibliothèque TypeScript avec mise en cache, hooks et mocks de test intégrés pour un développement Ethereum sans effort sur les bibliothèques web3._
 
 ### Contrats intelligents {#smart-contracts}
 
-Si vous êtes un développeur JavaScript qui souhaite rédiger son propre contrat intelligent, nous vous conseillons de vous familiariser avec [Solidity](https://solidity.readthedocs.io). Il s'agit du langage de contrat intelligent le plus populaire et il est syntaxiquement similaire à JavaScript, ce qui peut en faciliter l'apprentissage.
+Si vous êtes un développeur JavaScript et que vous souhaitez écrire votre propre contrat intelligent, vous voudrez peut-être vous familiariser avec [Solidity](https://solidity.readthedocs.io). Il s'agit du langage de contrat intelligent le plus populaire et il est syntaxiquement similaire à JavaScript, ce qui peut en faciliter l'apprentissage.
 
-Plus d'infos sur les [contrats intelligents](/developers/docs/smart-contracts/).
+En savoir plus sur les [contrats intelligents](/developers/docs/smart-contracts/).
 
 ## Comprendre le protocole {#understand-the-protocol}
 
-### La machine virtuelle Ethereum (EVM) {#the-ethereum-virtual-machine}
+### La Machine Virtuelle Ethereum {#the-ethereum-virtual-machine}
 
-Il existe une implémentation JavaScript de la [machine virtuelle Ethereum](/developers/docs/evm/). Elle prend en charge les dernières règles concernant les fourches. Les règles de fourche sont les modifications apportées à l'EVM suite à de mises à niveau planifiées.
+Il existe une implémentation JavaScript de la [machine virtuelle d'Ethereum](/developers/docs/evm/). Elle prend en charge les dernières règles concernant les fourches. Les règles de fourche sont les modifications apportées à l'EVM suite à de mises à niveau planifiées.
 
 Il existe différents packages JavaScript que vous pouvez consulter pour mieux comprendre :
 
@@ -40,23 +41,21 @@ Il existe différents packages JavaScript que vous pouvez consulter pour mieux c
 - Blocs
 - Blockchain
 - Transactions
-- Et plus encore...
+- et plus encore...
 
 Cela vous aidera à comprendre des concepts, comme la structure des données d'un compte.
 
 Si vous préférez lire du code, ce extrait JavaScript peut être une excellente alternative à la lecture de notre documentation.
 
-**Jetez un œil au monorepo**  
-[`ethereumjs`](https://github.com/ethereumjs/ethereumjs-vm)
+**Découvrez l'EVM**  
+[`@ethereumjs/evm`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/evm)
 
 ### Nœuds et clients {#nodes-and-clients}
 
 L'un des clients logiciels d'Ethereum se trouve actuellement en phase de test, vous permettant ainsi de découvrir le fonctionnement des clients de test d'Ethereum, dans un langage de programmation qui vous est propre : JavaScript !
 
-Il était jadis bâti sur des systèmes indépendants sur lesquels pouvaient être installés les systèmes d'exploitation hôte[`repository`](https://github.com/ethereumjs/ethereumjs-client), par contre, il a ensuite été implémenté en tant que paquet dans la monorepo de la machine virtuelle d'Ethereum.
-
-**Jetez un œil au client**  
-[`ethereumjs-client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client)
+**Découvrez le client**  
+[`@ethereumjs/client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client)
 
 ## Autres projets {#other-projects}
 
@@ -64,10 +63,10 @@ Plein d'autres choses voient le jour au pays d'Ethereum JavaScript, y compris :
 
 - des bibliothèques d'utilitaires pour les portefeuilles ;
 - 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.
+- une implémentation du `merkle-patricia-tree` – une structure de données décrite dans le Livre jaune d'Ethereum.
 
-Explorez ce qui vous intéresse le plus dans le répertoire[EthereumJS](https://github.com/ethereumjs).
+Explorez ce qui vous intéresse le plus sur le [dépôt EthereumJS](https://github.com/ethereumjs)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/programming-languages/python/index.md b/public/content/translations/fr/developers/docs/programming-languages/python/index.md
index 57c66ec0a34..4fcee3fb462 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/python/index.md
+++ b/public/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 pour Ethereum avec des projets et des outils basés sur Python
+title: "Ethereum pour les développeurs Python"
+description: "Apprendre à développer sur Ethereum avec des projets et des outils basés sur Python"
 lang: fr
 incomplete: true
 ---
 
-<FeaturedText>Apprendre à développer sur Ethereum avec des projets et des outils basés sur Python</FeaturedText>
+<FeaturedText>Apprenez à développer pour Ethereum en utilisant des projets et des outils basés sur Python</FeaturedText>
 
-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.
+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}
 
@@ -15,76 +15,85 @@ 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 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 une application avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment compiler et déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Rapport sur l'état de Python dans la blockchain en 2023](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
 
-## Articles pour les débutants {#beginner-articles}
+## Articles pour débutants {#beginner-articles}
 
-- [Guide du développeur (Python) pour Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
-- [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)
-- [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)
+- [Présentation de web3.py](https://web3py.readthedocs.io/en/latest/overview.html)
+- [Tour de l'écosystème Python d'Ethereum](https://snakecharmers.ethereum.org/python-ecosystem/)
+- [Guide du développeur (Python) sur Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
+- [Prize-Worthy : un guide de hackathon Ethereum Python](https://snakecharmers.ethereum.org/prize-worthy/)
+- [Une introduction aux contrats intelligents avec Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
+- [Comment développer un contrat Ethereum en utilisant Python et Flask ?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
+- [Introduction à Web3.py · Ethereum pour les développeurs Python](https://www.dappuniversity.com/articles/web3-py-intro)
+- [Comment appeler une fonction de 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)
 
 ## Articles intermédiaires {#intermediate-articles}
 
-- [Développement de dApp pour programmeurs Python](https://www.youtube.com/watch?v=tE-8bG35VNw)
-- [Création d'une interface Python Ethereum : 1ère partie](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
-- [Les contrats intelligents dans Python : un guide complet (ou presque)](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
-- [Utiliser Brownie et Python pour déployer des contrats intelligents](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
-- [Créer des NFT sur OpenSea avec Brownie](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
+- [Les amis de web3.py : introduction à Ape](https://snakecharmers.ethereum.org/intro-to-ape/)
+- [Développement de dapps pour les programmeurs Python](https://www.youtube.com/watch?v=tE-8bG35VNw)
+- [Créer une interface Ethereum en Python : partie 1](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
+- [Contrats intelligents Ethereum en Python : un guide (plus ou moins) complet](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
 
 ## Modèles d'utilisation avancés {#advanced-use-patterns}
 
+- [Modèles web3.py : abonnements aux événements en temps réel](https://snakecharmers.ethereum.org/subscriptions/)
+- [Modèles web3.py : WebSocketProvider](https://snakecharmers.ethereum.org/websocketprovider/)
 - [Compiler, déployer et appeler un contrat intelligent Ethereum en utilisant Python](https://yohanes.gultom.id/2018/11/28/compiling-deploying-and-calling-ethereum-smartcontract-using-python/)
 - [Analyser les contrats intelligents Solidity avec Slither](https://kauri.io/#collections/DevOps/analyze-solidity-smart-contracts-with-slither/#analyze-solidity-smart-contracts-with-slither)
-- [Tutoriel de la blockchain Fintech : prêts et emprunts avec Python](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
+- [Tutoriel sur la Fintech blockchain : prêts et emprunts avec Python](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
+
+## Articles archivés
+
+- [Déployer votre propre jeton ERC20 avec Python et Brownie](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
+- [Utiliser Brownie et Python pour déployer des contrats intelligents](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
+- [Créer des NFT sur OpenSea avec Brownie](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
 
-## Outils et projets Python {#python-projects-and-tools}
+## Projets et outils Python {#python-projects-and-tools}
 
-### Actifs : {#active}
+### Actifs : {#active}
 
 - [Web3.py](https://github.com/ethereum/web3.py) - _Bibliothèque Python pour interagir avec Ethereum_
-- [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é_
+- [Vyper](https://github.com/ethereum/vyper/) - _Langage de contrat intelligent pythonique pour l'EVM_
+- [Ape](https://github.com/ApeWorX/ape) - _L'outil de développement de contrats intelligents pour les pythonistes, les scientifiques des données et les professionnels de la sécurité_
 - [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-tester](https://github.com/ethereum/eth-tester) - _Outils pour tester les 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_
-- [py-solc-x](https://pypi.org/project/py-solc-x/) - _Wrapper Python autour du compilateur solc Solidity avec support 0.5.x_
+- [py-solc-x](https://pypi.org/project/py-solc-x/) - _Wrapper Python autour du compilateur solc Solidity avec prise en charge de la version 0.5.x_
 - [pymaker](https://github.com/makerdao/pymaker) - _API Python pour les contrats Maker_
-- [siwe](https://github.com/signinwithethereum/siwe-py) - _Connectez-vous avec Ethereum (siwe) pour Python_
-- [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_
-- [Wake](https://getwake.io) - _Cadre Python tout-en-un pour les tests de contrats, le fuzzing, le déploiement, les analyses de vulnérabilités et la navigation dans le code (serveur de langage - [Outils pour Solidity](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity))_
+- [siwe](https://github.com/signinwithethereum/siwe-py) - _Se connecter avec Ethereum (siwe) pour Python_
+- [Intégrations 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_
+- [Wake](https://getwake.io) - _Framework Python tout-en-un pour le test de contrats, le fuzzing, le déploiement, l'analyse de vulnérabilités et la navigation dans le code (serveur de langage - [Outils pour Solidity](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity))_
 
-### Archivé / Non entretenu : {#archived--no-longer-maintained}
+### Archivé / N'est plus maintenu : {#archived--no-longer-maintained}
 
-- [Trinity](https://github.com/ethereum/trinity) - _Client Ethereum sous Python_
-- [Mamba](https://github.com/arjunaskykok/mamba) - _Infrastructure permettant de rédiger, de compiler et de déployer des contrats intelligents en langage Vyper_
-- [Brownie](https://github.com/eth-brownie/brownie) - _Infrastructure Python pour déployer et tester les contrats intelligents Ethereum, et interagir avec ces derniers_
-- [pydevp2p](https://github.com/ethereum/pydevp2p) - _Implémentation de la pile P2P Ethereum_
-- [py-wasm](https://github.com/ethereum/py-wasm) - _Implémentation en Python de l'interpréteur d'assembleur Web_
+- [Trinity](https://github.com/ethereum/trinity) - _Client Python d'Ethereum_
+- [Mamba](https://github.com/arjunaskykok/mamba) - _Framework pour écrire, compiler et déployer des contrats intelligents écrits en langage Vyper_
+- [Brownie](https://github.com/eth-brownie/brownie) - _Framework Python pour déployer, tester et interagir avec les contrats intelligents Ethereum_
+- [pydevp2p](https://github.com/ethereum/pydevp2p) - _Implémentation de la pile P2P d'Ethereum_
+- [py-wasm](https://github.com/ethereum/py-wasm) - _Implémentation Python de l'interpréteur WebAssembly_
 
-Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/).
+Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers](/developers/).
 
-## Projets utilisant l'outil Python {#projects-using-python-tooling}
+## Projets utilisant les outils Python {#projects-using-python-tooling}
 
 Les projets Ethereum suivants utilisent les outils mentionnés sur cette page. Les dépôts open-source connexes servent de bonne référence pour le code et les meilleures pratiques par exemple.
 
-- [Yearn Finance](https://yearn.finance/) et [dépôt Yearn Vault Contracts](https://github.com/yearn/yearn-vaults)
-- [Curve](https://curve.fi/) et [Répertoire de contrats intelligents Curve](https://github.com/curvefi/curve-contract)
-- [BadgerDAO](https://badger.com/) et [Contrats intelligents en utilisant Brownie toolchain](https://github.com/Badger-Finance/badger-system)
-- [Sushi](https://sushi.com/) utilise [Python pour gérer et déployer leurs contrats d'acquisition](https://github.com/sushiswap/sushi-vesting-protocols)
-- [Alpha Venture DAO](https://alphaventuredao.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)
+- [Yearn Finance](https://yearn.finance/) et [dépôt des contrats Yearn Vault](https://github.com/yearn/yearn-vaults)
+- [Curve](https://www.curve.finance/) et [dépôt des contrats intelligents de Curve](https://github.com/curvefi/curve-contract)
+- [BadgerDAO](https://badger.com/) et [contrats intelligents utilisant la chaîne d'outils Brownie](https://github.com/Badger-Finance/badger-system)
+- [Sushi](https://sushi.com/) utilise [Python pour gérer et déployer ses contrats de vesting](https://github.com/sushiswap/sushi-vesting-protocols)
+- [Alpha Finance](https://alphaventuredao.io/), célèbre pour Alpha Homora, utilise [Brownie pour tester et déployer des contrats intelligents](https://github.com/AlphaFinanceLab/alpha-staking-contract)
 
-## Discussion de la Communauté Python {#python-community-contributors}
+## Discussion de la communauté Python {#python-community-contributors}
 
-- [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/SdvKC79cJk) pour les discussions sur la programmation des contrats intelligents avec Vyper
+- [Discord de la communauté Python Ethereum](https://discord.gg/9zk7snTfWe) pour discuter de Web3.py et d'autres frameworks Python
+- [Discord Vyper](https://discord.gg/SdvKC79cJk) pour discuter de la programmation de contrats intelligents avec Vyper
 
-## Autres ressources {#other-aggregated-lists}
+## Autres listes agrégées {#other-aggregated-lists}
 
-Le wiki de Vyper a une [incroyable liste de ressources pour Vyper](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources)
\ No newline at end of file
+Le wiki de Vyper contient une [incroyable liste de ressources pour Vyper](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources)
\ No newline at end of file
diff --git a/public/content/translations/fr/developers/docs/programming-languages/ruby/index.md b/public/content/translations/fr/developers/docs/programming-languages/ruby/index.md
index fbb61e27b25..772ca3118b7 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/ruby/index.md
+++ b/public/content/translations/fr/developers/docs/programming-languages/ruby/index.md
@@ -1,60 +1,60 @@
 ---
-title: Ethereum pour les développeurs Ruby
-description: Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Ruby.
+title: "Ethereum pour les développeurs Ruby"
+description: "Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Ruby."
 lang: fr
 incomplete: false
 ---
 
-<FeaturedText>Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Ruby.</FeaturedText>
+<FeaturedText>Apprenez à développer pour Ethereum en utilisant des projets et des outils basés sur Ruby.</FeaturedText>
 
 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.
 
-## Débuter avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity}
+## Premiers pas 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 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 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment compiler et déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
 
 ## 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)
+- [Comprendre enfin les comptes sur Ethereum](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
+- [Enfin, authentifier les utilisateurs de Rails avec MetaMask](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj)
 - [Comment se connecter au réseau Ethereum en utilisant Ruby](https://www.quicknode.com/guides/web3-sdks/how-to-connect-to-the-ethereum-network-using-ruby)
-- [Comment générer une nouvelle adresse Ethereum dans Ruby](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
+- [Comment générer une nouvelle adresse Ethereum en Ruby](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
 
-## Articles de niveau intermédiaire {#intermediate-articles}
+## Articles intermédiaires {#intermediate-articles}
 
-- [Application Blockchain avec Ruby](https://www.nopio.com/blog/blockchain-app-ruby/)
-- [Utilisez Ruby, connecté à Ethereum, pour exécuter le contrat intelligent](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
+- [Application blockchain avec Ruby](https://www.nopio.com/blog/blockchain-app-ruby/)
+- [Utiliser Ruby, connecté à Ethereum, pour exécuter le contrat intelligent](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
 
 ## Projets et outils Ruby {#ruby-projects-and-tools}
 
 ### Actif {#active}
 
-- [eth.rb](https://github.com/q9f/eth.rb) - _Bibliothèque Ruby et RPC-client pour gérer les comptes, messages et transactions Ethereum_
-- [keccak.rb](https://github.com/q9f/keccak.rb) - _L'empreinte numérique de Keccak (SHA3) utilisée par Ethereum_
-- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) - _Implémentation Ruby de la connexion avec Ethereum_
-- [siwe-rails](https://github.com/signinwithethereum/siwe-rails) - _Rails gem qui ajoute SIWE à la connexion en local_
-- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) - _Exemple de SIWE utilisant Ruby on Rails avec contrôleur personnalisé_
-- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) - _Stratégie OmniAuth pour se connecter avec Ethereum (SIWE)_
-- [omniauth-nft](https://github.com/valthon/omniauth-nft) - _Stratégie OmniAuth pour l'authentification via la détention de NFT_
-- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) - _Modèle d'Ethereum on Rails permettant de connecter MetaMask à Ruby on Rails_
+- [eth.rb](https://github.com/q9f/eth.rb) - _Bibliothèque Ruby et client RPC pour gérer les comptes, les messages et les transactions Ethereum_
+- [keccak.rb](https://github.com/q9f/keccak.rb) - _Le hachage Keccak (SHA3) utilisé par Ethereum_
+- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) - _Implémentation Ruby de Sign-In with Ethereum_
+- [siwe-rails](https://github.com/signinwithethereum/siwe-rails) - _Gem Rails qui ajoute des routes de connexion locale SIWE_
+- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) - _Exemple SIWE utilisant Ruby on Rails avec un contrôleur personnalisé_
+- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) - _Stratégie OmniAuth pour Sign In With Ethereum (SIWE)_
+- [omniauth-nft](https://github.com/valthon/omniauth-nft) - _Stratégie OmniAuth pour l'authentification via la propriété de NFT_
+- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) - _Modèle Ethereum on Rails qui permet de connecter MetaMask à Ruby on Rails_
 
-### Archivés / Non entretenus {#archived--no-longer-maintained}
+### Archivé / Non maintenu {#archived--no-longer-maintained}
 
-- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) - _Appel des méthodes RPC de nœud Ethereum avec Ruby_
-- [ethereum_tree](https://github.com/longhoangwkm/ethereum_tree) - _Bibliothèque Ruby destinée à générer des adresses ETH à partir d'un portefeuille déterministe hiérarchique selon le standard BIP32_
-- [etherlite](https://github.com/budacom/etherlite) - _Intégration Ethereum pour Ruby on Rails_
-- [ethereum. b](https://github.com/EthWorks/ethereum.rb) - _Client Ruby Ethereum utilisant l'interface JSON-RPC pour envoyer des transactions, créer et interagir avec les contrats ainsi que la boîte à outils utile pour travailler avec les nœuds Ethereum_
-- [omniauth-ethereum.rb](https://github.com/q9f/omniauth-ethereum.rb) - _Implémente la stratégie de fournisseur d'Ethereum pour OmniAuth_
+- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) - _Appeler les méthodes RPC d'un nœud Ethereum avec Ruby_
+- [ethereum_tree](https://github.com/longhoangwkm/ethereum_tree) - _Bibliothèque Ruby pour générer des adresses ETH à partir d'un portefeuille déterministe hiérarchique selon la norme BIP32_
+- [etherlite](https://github.com/budacom/etherlite) - _Intégration d'Ethereum pour Ruby on Rails_
+- [ethereum.rb](https://github.com/EthWorks/ethereum.rb) - _Client Ruby Ethereum utilisant l'interface JSON-RPC pour envoyer des transactions, créer des contrats et interagir avec eux, ainsi qu'une boîte à outils utile pour travailler avec un nœud Ethereum_
+- [omniauth-ethereum.rb](https://github.com/q9f/omniauth-ethereum.rb) - _Implémente la stratégie de fournisseur Ethereum pour OmniAuth_
 
-Vous cherchez davantage de ressources ? Jetez un œil à [notre maison du développeur](/developers/).
+Vous cherchez davantage de ressources ? Consultez [notre page d'accueil pour les développeurs](/developers/).
 
-## Contributeurs pour la Communauté Ruby {#ruby-community-contributors}
+## Contributeurs de la communauté Ruby {#ruby-community-contributors}
 
-Le groupe [Telegram Ethereum Ruby](https://t.me/ruby_eth) héberge une communauté en pleine croissance et constitue la ressource dédiée aux discussions sur les projets énoncés ci-dessus et sur des sujets connexes.
+Le [groupe Telegram Ethereum Ruby](https://t.me/ruby_eth) héberge une communauté en pleine croissance et constitue la ressource dédiée aux discussions sur l'un des projets ci-dessus et les sujets connexes.
diff --git a/public/content/translations/fr/developers/docs/programming-languages/rust/index.md b/public/content/translations/fr/developers/docs/programming-languages/rust/index.md
index b715e793207..e6e63199a43 100644
--- a/public/content/translations/fr/developers/docs/programming-languages/rust/index.md
+++ b/public/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 pour Ethereum avec des projets et des outils basés sur Rust
+title: "Ethereum pour les développeurs Rust"
+description: "Apprendre à développer pour Ethereum avec des projets et des outils basés sur Rust"
 lang: fr
 incomplete: true
 ---
 
-<FeaturedText>Apprendre à développer pour Ethereum avec des projets et des outils basés sur Rust</FeaturedText>
+<FeaturedText>Apprenez à développer pour Ethereum en utilisant des projets et des outils basés sur Rust</FeaturedText>
 
-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.
+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}
 
@@ -15,42 +15,44 @@ 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 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)
+- [Blockchain expliquée](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [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)
+- [Apprenez comment 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}
 
-- [Le client Rust Ethereum](https://openethereum.github.io/) **Veuillez noter que OpenEthereum [a été déprécié](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) et n'est plus maintenu.** Utilisez-le avec prudence et passez de préférence à une autre implémentation client.
-- [Envoi de la transaction à Ethereum en utilisant Rust](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/)
-- [Un tutoriel sur la façon d'écrire des contrats dans Rust Wasm pour Kovan](https://github.com/paritytech/pwasm-tutorial)
+- [Le client Rust Ethereum](https://openethereum.github.io/) \* **Notez que OpenEthereum [a été déprécié](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) et n'est plus maintenu.** Utilisez-le avec prudence et passez de préférence à une autre implémentation de client.
+- [Envoyer une transaction à Ethereum en utilisant Rust](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/)
+- [Un tutoriel étape par étape sur la façon d'écrire des contrats en Rust Wasm pour Kovan](https://github.com/paritytech/pwasm-tutorial)
 
 ## Articles intermédiaires {#intermediate-articles}
 
 ## Modèles d'utilisation avancés {#advanced-use-patterns}
 
-- [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)
+- [Bibliothèque externs pwasm_ethereum pour interagir avec un réseau de type Ethereum](https://github.com/openethereum/pwasm-ethereum)
 
-- [Construire une blockchain en Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
+- [Créer une discussion décentralisée en utilisant JavaScript et Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
+
+- [Créer une application de tâches décentralisée en utilisant Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
+
+- [Créer 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_
+- [Lighthouse](https://github.com/sigp/lighthouse) - _Client rapide de la couche de consensus Ethereum_
 - [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/latest/oasis_std/index.html) - _Référence de l'API OASIS_
-- [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_
+- [Solaris](https://github.com/paritytech/sol-rs) - _Harnais de test unitaire pour contrats intelligents Solidity utilisant l'EVM natif du client Parity._
+- [SputnikVM](https://github.com/rust-blockchain/evm) - _Implémentation en Rust de la Machine Virtuelle Ethereum_
+- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contrat intelligent Wavelet en Rust_
 - [Foundry](https://github.com/foundry-rs/foundry) - _Boîte à outils pour le développement d'applications Ethereum_
-- [Alloy](https://alloy.rs) - _ Des bibliothèques performantes, bien testées &amp ; documentées pour interagir avec Ethereum et d'autres chaînes basées sur l'EVM. _
-- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _Bibliothèque Ethereum et mise en place de portefeuille_
-- [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._
-- [Substreams](https://github.com/streamingfast/substreams) - _Il s'agit de protocoles d'indexation décentralisés des données qui sont soumises à une période d'immobilisation _
-- [Reth](https://github.com/paradigmxyz/reth) Reth (abréviation de Rust Ethereum) : il s'agit d'une nouvelle implémentation de nœud complet sur Ethereum
+- [Alloy](https://alloy.rs) - _Bibliothèques très performantes, bien testées et documentées pour interagir avec Ethereum et d'autres chaînes basées sur l'EVM._
+- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _Bibliothèque Ethereum et implémentation de portefeuille_
+- [SewUp](https://github.com/second-state/SewUp) - _Une bibliothèque pour vous aider à créer votre contrat webassembly Ethereum avec Rust, de la même manière que vous développez un backend commun_
+- [Substreams](https://github.com/streamingfast/substreams) - _Technologie d'indexation parallélisée des données de la blockchain_
+- [Reth](https://github.com/paradigmxyz/reth) Reth (abréviation de Rust Ethereum) est une nouvelle implémentation de nœud complet Ethereum
 - [Awesome Ethereum Rust](https://github.com/Vid201/awesome-ethereum-rust) - _Une collection de projets soigneusement sélectionnés dans l'écosystème Ethereum écrits en Rust_
 
 Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/)
@@ -58,6 +60,6 @@ Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/d
 ## Contributeurs de la communauté Rust {#rust-community-contributors}
 
 - [Ethereum WebAssembly](https://gitter.im/ewasm/Lobby)
-- [Gitter d'Oasis](https://gitter.im/Oasis-official/Lobby)
-- [Gitter de Parity](https://gitter.im/paritytech/parity)
+- [Oasis Gitter](https://gitter.im/Oasis-official/Lobby)
+- [Parity Gitter](https://gitter.im/paritytech/parity)
 - [Enigma](https://discord.gg/SJK32GY)
diff --git a/public/content/translations/fr/developers/docs/scaling/index.md b/public/content/translations/fr/developers/docs/scaling/index.md
index 06325e6dabc..99d34112d64 100644
--- a/public/content/translations/fr/developers/docs/scaling/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/index.md
@@ -1,15 +1,15 @@
 ---
-title: Évolutivité
-description: Introduction aux différentes options pour la mise à l'échelle actuellement en cours de développement par la communauté Ethereum.
+title: "Évolutivité"
+description: "Introduction aux différentes options pour la mise à l'échelle actuellement en cours de développement par la communauté Ethereum."
 lang: fr
 sidebarDepth: 3
 ---
 
-## Aperçu de la mise à l'échelle {#scaling-overview}
+## Aperçu de l'évolutivité {#scaling-overview}
 
 Le nombre grandissant d'utilisateurs d'Ethereum révèle certaines limites de capacité de la blockchain. Cela a augmenté le coût de l'utilisation du réseau, impliquant le besoin de "solutions de mise à l'échelle". De nombreuses solutions ont été étudiées, testées et mises en œuvre qui adoptent différentes approches pour atteindre des objectifs similaires.
 
-L'objectif principal de l'évolutivité est d'augmenter la vitesse des transactions (finalité plus rapide) et le débit des transactions (nombre plus élevé de transactions par seconde) sans compromettre la décentralisation ou la sécurité. Sur la blockchain Ethereum de la couche 1, une forte demande entraîne un ralentissement des transactions et des prix de [gaz](/developers/docs/gas/) non viables. L'augmentation de la capacité du réseau en termes de vitesse et de débit est fondamentale pour l'adoption significative et massive d'Ethereum.
+L'objectif principal de l'évolutivité est d'augmenter la vitesse des transactions (finalité plus rapide) et le débit des transactions (un plus grand nombre de transactions par seconde) sans sacrifier la décentralisation ou la sécurité. Sur la blockchain Ethereum de couche 1, une forte demande entraîne des transactions plus lentes et des [prix du gaz](/developers/docs/gas/) non viables. L'augmentation de la capacité du réseau en termes de vitesse et de débit est fondamentale pour l'adoption significative et massive d'Ethereum.
 
 Bien que la vitesse et le débit soient importants, il est essentiel que les solutions de mise à l'échelle permettent d'atteindre ces objectifs en restant décentralisées et sécurisées. Le maintien d'une faible barrière d'entrée pour les opérateurs de nœuds est essentiel pour empêcher une progression vers une puissance informatique centralisée et peu sûre.
 
@@ -19,19 +19,19 @@ D'un point de vue conceptuel, nous définissons la mise à l'échelle comme une
 
 Vous devez avoir une bonne compréhension de tous les sujets fondamentaux. La mise en œuvre de solutions de mise à l'échelle est délicate car la technologie est moins éprouvée et continue d'être étudiée et développée.
 
-## Mise à l'échelle sur la chaîne {#onchain-scaling}
+## Évolutivité en chaîne {#onchain-scaling}
 
-La mise à l'échelle sur la chaîne nécessite des modifications du protocole Ethereum ([Réseau principal](/glossary/#mainnet) de couche 1). Pendant longtemps, on s'attendait à ce que la fragmentation de la blockchain soit mise à l'échelle d'Ethereum. Cela impliquait de scinder la blockchain en morceaux discrets (fragments) pour être vérifiés par des sous-ensembles de validateurs. Cependant, la mise à l'échelle par rollups de couche 2 a pris le relais comme technique principale de mise à l'échelle. Ceci est supporté par l'ajout d'une nouvelle forme de données moins chère reliée à des blocs Ethereum qui est spécialement conçue pour rendre les rollups bon marché pour les utilisateurs.
+L'évolutivité en chaîne requiert des modifications du protocole Ethereum (couche 1 [Réseau principal](/glossary/#mainnet)). Pendant longtemps, on s'attendait à ce que la fragmentation de la blockchain soit mise à l'échelle d'Ethereum. Cela impliquait de scinder la blockchain en morceaux discrets (fragments) pour être vérifiés par des sous-ensembles de validateurs. Cependant, la mise à l'échelle par rollups de couche 2 a pris le relais comme technique principale de mise à l'échelle. Ceci est supporté par l'ajout d'une nouvelle forme de données moins chère reliée à des blocs Ethereum qui est spécialement conçue pour rendre les rollups bon marché pour les utilisateurs.
 
 ### Fragmentation {#sharding}
 
-La fragmentation est le processus de division d'une base de données. Les sous-ensembles de validateurs seraient responsables des fragments individuels plutôt que de garder la trace de tout le système Ethereum. La fragmentation était sur la feuille de route [Ethereum](/roadmap/) depuis longtemps, et était autrefois destinée à être expédiée avant la fusion pour la preuve d'enjeu. Cependant, le développement rapide des [rollups de couche 2](#layer-2-scaling) et l'invention de [Danksharding](/roadmap/danksharding) (ajout de blobs de données rollup à des blocs Ethereum qui peuvent être vérifiés très efficacement par les validateurs) a conduit la communauté Ethereum à privilégier une mise à l'échelle centrée sur le rollup au lieu de la mise à l'échelle par fragmentation. Cela permettra également de simplifier la logique de consensus d'Ethereum.
+La fragmentation est le processus de division d'une base de données. Les sous-ensembles de validateurs seraient responsables des fragments individuels plutôt que de garder la trace de tout le système Ethereum. La fragmentation figurait depuis longtemps sur la [feuille de route](/roadmap/) d'Ethereum et devait à l'origine être déployée avant La Fusion vers la preuve d'enjeu. Cependant, le développement rapide des [rollups de couche 2](#layer-2-scaling) et l'invention du [Danksharding](/roadmap/danksharding) (ajout de blobs de données de rollup aux blocs Ethereum qui peuvent être vérifiés très efficacement par les validateurs) a conduit la communauté Ethereum à privilégier une mise à l'échelle centrée sur les rollups plutôt qu'une mise à l'échelle par fragmentation. Cela permettra également de simplifier la logique de consensus d'Ethereum.
 
-## Mise à l'échelle hors chaîne {#offchain-scaling}
+## Évolutivité hors chaîne {#offchain-scaling}
 
-Les solutions hors chaîne sont implémentées séparément du réseau principal de couche 1 - elles ne nécessitent aucune modification du protocole Ethereum existant. Certaines solutions, connues sous le nom de solutions de « couche 2 », tirent leur sécurité directement du consensus Ethereum de la couche 1, telles que [des rollups optimistes](/developers/docs/scaling/optimistic-rollups/), [des rollups zk](/developers/docs/scaling/zk-rollups/) ou [des canaux d'état](/developers/docs/scaling/state-channels/). D’autres solutions impliquent la création de nouvelles chaînes sous diverses formes qui tirent leur sécurité séparément du réseau principal, telles que des [chaînes latérales](#sidechains), [validiums](#validium), ou [ chaînes Plasma](#plasma). Ces solutions communiquent avec le réseau principal, mais tirent leur sécurité différemment pour atteindre une variété d’objectifs.
+Les solutions hors chaîne sont implémentées séparément du réseau principal de couche 1 - elles ne nécessitent aucune modification du protocole Ethereum existant. Certaines solutions, connues sous le nom de solutions de « couche 2 », tirent leur sécurité directement du consensus de la couche 1 d'Ethereum, telles que les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/), les [rollups ZK](/developers/docs/scaling/zk-rollups/) ou les [canaux d'état](/developers/docs/scaling/state-channels/). D'autres solutions impliquent la création de nouvelles chaînes sous diverses formes qui tirent leur sécurité séparément du Réseau principal, comme les [chaînes latérales](#sidechains), les [validiums](#validium) ou les [chaînes Plasma](#plasma). Ces solutions communiquent avec le Réseau principal, mais tirent leur sécurité différemment pour atteindre une variété d’objectifs.
 
-### Mise à l'échelle par la couche 2 {#layer-2-scaling}
+### Évolutivité de couche 2 {#layer-2-scaling}
 
 Cette catégorie de solutions hors chaîne tire sa sécurité du réseau principal Ethereum.
 
@@ -44,11 +44,11 @@ Une instance spécifique de couche 2 peut être soit ouverte et partagée par de
 #### Pourquoi la couche 2 est-elle nécessaire ? {#why-is-layer-2-needed}
 
 - L’augmentation du nombre de transactions par seconde améliore considérablement l’expérience utilisateur et réduit la congestion du réseau sur le réseau principal d'Ethereum.
-- Les transactions sont regroupées en une seule transaction vers le réseau principal d'Ethereum, ce qui réduit les frais de gaz pour les utilisateurs, rendant ainsi Ethereum plus inclusif et accessible aux gens du monde entier.
+- Les transactions sont regroupées en une seule transaction vers le réseau principal d'Ethereum, ce qui réduit les frais de gaz pour les utilisateurs et rend Ethereum plus inclusif et accessible à tous, partout dans le monde.
 - Toute mise à jour d'évolutivité ne devrait pas se faire au détriment de la décentralisation ou de la sécurité. La couche 2 s'appuie sur Ethereum.
 - Il existe des réseaux de couche 2 spécifiques à une application qui apportent leur propre ensemble de gains d'efficacité lorsqu’ils travaillent avec des actifs à grande échelle.
 
-[Plus d'infos sur la couche 2](/layer-2/).
+[En savoir plus sur la couche 2](/layer-2/).
 
 #### Rollups {#rollups}
 
@@ -56,24 +56,24 @@ Les rollups exécutent des transactions en dehors de la couche 1, puis les donn
 
 Il existe deux types de rollups avec différents modèles de sécurité :
 
-- **Rollups optimistes** : suppose que les transactions sont valides par défaut et n’exécute que le calcul, via une [**preuve de fraude**](/glossary/#fraud-proof), en cas de contestation. [Plus d'infos sur les rollups optimistes](/developers/docs/scaling/optimistic-rollups/).
-- **Rollups Zero-Knowledge (ZK)** : exécute le calcul hors chaîne et soumet une [**preuve de validité**](/glossary/#validity-proof) sur la chaîne. [Plus d'infos sur les rollups ZK](/developers/docs/scaling/zk-rollups/).
+- **Rollups optimistes** : suppose que les transactions sont valides par défaut et n'exécute le calcul, via une [**preuve de fraude**](/glossary/#fraud-proof), qu'en cas de contestation. [En savoir plus sur les rollups optimistes](/developers/docs/scaling/optimistic-rollups/).
+- **Rollups ZK** : exécute le calcul hors chaîne et soumet une [**preuve de validité**](/glossary/#validity-proof) à la chaîne. [En savoir plus sur les rollups ZK](/developers/docs/scaling/zk-rollups/).
 
-#### Canaux d'état {#channels}
+#### Les canaux d'état {#channels}
 
 Les canaux d'état utilisent des contrats multisig pour permettre aux participants d’effectuer des transactions rapidement et librement hors chaîne, puis de régler la finalité sur le réseau principal. Cela minimise la congestion du réseau, les frais et les retards. Il existe actuellement deux types de canaux : les canaux d'état et les canaux de paiement.
 
 En savoir plus sur les [canaux d'état](/developers/docs/scaling/state-channels/).
 
-### Chaines latérales {#sidechains}
+### Chaînes latérales {#sidechains}
 
-Une chaîne latérale est une blockchain indépendante compatible EVM qui fonctionne en parallèle avec le réseau principal. Celles-ci sont compatibles avec Ethereum via des ponts bidirectionnels et fonctionnent selon leurs propres règles de consensus choisies et paramètres de bloc.
+Une chaîne latérale est une blockchain indépendante compatible avec l'EVM qui fonctionne en parallèle du Réseau principal. Celles-ci sont compatibles avec Ethereum via des ponts bidirectionnels et fonctionnent selon leurs propres règles de consensus et paramètres de bloc.
 
 En savoir plus sur les [chaînes latérales](/developers/docs/scaling/sidechains/).
 
 ### Plasma {#plasma}
 
-Une chaîne Plasma est une blockchain séparée qui est ancrée à la chaîne Ethereum principale et qui utilise des preuves de fraude (comme les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/)) pour arbitrer les litiges.
+Une chaîne Plasma est une blockchain distincte qui est ancrée à la chaîne principale d'Ethereum et qui utilise des preuves de fraude (comme les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/)) pour arbitrer les litiges.
 
 En savoir plus sur [Plasma](/developers/docs/scaling/plasma/).
 
@@ -97,17 +97,17 @@ _Notez que l’explication dans la vidéo utilise le terme « Couche 2 » pour
 
 <YouTube id="7pWxCklcNsU" />
 
-## Complément d'information {#further-reading}
-
-- [Une feuille de route Ethereum centrée sur le rollup](https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698) _Vitalik Buterin_
-- [Analytiques à jour sur les solutions de mise à l'échelle de la couche 2 pour Ethereum](https://www.l2beat.com/)
-- [Évaluation des solutions de mise à l'échelle de la couche 2 d'Ethereum : Un cadre de comparaison](https://medium.com/matter-labs/evaluating-ethereum-l2-scaling-solutions-a-comparison-framework-b6b2f410f955)
-- [Un guide incomplet pour les rollups](https://vitalik.eth.limo/general/2021/01/05/rollup.html)
-- [Rollups ZK alimentés par Ethereum : Wolrd Beaters](https://hackmd.io/@canti/rkUT0BD8K)
-- [Rollups optimisés vs Rollups ZK](https://limechain.tech/blog/optimistic-rollups-vs-zk-rollups/)
-- [Pourquoi les rollups + les data shards sont les seules solutions durables pour une grande évolutivité](https://polynya.medium.com/why-rollups-data-shards-are-the-only-sustainable-solution-for-high-scalability-c9aabd6fbb48)
-- [Quels types de couches 3 ont un sens ?](https://vitalik.eth.limo/general/2022/09/17/layer_3.html)
-- [Disponibilité des données ou : Comment les Rollups ont appris à ne plus s'inquiéter et à aimer Ethereum](https://web.archive.org/web/20250515194659/https://web.archive.org/web/20241108192208/https://research.2077.xyz/data-availability-or-how-rollups-learned-to-stop-worrying-and-love-ethereum)
-- [Guide Pratique des Rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
+## En savoir plus {#further-reading}
+
+- [Une feuille de route pour Ethereum centrée sur les rollups](https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698) _Vitalik Buterin_
+- [Analyses à jour sur les solutions d'évolutivité de couche 2 pour Ethereum](https://www.l2beat.com/)
+- [Evaluating Ethereum layer 2 Scaling Solutions: A Comparison Framework](https://medium.com/matter-labs/evaluating-ethereum-l2-scaling-solutions-a-comparison-framework-b6b2f410f955)
+- [Un guide incomplet des rollups](https://vitalik.eth.limo/general/2021/01/05/rollup.html)
+- [Ethereum-powered ZK-Rollups: World Beaters](https://hackmd.io/@canti/rkUT0BD8K)
+- [Rollups optimistes ou Rollups ZK](https://limechain.tech/blog/optimistic-rollups-vs-zk-rollups/)
+- [Pourquoi les rollups et les fragments de données sont la seule solution durable pour une haute évolutivité](https://polynya.medium.com/why-rollups-data-shards-are-the-only-sustainable-solution-for-high-scalability-c9aabd6fbb48)
+- [Quels types de couches 3 sont pertinents ?](https://vitalik.eth.limo/general/2022/09/17/layer_3.html)
+- [Data Availability Or: How Rollups Learned To Stop Worrying And Love Ethereum](https://web.archive.org/web/20250515194659/https://web.archive.org/web/20241108192208/https://research.2077.xyz/data-availability-or-how-rollups-learned-to-stop-worrying-and-love-ethereum)
+- [Le guide pratique des rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/scaling/optimistic-rollups/index.md b/public/content/translations/fr/developers/docs/scaling/optimistic-rollups/index.md
index 40b4615dd7d..90f69b5309c 100644
--- a/public/content/translations/fr/developers/docs/scaling/optimistic-rollups/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/optimistic-rollups/index.md
@@ -1,52 +1,52 @@
 ---
-title: Rollups optimisés
-description: Une introduction aux rollups optimistes, une solution de mise à l'échelle utilisée par la communauté Ethereum.
+title: Rollups optimistes
+description: "Une introduction aux rollups optimistes, une solution de mise à l'échelle utilisée par la communauté Ethereum."
 lang: fr
 ---
 
-Les rollups optimistes sont des protocoles de couche 2 (L2) conçus pour augmenter le débit de la couche de base d'Ethereum. Ils réduisent le calcul de la chaîne principale d'Ethereum en traitant les transactions hors chaîne, offrant ainsi des améliorations significatives dans les vitesses de traitement. Contrairement aux autres solutions de mise à l'échelle, telles que les [chaînes latérales](/developers/docs/scaling/sidechains/), les rollups optimistes tirent leur sécurité du réseau principal en publiant les résultats de transaction en chaîne, ou les [chaînes Plasma](/developers/docs/scaling/plasma/), qui vérifient également les transactions sur Ethereum à l'aide de preuves de fraude, mais stockent les données de transaction ailleurs.
+Les rollups optimistes sont des protocoles de couche 2 (L2) conçus pour augmenter le débit de la couche de base d'Ethereum. Ils réduisent le calcul de la chaîne principale d'Ethereum en traitant les transactions hors chaîne, offrant ainsi des améliorations significatives dans les vitesses de traitement. Contrairement à d'autres solutions de mise à l'échelle, telles que les [chaînes latérales](/developers/docs/scaling/sidechains/), les rollups optimistes tirent leur sécurité du réseau principal en publiant les résultats des transactions sur la chaîne, ou les [chaînes Plasma](/developers/docs/scaling/plasma/), qui vérifient également les transactions sur Ethereum à l'aide de preuves de fraude, mais stockent les données des transactions ailleurs.
 
 Le calcul étant la partie lente et coûteuse de l'utilisation d'Ethereum, les rollups optimistes offrent 10 à 100 fois plus d'améliorations en terme d'évolutivité. Les rollups optimistes écrivent également les transactions sur Ethereum en tant que `calldata` ou dans des [blobs](/roadmap/danksharding/), ce qui réduit les coûts de gaz pour les utilisateurs.
 
 ## Prérequis {#prerequisites}
 
-Vous devez avoir lu et compris nos pages sur la [mise à l'échelle d'Ethereum](/developers/docs/scaling/) et la [couche 2](/layer-2/).
+Vous devrez avoir lu et compris nos pages sur l'[évolutivité d'Ethereum](/developers/docs/scaling/) et les [couches de niveau 2](/layer-2/).
 
 ## Qu'est-ce qu'un rollup optimiste ? {#what-is-an-optimistic-rollup}
 
-Un rollup optimiste est une approche de mise à l'échelle d'Ethereum qui implique de déplacer le calcul et le stockage d'état hors chaîne. Les rollups optimistes exécutent des transactions en dehors d'Ethereum, mais publient les données de transaction sur le réseau principal en tant que `calldata` ou dans les [blobs](/roadmap/danksharding/).
+Un rollup optimiste est une approche de mise à l'échelle d'Ethereum qui implique de déplacer le calcul et le stockage d'état hors chaîne. Les rollups optimistes exécutent des transactions en dehors d'Ethereum, mais publient les données des transactions sur le réseau principal en tant que `calldata` ou dans des [blobs](/roadmap/danksharding/).
 
 Les opérateurs de rollup optimiste regroupent plusieurs transactions hors chaîne en lots importants avant de les soumettre à Ethereum. Cette approche permet de répartir les coûts fixes sur plusieurs transactions dans chaque lot, réduisant ainsi les frais pour les utilisateurs finaux. Les rollups optimistes utilisent également des techniques de compression pour réduire la quantité de données publiées sur Ethereum.
 
-Les rollups optimistes sont considérés comme « optimistes » car ils supposent que les transactions hors chaîne sont valides et ne publient pas de preuves de validité pour les lots de transactions postés sur la chaîne. Cela distingue les rollups optimistes des [rollups zero-knowledge](/developers/docs/scaling/zk-rollups) qui publient des [preuves de validité](/glossary/#validity-proof) cryptographiques pour les transactions hors chaîne.
+Les rollups optimistes sont considérés comme « optimistes » car ils supposent que les transactions hors chaîne sont valides et ne publient pas de preuves de validité pour les lots de transactions postés sur la chaîne. Cela différencie les rollups optimistes des [rollups à preuve à divulgation nulle de connaissance](/developers/docs/scaling/zk-rollups) qui publient des [preuves de validité](/glossary/#validity-proof) cryptographiques pour les transactions hors chaîne.
 
-Les rollups optimistes se basent plutôt sur un système de preuve de fraude pour détecter les cas où les transactions ne sont pas calculées correctement. Après qu'un lot de rollup soit envoyé sur Ethereum, il y a une fenêtre de temps (appelée période de contestation) au cours de laquelle n'importe qui peut contester les résultats d'une transaction de rollup en calculant une [preuve de fraude](/glossary/#fraud-proof).
+Les rollups optimistes se basent plutôt sur un système de preuve de fraude pour détecter les cas où les transactions ne sont pas calculées correctement. Après qu'un lot de rollup est soumis sur Ethereum, il y a une fenêtre de temps (appelée période de contestation) pendant laquelle n'importe qui peut contester les résultats d'une transaction de rollup en calculant une [preuve de fraude](/glossary/#fraud-proof).
 
 Si la preuve de fraude réussit, le protocole du rollup exécute à nouveau la/les transaction(s) et met à jour l'état du rollup en conséquence. L'autre effet d'une preuve de fraude réussie est que le séquenceur responsable d'inclure la transaction incorrectement exécutée dans un bloc reçoit une pénalité.
 
 Si le lot de rollup reste non contesté (c’est-à-dire que toutes les transactions sont correctement exécutées) après la période de contestation, il est considéré valide et est accepté sur Ethereum. Les autres peuvent continuer à construire sur un bloc de rollup non confirmé, mais avec une mise en garde : les résultats de la transaction seront inversés si elle est basée sur une transaction mal exécutée publiée précédemment.
 
-## Comment les rollups optimistes interagissent-ils avec Ethereum ? {#optimistic-rollups-and-Ethereum}
+## Comment les rollups optimistes interagissent-ils avec Ethereum ? Les rollups optimistes et Ethereum {#optimistic-rollups-and-Ethereum}
 
-Les rollups optimistes sont des [solutions d'évolutivité hors chaîne](/developers/docs/scaling/#offchain-scaling) conçues pour fonctionner sur Ethereum. Chaque rollup optimiste est géré par un ensemble de contrats intelligents déployés sur le réseau Ethereum. Les rollups optimistes traitent les transactions en dehors de la chaîne principale d'Ethereum, mais publient les transactions hors chaîne (en lots) dans un contrat de rollup sur la chaîne. Comme la blockchain Ethereum, cet enregistrement de transaction est immuable et forme la « chaîne de rollup optimiste. »
+Les rollups optimistes sont des [solutions de mise à l'échelle hors chaîne](/developers/docs/scaling/#offchain-scaling) conçues pour fonctionner sur Ethereum. Chaque rollup optimiste est géré par un ensemble de contrats intelligents déployés sur le réseau Ethereum. Les rollups optimistes traitent les transactions en dehors de la chaîne principale d'Ethereum, mais publient les transactions hors chaîne (en lots) dans un contrat de rollup sur la chaîne. Comme la blockchain Ethereum, cet enregistrement de transaction est immuable et forme la « chaîne de rollup optimiste. »
 
 L'architecture d'un rollup optimiste comprend les éléments suivants :
 
-**Les contrats en chaîne** : Le fonctionnement des rollups optimistes est contrôlé par des contrats intelligents s'exécutant sur Ethereum. Cela inclut les contrats qui stockent les blocs du rollup, surveillent les mises à jour d'état sur le rollup, et suivent les dépôts des utilisateurs. Dans ce sens, Ethereum sert de couche de base ou de « couche 1 » pour les rollups optimistes.
+**Contrats sur la chaîne** : le fonctionnement du rollup optimiste est contrôlé par des contrats intelligents exécutés sur Ethereum. Cela inclut les contrats qui stockent les blocs du rollup, surveillent les mises à jour d'état sur le rollup, et suivent les dépôts des utilisateurs. Dans ce sens, Ethereum sert de couche de base ou de « couche 1 » pour les rollups optimistes.
 
-**Machine virtuelle hors chaîne (VM)** : Bien que les contrats gérant le protocole de rollup optimiste s'exécutent sur Ethereum, le protocole rollup effectue le calcul et le stockage d'état sur une autre machine virtuelle distincte de la [Machine Virtuelle Ethereum](/developers/docs/evm/). La VM hors chaîne est l'endroit où les applications résident et où les changements d'état sont exécutés ; elle sert de couche supérieure ou de « couche 2 » pour un rollup optimiste.
+**Machine virtuelle hors chaîne (VM)** : Bien que les contrats gérant le protocole de rollup optimiste s'exécutent sur Ethereum, le protocole de rollup effectue le calcul et le stockage d'état sur une autre machine virtuelle, distincte de la [machine virtuelle Ethereum](/developers/docs/evm/). La VM hors chaîne est l'endroit où les applications résident et où les changements d'état sont exécutés ; elle sert de couche supérieure ou de « couche 2 » pour un rollup optimiste.
 
-Dans la mesure où les rollups optimistes sont conçus pour exécuter des programmes écrits ou compilés pour l'EVM, la VM hors chaîne intègre de nombreuses spécifications de conception de l'EVM. De plus, les preuves de fraude calculées sur la chaîne permettent au réseau Ethereum de faire respecter la validité des changements d'état calculés dans la machine virtuelle hors chaîne.
+Dans la mesure où les rollups optimistes sont conçus pour exécuter des programmes écrits ou compilés pour l'EVM, la VM hors chaîne intègre de nombreuses spécifications de conception de l'EVM. De plus, les preuves de fraude calculées sur la chaîne permettent au réseau Ethereum de faire respecter la validité des changements d'état calculés dans la MV hors chaîne.
 
-Les rollups optimistes sont décrits comme des « solutions hybrides de mise à l'échelle », car, bien qu'ils existent en tant que protocoles séparés, leurs propriétés de sécurité sont dérivées d'Ethereum. Entre autres choses, Ethereum garantit l'exactitude du calcul hors chaîne d'un rollup et la disponibilité des données à l'origine du calcul. Cela rend les rollups optimistes plus sécurisés que les protocoles de mise à l'échelle purement hors chaîne (par exemple, les [chaînes latérales](/developers/docs/scaling/sidechains/)) qui ne reposent pas sur Ethereum en matière de sécurité.
+Les rollups optimistes sont décrits comme des « solutions hybrides de mise à l'échelle », car, bien qu'ils existent en tant que protocoles séparés, leurs propriétés de sécurité sont dérivées d'Ethereum. Entre autres choses, Ethereum garantit l'exactitude du calcul hors chaîne d'un rollup et la disponibilité des données à l'origine du calcul. Cela rend les rollups optimistes plus sécurisés que les protocoles de mise à l'échelle purement hors chaîne (par ex., les [chaînes latérales](/developers/docs/scaling/sidechains/)) qui ne dépendent pas d'Ethereum pour la sécurité.
 
 Les rollups optimistes s'appuient sur le protocole Ethereum principal pour les raisons suivantes :
 
 ### Disponibilité des données {#data-availability}
 
-Comme mentionné plus tôt, les rollups optimistes envoient des données de transaction sur Ethereum en tant que `calldata` ou [blobs](/roadmap/danksharding/). Étant donné que l'exécution de la chaîne rollup est basée sur les transactions soumises, n'importe qui peut utiliser ces informations – ancrées sur la couche de base d'Ethereum – pour exécuter l'état du rollup et vérifier la justesse des transitions d'état.
+Comme mentionné, les rollups optimistes publient les données des transactions sur Ethereum en tant que `calldata` ou [blobs](/roadmap/danksharding/). Étant donné que l'exécution de la chaîne rollup est basée sur les transactions soumises, n'importe qui peut utiliser ces informations – ancrées sur la couche de base d'Ethereum – pour exécuter l'état du rollup et vérifier la justesse des transitions d'état.
 
-La [disponibilité des données](/developers/docs/data-availability/) est essentielle car, sans accès aux données d'état, les challengers ne peuvent pas construire de preuves de fraude pour contester les opérations de rollup invalides. Avec Ethereum fournissant la disponibilité des données, le risque que les opérateurs de rollup pratiquent des actes malveillants (par exemple, soumettre des blocs non valides) est réduit.
+La [disponibilité des données](/developers/docs/data-availability/) est essentielle car sans accès aux données d'état, les contestataires ne peuvent pas construire de preuves de fraude pour contester les opérations de rollup invalides. Avec Ethereum fournissant la disponibilité des données, le risque que les opérateurs de rollup pratiquent des actes malveillants (par exemple, soumettre des blocs non valides) est réduit.
 
 ### Résistance à la censure {#censorship-resistance}
 
@@ -68,15 +68,15 @@ Les rollups optimistes résolvent ce problème en forçant les opérateurs à pu
 
 Un autre rôle qu'Ethereum joue dans le contexte des rollups optimistes est celui d'une couche de règlement. Une couche de règlement permet d'ancrer l'ensemble de l'écosystème blockchain, d'établir la sécurité et de fournir une finalité objective si un litige survient sur une autre chaîne (les rollups optimistes dans ce cas) qui nécessite un arbitrage.
 
-Le réseau principal d'Ethereum fournit un hub pour les rollups optimistes afin de vérifier les preuves de fraude et de résoudre les litiges. En outre, les transactions effectuées sur le rollup ne sont définitives qu'_après_ l'acceptation du bloc rollup sur Ethereum. Une fois qu'une transaction rollup est engagée sur la couche de base d'Ethereum, elle ne peut pas être annulée (sauf dans le cas très improbable d'une réorganisation de la chaîne).
+Le réseau principal d'Ethereum fournit un hub pour les rollups optimistes afin de vérifier les preuves de fraude et de résoudre les litiges. De plus, les transactions effectuées sur le rollup ne sont définitives _qu'après_ l'acceptation du bloc de rollup sur Ethereum. Une fois qu'une transaction rollup est engagée sur la couche de base d'Ethereum, elle ne peut pas être annulée (sauf dans le cas très improbable d'une réorganisation de la chaîne).
 
 ## Comment fonctionnent les rollups optimistes ? {#how-optimistic-rollups-work}
 
-### Exécution et agrégation des transactions {#transaction-execution-and-aggregation}
+### Exécution et regroupement des transactions {#transaction-execution-and-aggregation}
 
 Les utilisateurs soumettent des transactions aux « opérateurs », qui sont des nœuds responsables du traitement des transactions sur le rollup optimiste. Également appelé « validateur » ou « agrégateur », l'opérateur regroupe les transactions, compresse les données sous-jacentes et publie le bloc sur Ethereum.
 
-Bien que n'importe qui puisse devenir validateur, les validateurs de rollup optimiste doivent fournir une caution avant de produire des blocs, un peu comme dans un [système de preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Ce lien peut être rompu si le validateur publie un bloc non valide ou s'appuie sur un bloc ancien mais non valide (même si son bloc est valide). De cette façon, les rollups optimistes utilisent des incitations cryptoéconomiques pour garantir que les validateurs agissent honnêtement.
+Bien que n'importe qui puisse devenir un validateur, les validateurs de rollup optimiste doivent fournir une caution avant de produire des blocs, un peu comme un [système de preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Ce lien peut être rompu si le validateur publie un bloc non valide ou s'appuie sur un bloc ancien mais non valide (même si son bloc est valide). De cette façon, les rollups optimistes utilisent des incitations cryptoéconomiques pour garantir que les validateurs agissent honnêtement.
 
 Les autres validateurs de la chaîne de rollup optimiste sont censés exécuter les transactions soumises en utilisant leur copie de l'état du rollup. Si l'état final d'un validateur est différent de l'état proposé par l'opérateur, il peut lancer un défi et calculer une preuve de fraude.
 
@@ -84,33 +84,33 @@ Certains rollups optimistes peuvent renoncer à un système de validateurs sans
 
 Le séquenceur est différent d'un opérateur de rollup ordinaire car il a un plus grand contrôle sur l'ordre des transactions. De plus, le séquenceur a un accès prioritaire à la chaîne de rollup et est la seule entité autorisée à soumettre des transactions au contrat en chaîne. Les transactions provenant de nœuds non séquenceurs ou d'utilisateurs réguliers sont simplement mises en file d'attente dans une boîte de réception distincte jusqu'à ce que le séquenceur les englobe dans un nouveau lot.
 
-#### Soumettre des blocs de rollup à Ethereum {#submitting-blocks-to-ethereum}
+#### Soumission des blocs de rollup à Ethereum {#submitting-blocks-to-ethereum}
 
 Comme mentionné, l'opérateur d'un rollup optimiste regroupe les transactions hors chaîne dans un lot et envoie celui-ci à Ethereum pour la notarisation. Ce processus implique de compresser les données liées aux transactions et de les publier sur Ethereum en tant que `calldata` ou dans des blobs.
 
-`calldata` est une zone non modifiable et non persistante dans un contrat intelligent qui se comporte principalement comme une [mémoire](/developers/docs/smart-contracts/anatomy/#memory). Alors que les `calldata` persistent sur la chaîne en tant que partie des [journaux d'historique](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html?highlight=memory#logs) de la blockchain, elles ne sont pas stockées en tant que partie de l'état d'Ethereum. Dans la mesure où les `calldata` ne touchent aucune partie de l'état d'Ethereum, elles sont moins coûteuses que l'état pour stocker des données sur la chaîne.
+`calldata` est une zone non modifiable et non persistante dans un contrat intelligent qui se comporte principalement comme la [mémoire](/developers/docs/smart-contracts/anatomy/#memory). Bien que `calldata` persiste sur la chaîne en tant que partie des [journaux d'historique](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html?highlight=memory#logs) de la blockchain, il n'est pas stocké en tant que partie de l'état d'Ethereum. Parce que `calldata` ne touche aucune partie de l'état d'Ethereum, c'est moins cher que l'état pour stocker des données sur la chaîne.
 
-Le mot-clé `calldata` est également utilisé dans Solidity pour transmettre des arguments à une fonction de contrat intelligent au moment de l'exécution. `calldata` identifie la fonction appelée pendant une transaction et détient les entrées de la fonction sous la forme d'une séquence arbitraire d'octets.
+Le mot-clé `calldata` est également utilisé dans Solidity pour passer des arguments à une fonction de contrat intelligent au moment de l'exécution. `calldata` identifie la fonction appelée lors d'une transaction et contient les entrées de la fonction sous la forme d'une séquence arbitraire d'octets.
 
-Dans le contexte des rollups optimistes, les `calldata` sont utilisées pour envoyer des données de transaction compressées au contrat en chaîne. L'opérateur de rollup ajoute un nouveau lot en appelant la fonction requise dans le contrat de rollup et en transmettant les données compressées comme arguments de fonction. L'utilisation de `calldata` permet de réduire les frais d'utilisation, car la plupart des coûts supportés par les rollups proviennent du stockage des données sur la chaîne.
+Dans le contexte des rollups optimistes, `calldata` est utilisé pour envoyer des données de transaction compressées au contrat sur la chaîne. L'opérateur de rollup ajoute un nouveau lot en appelant la fonction requise dans le contrat de rollup et en transmettant les données compressées comme arguments de fonction. L'utilisation de `calldata` réduit les frais des utilisateurs, car la plupart des coûts que les rollups encourent proviennent du stockage de données sur la chaîne.
 
-Voici [un exemple](https://etherscan.io/tx/0x9102bfce17c58b5fc1c974c24b6bb7a924fb5fbd7c4cd2f675911c27422a5591) de soumission d'un batch de rollup pour montrer comment ce concept fonctionne. Le séquenceur a invoqué la méthode `appendSequencerBatch()` et a transmis les données de transaction compressées comme entrées en utilisant `calldata`.
+Voici [un exemple](https://eth.blockscout.com/tx/0x9102bfce17c58b5fc1c974c24b6bb7a924fb5fbd7c4cd2f675911c27422a5591) de soumission de lot de rollup pour montrer comment ce concept fonctionne. Le séquenceur a invoqué la méthode `appendSequencerBatch()` et a passé les données de transaction compressées comme entrées en utilisant `calldata`.
 
 Certains rollups utilisent maintenant des blobs pour poster des lots de transactions sur Ethereum.
 
-Les blobs ne sont ni modifiables ni persistants (tout comme `calldata`), mais ils sont supprimés de l'historique après environ 18 jours. Pour plus d'informations sur les blobs, consultez [Danksharding](/roadmap/danksharding).
+Les blobs sont non modifiables et non persistants (tout comme `calldata`) mais sont élagués de l'historique après ~18 jours. Pour plus d'informations sur les blobs, voir [Danksharding](/roadmap/danksharding).
 
 ### Engagements d'état {#state-commitments}
 
-À tout moment, l'état du rollup optimiste (comptes, soldes, code de contrat, etc.) est organisé sous la forme d'un [arbre de Merkle](/whitepaper/#merkle-trees) appelé « arbre d'état ». La racine de cet arbre de Merkle (racine d'état), qui fait référence au dernier état du rollup, est hachée et stockée dans le contrat du rollup. Chaque transition d'état sur la chaîne produit un nouvel état de rollup, auquel un opérateur s'engage en calculant une nouvelle racine d'état.
+À tout moment, l'état du rollup optimiste (comptes, soldes, code du contrat, etc.) est organisé sous la forme d'un [arbre de Merkle](/whitepaper/#merkle-trees) appelé « arbre d'état ». La racine de cet arbre de Merkle (racine d'état), qui fait référence au dernier état du rollup, est hachée et stockée dans le contrat du rollup. Chaque transition d'état sur la chaîne produit un nouvel état de rollup, auquel un opérateur s'engage en calculant une nouvelle racine d'état.
 
 L'opérateur est tenu de soumettre les racines de l'ancien et du nouvel État lorsqu'il enregistre des lots. Si l'ancienne racine d'état correspond à la racine d'état existante dans le contrat en chaîne, cette dernière est écartée et remplacée par la nouvelle racine d'état.
 
-L'opérateur de rollup est également tenu de livrer une racine Merkle pour le lot de transactions lui-même. Cela permet à quiconque de prouver l'inclusion d'une transaction dans le lot (sur L1) en présentant une [preuve de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/).
+L'opérateur de rollup est également tenu de livrer une racine Merkle pour le lot de transactions lui-même. Cela permet à quiconque de prouver l'inclusion d'une transaction dans le lot (sur la L1) en présentant une [preuve de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/).
 
 Les engagements d'état, en particulier les racines d'état, sont nécessaires pour prouver l'exactitude des changements d'état dans un rollup optimiste. Le contrat de rollup accepte les nouvelles racines d'état des opérateurs immédiatement après leur publication, mais peut supprimer ultérieurement les racines d'état invalides pour rétablir l'état correct du rollup.
 
-### La preuve de la fraude {#fraud-proving}
+### Preuve de fraude {#fraud-proving}
 
 Comme expliqué, les rollups optimistes permettent à quiconque de publier des blocs sans fournir de preuves de validité. Cependant, pour garantir la sécurité de la chaîne, les rollups optimistes spécifient une fenêtre de temps pendant laquelle n'importe qui peut contester une transition d'état. C'est pourquoi les blocs de rollup sont appelés « assertions », car tout le monde peut contester leur validité.
 
@@ -120,11 +120,11 @@ Les schémas de preuve interactifs à un tour rejouent les transactions contest
 
 Cependant, la réexécution des transactions sur la couche 1 en vue de détecter les fraudes nécessite la publication des engagements d'état pour les transactions individuelles et augmente le nombre de données que les rollups doivent publier sur la chaîne. La relecture des transactions entraîne également d'importants coûts en gaz. Pour ces raisons, les rollups optimistes passent à la preuve interactive à tours multiples, qui atteint le même objectif (c'est-à-dire la détection des opérations de rollup invalides) avec plus d'efficacité.
 
-#### Épreuve interactive à plusieurs tours {#multi-round-interactive-proving}
+#### Preuve interactive à plusieurs tours {#multi-round-interactive-proving}
 
 La preuve interactive à tours multiples implique un protocole de va-et-vient entre l'assertif et le challenger, supervisé par un contrat de vérificateur L1, qui décide finalement de la partie qui a menti. Après qu'un nœud L2 ait contesté une assertion, l'assertif est tenu de diviser l'assertion contestée en deux moitiés égales. Dans ce cas, chaque assertion individuelle contiendra autant d'étapes de calcul que l'autre.
 
-Le contestataire choisira ensuite l'affirmation qu'il veut contester. Le processus de division (appelé « protocole de bissection ») se poursuit jusqu'à ce que les deux parties contestent une affirmation concernant _une seule_ étape d'exécution. À ce stade, le contrat L1 résoudra le litige en évaluant l'instruction (et son résultat) pour attraper la partie frauduleuse.
+Le contestataire choisira ensuite l'affirmation qu'il veut contester. Le processus de division (appelé « protocole de bissection ») se poursuit jusqu'à ce que les deux parties contestent une affirmation concernant une _seule_ étape d'exécution. À ce stade, le contrat L1 résoudra le litige en évaluant l'instruction (et son résultat) pour attraper la partie frauduleuse.
 
 Le vérificateur est tenu de fournir une « preuve en une étape » vérifiant la validité du calcul en une étape contesté. Si le vérificateur ne parvient pas à fournir la preuve en une étape, ou si le vérificateur L1 juge la preuve invalide, ils perdent le défi.
 
@@ -138,41 +138,41 @@ Quelques remarques sur ce type de preuve de fraude :
 
 4. La preuve interactive à tours multiples exige que les deux parties (le vérificateur et le challenger) effectuent des mouvements dans la fenêtre de temps spécifiée. L'absence d'action avant l'expiration du délai entraîne la perte du défi pour la partie défaillante.
 
-#### Pourquoi les preuves de fraude sont importantes pour les rollups optimistes {#fraud-proof-benefits}
+#### Pourquoi les preuves de fraude sont-elles importantes pour les rollups optimistes {#fraud-proof-benefits}
 
-Les preuves de fraude sont importantes parce qu'elles facilitent la _finalité de confiance_ dans les rollups optimistes. La finalité sans confiance est une qualité des rollups optimistes qui garantit qu'une transaction - tant qu'elle est valide - sera finalement confirmée.
+Les preuves de fraude sont importantes car elles facilitent la _finalité sans confiance_ dans les rollups optimistes. La finalité sans confiance est une qualité des rollups optimistes qui garantit qu'une transaction - tant qu'elle est valide - sera finalement confirmée.
 
 Les nœuds malveillants peuvent essayer de retarder la confirmation d'un bloc de rollup valide en lançant de faux défis. Cependant, les preuves de fraude finiront par prouver la validité du bloc rollup et le feront confirmer.
 
-Ceci est également lié à une autre propriété de sécurité des rollups optimistes : la validité de la chaîne repose sur l'existence _d'un_ nœud honnête. Le nœud honnête peut faire progresser la chaîne correctement en postant des assertions valides ou en contestant les assertions invalides. Quoi qu'il en soit, les nœuds malveillants qui entrent en conflit avec le nœud honnête perdront leurs mises pendant le processus de preuve de la fraude.
+Ceci est également lié à une autre propriété de sécurité des rollups optimistes : la validité de la chaîne repose sur l'existence d'_un seul_ nœud honnête. Le nœud honnête peut faire progresser la chaîne correctement en postant des assertions valides ou en contestant les assertions invalides. Quoi qu'il en soit, les nœuds malveillants qui entrent en conflit avec le nœud honnête perdront leurs mises pendant le processus de preuve de la fraude.
 
 ### Interopérabilité L1/L2 {#l1-l2-interoperability}
 
-Les rollups optimistes sont conçus pour l'interopérabilité avec le réseau principal Ethereum et permettent aux utilisateurs de transmettre des messages et des données arbitraires entre L1 et L2. Ils sont également compatibles avec l'EVM, de sorte que vous pouvez porter des [dApps](/developers/docs/dapps/) existantes vers des rollups optimistes ou créer de nouveaux dApps à l'aide d'outils de développement Ethereum.
+Les rollups optimistes sont conçus pour l'interopérabilité avec le réseau principal Ethereum et permettent aux utilisateurs de transmettre des messages et des données arbitraires entre L1 et L2. Ils sont également compatibles avec l'EVM, vous pouvez donc porter des [dapps](/developers/docs/dapps/) existantes sur des rollups optimistes ou créer de nouvelles dapps à l'aide des outils de développement d'Ethereum.
 
-#### 1. Mouvement des actifs {#asset-movement}
+#### 1. Mouvement d'actifs {#asset-movement}
 
 ##### Saisir le rollup
 
-Pour utiliser un rollup optimiste, les utilisateurs déposent des ETH, des jetons ERC-20 et d'autres actifs acceptés dans le contrat [pont](/developers/docs/bridges/) du rollup sur L1. Le contrat pont relaiera la transaction vers L2, où un montant équivalent d'actifs sera frappé et envoyé à l'adresse choisie par l'utilisateur lors du rollup optimiste.
+Pour utiliser un rollup optimiste, les utilisateurs déposent de l'ETH, des jetons ERC-20 et d'autres actifs acceptés dans le contrat de [pont](/developers/docs/bridges/) du rollup sur la L1. Le contrat pont relaiera la transaction vers L2, où un montant équivalent d'actifs sera frappé et envoyé à l'adresse choisie par l'utilisateur lors du rollup optimiste.
 
-Les transactions générées par l'utilisateur (comme un dépôt L1 > L2) sont généralement mises en file d'attente jusqu'à ce que le séquenceur les soumette à nouveau au contrat de rollup. Cependant, pour préserver la résistance à la censure, les rollups optimistes permettent aux utilisateurs de soumettre une transaction directement au contrat de rollup en chaîne si celle-ci a été retardée au-delà du temps maximum autorisé.
+Les transactions générées par l'utilisateur (comme un dépôt L1 > L2) sont généralement mises en file d'attente jusqu'à ce que le séquenceur les soumette à nouveau au contrat du rollup. Cependant, pour préserver la résistance à la censure, les rollups optimistes permettent aux utilisateurs de soumettre une transaction directement au contrat de rollup en chaîne si celle-ci a été retardée au-delà du temps maximum autorisé.
 
 Certains rollups optimistes adoptent une approche plus directe pour empêcher les séquenceurs de censurer les utilisateurs. Ici, un bloc est défini par toutes les transactions soumises au contrat L1 depuis le bloc précédent (par exemple, les dépôts) en plus des transactions traitées sur la chaîne de rollup. Si un séquenceur ignore une transaction sur L1, il publiera la racine d'état (prouvée) erronée ; par conséquent, les séquenceurs ne peuvent pas retarder les messages générés par les utilisateurs une fois qu'ils sont publiés sur L1.
 
 ##### Sortie du rollup
 
-Le retrait d'un rollup optimiste vers Ethereum est plus difficile en raison du système de preuve de la fraude. Si un utilisateur lance une transaction L2 > L1 pour retirer des fonds séquestrés sur L1, il doit attendre que la période de défi - qui dure environ sept jours - soit écoulée. Néanmoins, le processus de retrait lui-même est assez simple.
+Le retrait d'un rollup optimiste vers Ethereum est plus difficile en raison du système de preuve de la fraude. Si un utilisateur initie une transaction L2 > L1 pour retirer des fonds mis sous séquestre sur L1, il doit attendre que la période de contestation, d'une durée d'environ sept jours, s'écoule. Néanmoins, le processus de retrait lui-même est assez simple.
 
 Une fois la demande de retrait initiée sur le rollup L2, la transaction est incluse dans le lot suivant, tandis que les actifs de l'utilisateur sur le rollup sont brûlés. Une fois le lot publié sur Ethereum, l'utilisateur peut calculer une preuve de Merkle vérifiant l'inclusion de sa transaction de sortie dans le bloc. Il s'agit ensuite d'attendre la période de retard pour finaliser la transaction sur L1 et retirer les fonds sur le réseau principal.
 
-Pour éviter d'attendre une semaine avant de retirer des fonds sur Ethereum, les utilisateurs de rollup optimistes peuvent faire appel à un **fournisseur de liquidités** (LP). Un fournisseur de liquidité assume la propriété d'un retrait L2 en attente et paie l'utilisateur sur L1 (en échange d'une commission).
+Pour éviter d'attendre une semaine avant de retirer des fonds sur Ethereum, les utilisateurs de rollup optimiste peuvent employer un **fournisseur de liquidités** (LP). Un fournisseur de liquidité assume la propriété d'un retrait L2 en attente et paie l'utilisateur sur L1 (en échange d'une commission).
 
 Les fournisseurs de liquidités peuvent vérifier la validité de la demande de retrait de l'utilisateur (en exécutant eux-mêmes la chaîne) avant de libérer les fonds. De cette façon, ils ont l'assurance que la transaction sera finalement confirmée (c'est-à-dire une finalité sans confiance).
 
 #### 2. Compatibilité EVM {#evm-compatibility}
 
-Pour les développeurs, l'avantage des rollups optimistes est leur compatibilité - ou, mieux encore, leur équivalence - avec la [machine virtuelle Ethereum](/developers/docs/evm/) (EVM). Les rollups compatibles EVM sont conformes aux spécifications du [Yellow Paper d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf) et prennent en charge l'EVM au niveau du bytecode.
+Pour les développeurs, l'avantage des rollups optimistes est leur compatibilité, ou, mieux encore, leur équivalence, avec la [machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Les rollups compatibles avec l'EVM sont conformes aux spécifications du [Yellow Paper d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf) et prennent en charge l'EVM au niveau du bytecode.
 
 La compatibilité avec EVM dans les rollups optimistes présente les avantages suivants :
 
@@ -182,7 +182,7 @@ ii. Les développeurs et les équipes de projet qui utilisent des rollups optimi
 
 L'utilisation d'outils existants est importante car ces outils ont été largement vérifiés, débogués et améliorés au fil des années. De plus, les développeurs d'Ethereum n'ont plus besoin d'apprendre à construire avec une pile de développement entièrement nouvelle.
 
-#### 3. Appels de contrats inter-chaînes {#cross-chain-contract-calls}
+#### 3. Appels de contrat inter-chaînes {#cross-chain-contract-calls}
 
 Les utilisateurs (comptes détenus en externe) interagissent avec les contrats L2 en soumettant une transaction au contrat de rollup ou en demandant à un séquenceur ou à un validateur de le faire pour eux. Les rollups optimistes permettent également aux comptes de contrats sur Ethereum d'interagir avec les contrats L2 en utilisant des contrats relais pour relayer les messages et transmettre les données entre L1 et L2. Cela signifie que vous pouvez programmer un contrat L1 sur le réseau principal Ethereum pour invoquer des fonctions appartenant à des contrats sur un rollup optimiste L2.
 
@@ -190,64 +190,64 @@ Les appels de contrats inter-chaînes se font de manière asynchrone, c'est-à-d
 
 Un exemple d'appel de contrat inter-chaîne est le dépôt de jetons décrit précédemment. Un contrat sur L1 met en dépôt les jetons de l'utilisateur et envoie un message à un contrat L2 apparié pour monnayer une quantité égale de jetons lors du rollup.
 
-Étant donné que les appels de messages inter-chaînes entraînent l'exécution d'un contrat, l'expéditeur est généralement tenu de couvrir les [coûts du gaz](/developers/docs/gas/) pour le calcul. Il est conseillé de fixer une limite de gaz élevée pour éviter que la transaction n'échoue sur la chaîne cible. Le scénario du pontage des jetons en est un bon exemple. Si le côté L1 de la transaction (dépôt des jetons) fonctionne, mais que le côté L2 (frappe de nouveaux jetons) échoue en raison d'un manque de gaz, le dépôt devient irrécupérable.
+Comme les appels de messages inter-chaînes entraînent l'exécution de contrats, l'expéditeur est généralement tenu de couvrir les [coûts de gaz](/developers/docs/gas/) pour le calcul. Il est conseillé de fixer une limite de gaz élevée pour éviter que la transaction n'échoue sur la chaîne cible. Le scénario du pontage des jetons en est un bon exemple. Si le côté L1 de la transaction (dépôt des jetons) fonctionne, mais que le côté L2 (frappe de nouveaux jetons) échoue en raison d'un manque de gaz, le dépôt devient irrécupérable.
 
-Enfin, il convient de noter que les appels de messages L2 > L1 entre les contrats doivent tenir compte des délais (les appels L1 > L2 sont généralement exécutés après quelques minutes). En effet, les messages envoyés au réseau principal depuis le rollup optimiste ne peuvent être exécutés avant l'expiration de la fenêtre de défi.
+Enfin, il convient de noter que les appels de message L2 > L1 entre les contrats doivent tenir compte des délais (les appels L1 > L2 sont généralement exécutés après quelques minutes). En effet, les messages envoyés au réseau principal depuis le rollup optimiste ne peuvent être exécutés avant l'expiration de la fenêtre de défi.
 
 ## Comment fonctionnent les frais de reconduction optimistes ? {#how-do-optimistic-rollup-fees-work}
 
 Les rollups optimistes utilisent un système de frais de gaz, un peu comme Ethereum, pour indiquer combien les utilisateurs paient par transaction. Les frais facturés sur les rollups optimistes dépendent des éléments suivants :
 
-1. **State write**: Les rollups optimistes publient les données de transaction et les en-têtes de bloc (composés du hachage de l'en-tête de bloc précédent, de la racine de l'état, de la racine du lot) sur Ethereum sous forme de `blob`, ou "objet binaire large". [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) a introduit une solution économique pour inclure des données sur la chaîne. Un `blob` est un nouveau champ de transaction qui permet aux rollups de publier des données de transition d'état compressées sur la couche 1 d'Ethereum. Contrairement au `calldata`, qui reste en permanence sur la chaîne, les blobs sont de courte durée et peuvent être retirés aux clients après [4 096 époques](https://github.com/ethereum/consensus-specs/blob/81f3ea8322aff6b9fb15132d050f8f98b16bdba4/configs/mainnet.yaml#L147) (environ 18 jours). En utilisant des blobs pour publier des lots de transactions compressées, les rollups optimistes peuvent réduire de manière significative le coût d'écriture des transactions sur la couche 1.
+1. **Écriture d'état** : Les rollups optimistes publient les données de transaction et les en-têtes de bloc (constitués du hachage de l'en-tête de bloc précédent, de la racine d'état et de la racine de lot) sur Ethereum sous la forme d'un `blob` ou « grand objet binaire ». [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) a introduit une solution rentable pour inclure des données sur la chaîne. Un `blob` est un nouveau champ de transaction qui permet aux rollups de publier des données de transition d'état compressées sur la L1 d'Ethereum. Contrairement à `calldata`, qui reste en permanence sur la chaîne, les blobs ont une durée de vie courte et peuvent être élagués des clients après [4096 époques](https://github.com/ethereum/consensus-specs/blob/81f3ea8322aff6b9fb15132d050f8f98b16bdba4/configs/mainnet.yaml#L147) (environ 18 jours). En utilisant des blobs pour publier des lots de transactions compressées, les rollups optimistes peuvent réduire de manière significative le coût d'écriture des transactions sur la couche 1.
 
-2. **Gaz utilisé pour les blobs** : Les transactions contenant des blobs utilisent un mécanisme de frais dynamique similaire à celui introduit par [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559). Les frais de gaz pour les transactions de type 3 tiennent compte des frais de base pour les blobs, qui sont déterminés par le réseau en fonction de la demande d'espace pour les blobs et de l'utilisation de l'espace blob par la transaction envoyée.
+2. **Gaz de blob utilisé** : les transactions transportant des blobs emploient un mécanisme de frais dynamiques similaire à celui introduit par [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559). Les frais de gaz pour les transactions de type 3 tiennent compte des frais de base pour les blobs, qui sont déterminés par le réseau en fonction de la demande d'espace pour les blobs et de l'utilisation de l'espace blob par la transaction envoyée.
 
-3. **Frais d'opérateur L2** : Il s'agit du montant versé aux nœuds de rollup en compensation des coûts de calcul encourus pour le traitement des transactions, un peu comme les frais de gaz sur Ethereum. Les nœuds de rollup facturent des frais de transaction moins élevés car les L2 ont des capacités de traitement supérieures et ne sont pas confrontées aux congestions du réseau qui obligent les validateurs d'Ethereum à donner la priorité aux transactions dont les frais sont plus élevés.
+3. **Frais d'opérateur L2 :** Il s'agit du montant versé aux nœuds de rollup en compensation des coûts de calcul encourus pour le traitement des transactions, un peu comme les frais de gaz sur Ethereum. Les nœuds de rollup facturent des frais de transaction moins élevés car les L2 ont des capacités de traitement supérieures et ne sont pas confrontées aux congestions du réseau qui obligent les validateurs d'Ethereum à donner la priorité aux transactions dont les frais sont plus élevés.
 
-Les rollups optimistes appliquent plusieurs mécanismes pour réduire les frais pour les utilisateurs, notamment le regroupement des transactions et la compression des `calldata` pour réduire les coûts de publication des données. Vous pouvez consulter le [L2 fee tracker](https://l2fees.info/) pour avoir un aperçu en temps réel de ce que coûte l'utilisation des rollups optimistes basés sur Ethereum.
+Les rollups optimistes appliquent plusieurs mécanismes pour réduire les frais pour les utilisateurs, notamment le traitement par lots des transactions et la compression de `calldata` pour réduire les coûts de publication des données. Vous pouvez consulter le [L2 fee tracker](https://l2fees.info/) pour un aperçu en temps réel du coût d'utilisation des rollups optimistes basés sur Ethereum.
 
 ## Comment les rollups optimistes font-ils évoluer Ethereum ? {#scaling-ethereum-with-optimistic-rollups}
 
 Comme expliqué, les rollups optimistes publient des données de transaction compressées sur Ethereum pour garantir la disponibilité des données. Il est essentiel de pouvoir compresser les données publiées sur la chaîne pour mettre à l'échelle le débit sur Ethereum avec des rollups optimistes.
 
-La chaîne principale d'Ethereum impose des limites à la quantité de données que les blocs peuvent contenir, libellées en unités de gaz (la [taille moyenne des blocs](/developers/docs/blocks/#block-size) est de 15 millions de gaz). Bien que cela limite la quantité de gaz que chaque transaction peut utiliser, cela signifie également que nous pouvons augmenter les transactions traitées par bloc en réduisant les données liées aux transactions, ce qui améliore directement l'évolutivité.
+La chaîne principale d'Ethereum impose des limites à la quantité de données que les blocs peuvent contenir, exprimées en unités de gaz (la [taille moyenne des blocs](/developers/docs/blocks/#block-size) est de 15 millions de gaz). Bien que cela limite la quantité de gaz que chaque transaction peut utiliser, cela signifie également que nous pouvons augmenter les transactions traitées par bloc en réduisant les données liées aux transactions, ce qui améliore directement l'évolutivité.
 
 Les rollups optimistes utilisent plusieurs techniques pour réaliser la compression des données de transaction et améliorer les taux de TPS. Par exemple, cet [article](https://vitalik.eth.limo/general/2021/01/05/rollup.html) compare les données qu'une transaction utilisateur de base (envoi d'ether) génère sur le réseau principal par rapport à la quantité de données que la même transaction génère sur un rollup :
 
-| Paramètre   | Ethereum (L1)       | Rollup (L2)    |
-| ----------- | ------------------- | -------------- |
-| Nonce       | ~3                  | 0              |
-| Prix du gaz | ~8                  | 0-0.5          |
-| Gaz         | 3                   | 0-0.5          |
-| À           | 21                  | 4              |
-| Valeur      | 9                   | ~3             |
-| Signature   | ~68 (2 + 33 + 33)   | ~0.5           |
-| De          | 0 (récupéré de sig) | 4              |
-| **Total**   | **~112 octets**     | **~12 octets** |
+| Paramètre   | Ethereum (L1)                     | Rollup (L2)       |
+| ----------- | ---------------------------------------------------- | ------------------------------------ |
+| Nonce       | ~3                                   | 0                                    |
+| Prix du gaz | ~8                                   | 0-0.5                |
+| Gaz         | 3                                                    | 0-0.5                |
+| À           | 21                                                   | 4                                    |
+| Valeur      | 9                                                    | ~3                   |
+| Signature   | ~68 (2 + 33 + 33) | ~0.5 |
+| De          | 0 (récupéré de sig)               | 4                                    |
+| **Total**   | **~112 octets**                      | **~12 octets**       |
 
 En effectuant quelques calculs approximatifs sur ces chiffres, on peut montrer les améliorations d'évolutivité offertes par un rollup optimiste :
 
-1. La taille cible de chaque bloc est de 15 millions de gaz et il en coûte 16 pour vérifier un octet de données. En divisant la taille moyenne des blocs par 16 gaz (15 000 000/16), on constate que le bloc moyen peut contenir **937 500 octets de données**.
-2. Si une transaction rollup de base utilise 12 octets, alors le bloc Ethereum moyen peut traiter **78 125 transactions rollup** (937 5000/12) ou **39 lots rollup** (si chaque lot contient une moyenne de 2 000 transactions).
-3. Si un nouveau bloc est produit sur Ethereum toutes les 15 secondes, les vitesses de traitement du rollup s'élèveraient à environ **5 208 transactions par seconde**. Cela se fait en divisant le nombre de transactions rollup de base qu'un bloc Ethereum peut contenir (**78 125**) par la durée moyenne du bloc (**15 secondes**).
+1. La taille cible de chaque bloc est de 15 millions de gaz et il en coûte 16 pour vérifier un octet de données. La division de la taille moyenne des blocs par 16 gaz (15 000 000/16) montre que le bloc moyen peut contenir **937 500 octets de données**.
+2. Si une transaction de rollup de base utilise 12 octets, le bloc Ethereum moyen peut traiter **78 125 transactions de rollup** (937 500/12) ou **39 lots de rollup** (si chaque lot contient en moyenne 2 000 transactions).
+3. Si un nouveau bloc est produit sur Ethereum toutes les 15 secondes, la vitesse de traitement du rollup s'élèverait à environ **5 208 transactions par seconde**. Pour ce faire, on divise le nombre de transactions de rollup de base qu'un bloc Ethereum peut contenir (**78 125**) par le temps de bloc moyen (**15 secondes**).
 
 Il s'agit d'une estimation assez optimiste, étant donné que les transactions de rollup optimistes ne peuvent pas constituer un bloc entier sur Ethereum. Cependant, il peut donner une idée approximative des gains d'évolutivité que les rollups optimistes peuvent offrir aux utilisateurs d'Ethereum (les implémentations actuelles offrent jusqu'à 2 000 TPS).
 
-L'introduction de [la fragmentation des données](/roadmap/danksharding/) sur Ethereum devrait améliorer l'évolutivité dans les rollups optimistes. Comme les transactions rollup doivent partager l'espace de blocs avec d'autres transactions non rollup, leur capacité de traitement est limitée par le débit de données sur la chaîne principale d'Ethereum. Danksharding augmentera l'espace disponible pour les chaînes L2 pour publier des données par bloc, en utilisant un stockage « blob » moins cher, non permanent au lieu de `DONNÉES D'APPEL` coûteuses et permanentes.
+L'introduction de la [fragmentation des données](/roadmap/danksharding/) sur Ethereum devrait améliorer la mise à l'échelle des rollups optimistes. Comme les transactions rollup doivent partager l'espace de blocs avec d'autres transactions non rollup, leur capacité de traitement est limitée par le débit de données sur la chaîne principale d'Ethereum. Danksharding augmentera l'espace disponible pour les chaînes L2 afin de publier des données par bloc, en utilisant un stockage « blob » moins cher et non permanent au lieu du coûteux et permanent `CALLDATA`.
 
 ### Avantages et inconvénients des rollups optimistes {#optimistic-rollups-pros-and-cons}
 
-| Avantages                                                                                                                                                                                              | Inconvénients                                                                                                                                                                       |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Avantages                                                                                                                                                                                                              | Inconvénients                                                                                                                                                                                       |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Offre des améliorations massives en matière d'évolutivité sans sacrifier la sécurité ou la fiabilité.                                                                                                  | Retards dans la finalité de la transaction en raison d'éventuels problèmes de fraude.                                                                                               |
-| Les données de transaction sont stockées sur la chaîne de couche 1, ce qui améliore la transparence, la sécurité, la résistance à la censure et la décentralisation.                                   | Les opérateurs centralisés de rollup (séquenceurs) peuvent influencer l'ordre des transactions.                                                                                     |
+| Les données de transaction sont stockées sur la chaîne de couche 1, ce qui améliore la transparence, la sécurité, la résistance à la censure et la décentralisation.                                   | Les opérateurs centralisés de rollup (séquenceurs) peuvent influencer l'ordre des transactions.                                                                  |
 | La preuve de la fraude garantit une finalité sans faille et permet aux minorités honnêtes de sécuriser la chaîne.                                                                                      | S'il n'y a pas de nœuds honnêtes, un opérateur malveillant peut voler des fonds en postant des blocs et des engagements d'état invalides.                                           |
-| Le calcul des preuves de fraude est ouvert au nœud L2 ordinaire, contrairement aux preuves de validité (utilisées dans les rollups ZK) qui nécessitent un matériel spécial.                            | Le modèle de sécurité repose sur au moins un nœud honnête exécutant des transactions de rollup et soumettant des preuves de fraude pour contester les transitions d'état invalides. |
-| Les rollups bénéficient d'une « vivacité sans confiance » (n'importe qui peut forcer la chaîne à avancer en exécutant des transactions et en postant des assertions)                                   | Les utilisateurs doivent attendre l'expiration de la période de défi d'une semaine avant de retirer des fonds vers l'Ethereum.                                                      |
+| Le calcul des preuves de fraude est ouvert au nœud L2 ordinaire, contrairement aux preuves de validité (utilisées dans les rollups ZK) qui nécessitent un matériel spécial.         | Le modèle de sécurité repose sur au moins un nœud honnête exécutant des transactions de rollup et soumettant des preuves de fraude pour contester les transitions d'état invalides. |
+| Les rollups bénéficient d'une « vivacité sans confiance » (n'importe qui peut forcer la chaîne à avancer en exécutant des transactions et en postant des assertions)                                | Les utilisateurs doivent attendre l'expiration de la période de défi d'une semaine avant de retirer des fonds vers l'Ethereum.                                                      |
 | Les rollups optimistes s'appuient sur des incitations cryptoéconomiques bien conçues pour accroître la sécurité sur la chaîne.                                                                         | Les rollups doivent publier toutes les données de transaction sur la chaîne, ce qui peut augmenter les coûts.                                                                       |
-| La compatibilité avec EVM et Solidity permet aux développeurs de porter les contrats intelligents natifs d'Ethereum vers les rollups ou d'utiliser les outils existants pour créer de nouvelles dApps. |                                                                                                                                                                                     |
+| La compatibilité avec EVM et Solidity permet aux développeurs de porter les contrats intelligents natifs d'Ethereum vers les rollups ou d'utiliser les outils existants pour créer de nouvelles dApps. |                                                                                                                                                                                                     |
 
-### Une explication visuelle des rollups optimistes {#optimistic-video}
+### Explication visuelle des rollups optimistes {#optimistic-video}
 
 Davantage qu'un apprenant visuel ? Regardez Finematics expliquer les rollups optimistes :
 
@@ -257,9 +257,9 @@ Davantage qu'un apprenant visuel ? Regardez Finematics expliquer les rollups opt
 
 - [Comment fonctionnent les rollups optimistes (Le guide complet)](https://www.alchemy.com/overviews/optimistic-rollups)
 - [Qu'est-ce qu'un rollup de blockchain ? Une introduction technique](https://www.ethereum-ecosystem.com/blog/what-is-a-blockchain-rollup-a-technical-introduction)
-- [Le guide essentiel pour Arbitrum](https://www.bankless.com/the-essential-guide-to-arbitrum)
-- [Guide pratique des rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
-- [L’état des preuves de fraude dans les secondes couches d’Ethereum](https://web.archive.org/web/20241124154627/https://research.2077.xyz/the-state-of-fraud-proofs-in-ethereum-l2s)
+- [Le guide essentiel d'Arbitrum](https://www.bankless.com/the-essential-guide-to-arbitrum)
+- [Le guide pratique des rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
+- [L'état des preuves de fraude dans les L2 d'Ethereum](https://web.archive.org/web/20241124154627/https://research.2077.xyz/the-state-of-fraud-proofs-in-ethereum-l2s)
 - [Comment fonctionne réellement le rollup d'Optimism ?](https://www.paradigm.xyz/2021/01/how-does-optimism-s-rollup-really-work)
-- [OVM Deep Dive](https://medium.com/ethereum-optimism/ovm-deep-dive-a300d1085f52)
-- [Qu’est-ce que la machine virtuelle optimiste ?](https://www.alchemy.com/overviews/optimistic-virtual-machine)
+- [Plongée dans l'OVM](https://medium.com/ethereum-optimism/ovm-deep-dive-a300d1085f52)
+- [Qu'est-ce que la Machine Virtuelle Optimiste ?](https://www.alchemy.com/overviews/optimistic-virtual-machine)
diff --git a/public/content/translations/fr/developers/docs/scaling/plasma/index.md b/public/content/translations/fr/developers/docs/scaling/plasma/index.md
index e3e1a9212bb..7b1dc333595 100644
--- a/public/content/translations/fr/developers/docs/scaling/plasma/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/plasma/index.md
@@ -1,24 +1,24 @@
 ---
-title: Les chaînes Plasma
-description: Une introduction aux chaînes Plasma en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum.
+title: "Les chaînes Plasma"
+description: "Une introduction aux chaînes Plasma en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum."
 lang: fr
 incomplete: true
 sidebarDepth: 3
 ---
 
-Une chaîne Plasma est une blockchain distincte ancrée au réseau principal d'Ethereum mais exécutant des transactions hors chaîne avec son propre mécanisme de validation des blocs. Les chaînes Plasma sont parfois appelées chaînes « enfant », car elles sont essentiellement des copies plus petites du réseau principal Ethereum. Les chaînes plasma utilisent [des preuves de fraude](/glossary/#fraud-proof) (comme [des rollups optimistes](/developers/docs/scaling/optimistic-rollups/)) pour arbitrer les conflits.
+Une chaîne Plasma est une blockchain distincte ancrée au réseau principal d'Ethereum mais exécutant des transactions hors chaîne avec son propre mécanisme de validation des blocs. Les chaînes Plasma sont parfois appelées chaînes « enfant », car elles sont essentiellement des copies plus petites du réseau principal Ethereum. Les chaînes Plasma utilisent des [preuves de fraude](/glossary/#fraud-proof) (comme les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/)) pour arbitrer les litiges.
 
 Les arbres de Merkle permettent de créer une pile infinie de ces chaînes qui peuvent fonctionner pour décharger la bande passante des chaînes mères (y compris le réseau principal Ethereum). Cependant, alors que ces chaînes intègrent une partie de la sécurité d'Ethereum (via des preuves de fraude), leur sécurité et leur efficacité sont affectées par plusieurs limitations de conception.
 
 ## Prérequis {#prerequisites}
 
-Vous devez avoir une bonne compréhension de tous les sujets fondamentaux et une compréhension de haut niveau de la [mise à l'échelle Ethereum](/developers/docs/scaling/).
+Vous devez avoir une bonne compréhension de tous les sujets fondamentaux et une compréhension de haut niveau de l'[évolutivité d'Ethereum](/developers/docs/scaling/).
 
 ## Qu'est-ce que Plasma ?
 
-Plasma est un cadre pour améliorer l'évolutivité des blockchains publiques comme Ethereum. Comme décrit dans le [Livre Blanc de Plasma](http://plasma.io/plasma.pdf), les chaînes Plasma sont construites sur d'autres blockchains (qui sont appelées les « chaînes racines »). Chaque « chaîne enfant » s'étend à partir de la chaîne racine et est généralement gérée par un contrat intelligent déployé sur la chaîne mère.
+Plasma est un cadre pour améliorer l'évolutivité des blockchains publiques comme Ethereum. Comme décrit dans le [livre blanc Plasma](http://plasma.io/plasma.pdf) original, les chaînes Plasma sont construites au-dessus d'une autre blockchain (appelée une "chaîne racine"). Chaque « chaîne enfant » s'étend à partir de la chaîne racine et est généralement gérée par un contrat intelligent déployé sur la chaîne mère.
 
-Le contrat Plasma fonctionne, entre autres, comme un [pont](/developers/docs/bridges/) permettant aux utilisateurs de déplacer des actifs entre le réseau principal Ethereum et la chaîne Plasma. Bien que cela les rende similaires à des [chaînes latérales](/developers/docs/scaling/sidechains/), les chaînes plasma bénéficient - du moins, dans une certaine mesure - de la sécurité du réseau principal Ethereum. Ce n'est pas le cas des chaînes latérales qui sont les seules responsables de leur sécurité.
+Le contrat Plasma fonctionne, entre autres, comme un [pont](/developers/docs/bridges/) permettant aux utilisateurs de déplacer des actifs entre le réseau principal d'Ethereum et la chaîne plasma. Bien que cela les rende similaires aux [chaînes latérales](/developers/docs/scaling/sidechains/), les chaînes plasma bénéficient — du moins, dans une certaine mesure — de la sécurité du réseau principal d'Ethereum. Ce n'est pas le cas des chaînes latérales qui sont les seules responsables de leur sécurité.
 
 ## Comment fonctionne Plasma ?
 
@@ -26,7 +26,7 @@ Les composants de base de Plasma sont :
 
 ### Calcul hors chaîne {#offchain-computation}
 
-La vitesse de traitement actuelle d'Ethereum est limitée à environ 15 à 20 transactions par seconde, ce qui ne permet pas de gérer un fort accroissement du nombre d'utilisateurs sans engorger le réseau. Ce problème existe principalement parce que le [mécanisme de consensus](/developers/docs/consensus-mechanisms/) d'Ethereum nécessite de nombreux nœuds peer-to-peer pour vérifier chaque mise à jour de l'état de la blockchain.
+La vitesse de traitement actuelle d'Ethereum est limitée à environ 15 à 20 transactions par seconde, ce qui ne permet pas de gérer un fort accroissement du nombre d'utilisateurs sans engorger le réseau. Ce problème existe principalement parce que le [mécanisme de consensus](/developers/docs/consensus-mechanisms/) d'Ethereum exige que de nombreux nœuds pair-à-pair vérifient chaque mise à jour de l'état de la blockchain.
 
 Bien que ce mécanisme de consensus soit nécessaire pour la sécurité du réseau, il peut ne pas s'appliquer pour chaque cas d'utilisation. Par exemple, Alice peut ne pas souhaiter que ses paiements quotidiens à Bob pour l'achat d'une tasse de café soient vérifiés par l'ensemble du réseau Ethereum car une certaine confiance existe entre les deux parties.
 
@@ -38,11 +38,11 @@ Les calculs hors chaîne sont nécessaires car les chaînes Plasma peuvent optim
 
 Bien que Plasma exécute des transactions hors chaîne, celles-ci sont réglées sur la couche d'exécution principale d'Ethereum. Dans le cas contraire, les chaînes Plasma ne peuvent pas bénéficier des garanties de sécurité d'Ethereum. Mais finaliser des transactions hors chaîne sans connaître l'état de la chaîne plasma briserait le modèle de sécurité et permettrait la prolifération de transactions invalides. C'est pourquoi l'opérateur, l'entité responsable de la production des blocs sur la chaîne plasma, est tenu de publier périodiquement des « engagements d'état » sur Ethereum.
 
-Un [schéma d'engagement](https://en.wikipedia.org/wiki/Commitment_scheme) est une technique cryptographique permettant de s'engager sur une valeur ou une déclaration sans la révéler à une autre partie. Les engagements sont « contraignants » dans le sens où vous ne pouvez pas modifier la valeur ou la déclaration une fois que vous vous y êtes engagé. Les engagements d'État dans Plasma prennent la forme de « racines de Merkle » (dérivées d'un [arbre de Merkle](/whitepaper/#merkle-trees)) que l'opérateur envoie à intervalles au contrat Plasma sur la chaîne Ethereum.
+Un [schéma d'engagement](https://en.wikipedia.org/wiki/Commitment_scheme) est une technique cryptographique permettant de s'engager sur une valeur ou une déclaration sans la révéler à une autre partie. Les engagements sont « contraignants » dans le sens où vous ne pouvez pas modifier la valeur ou la déclaration une fois que vous vous y êtes engagé. Les engagements d'état dans Plasma prennent la forme de "racines de Merkle" (dérivées d'un [arbre de Merkle](/whitepaper/#merkle-trees)) que l'opérateur envoie à intervalles réguliers au contrat Plasma sur la chaîne Ethereum.
 
-Les racines de Merkle sont des primitives cryptographiques qui permettent de compresser de grandes quantités d'informations. Une racine Merkle (également appelée « racine de bloc » dans ce cas) pourrait représenter toutes les transactions d'un bloc. Les racines de Merkle permettent également de vérifier plus facilement qu'un petit élément de données fait partie d'un ensemble de données plus vaste. Par exemple, un utilisateur peut produire une [preuve Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/#main-content) pour prouver l'inclusion d'une transaction dans un bloc spécifique.
+Les racines de Merkle sont des primitives cryptographiques qui permettent de compresser de grandes quantités d'informations. Une racine Merkle (également appelée « racine de bloc » dans ce cas) pourrait représenter toutes les transactions d'un bloc. Les racines de Merkle permettent également de vérifier plus facilement qu'un petit élément de données fait partie d'un ensemble de données plus vaste. Par exemple, un utilisateur peut produire une [preuve de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/#main-content) pour prouver l'inclusion d'une transaction dans un bloc spécifique.
 
-Les racines Merkle sont importantes pour fournir à Ethereum des informations sur l'état hors chaîne. Vous pouvez considérer les racines de Merkle comme des « points de sauvegarde » : l'opérateur dit : « Voici l'état de la chaîne Plasma à un moment x, et voici la racine de Merkle comme preuve. » L'opérateur s'engage sur l'_état actuel_ de la chaîne plasma avec une racine de Merkle, c'est pourquoi on parle d'un « engagement d'état ».
+Les racines Merkle sont importantes pour fournir à Ethereum des informations sur l'état hors chaîne. Vous pouvez considérer les racines de Merkle comme des « points de sauvegarde » : l'opérateur dit : « Voici l'état de la chaîne Plasma à un moment x, et voici la racine de Merkle comme preuve. » L'opérateur s'engage sur l'_état actuel_ de la chaîne plasma avec une racine de Merkle, c'est pourquoi on l'appelle un "engagement d'état".
 
 ### Entrées et sorties {#entries-and-exits}
 
@@ -50,11 +50,11 @@ Pour que les utilisateurs d'Ethereum puisse tirer parti de Plasma, il doit y avo
 
 Plasma utilise un contrat principal fonctionnant sur Ethereum pour traiter les entrées et sorties des utilisateurs. Ce contrat principal est également responsable du suivi des engagements d'état (expliqué précédemment) et de la sanction des comportements malhonnêtes par le biais de preuves de fraude (nous y reviendrons plus tard).
 
-#### Intégrer la chaîne Plasma {#entering-the-plasma-chain}
+#### Entrer dans la chaîne plasma {#entering-the-plasma-chain}
 
 Pour entrer dans la chaîne Plasma, Alice (l'utilisateur) devra déposer un ETH ou tout jeton ERC-20 dans le contrat Plasma. L'opérateur Plasma, qui surveille les dépôts contractuels, recrée un montant égal au dépôt initial d'Alice et le libère à son adresse sur la chaîne Plasma. Alice doit ensuite attester avoir reçu ses fonds sur la chaîne enfant afin de pouvoir les utiliser dans le cadre de transactions.
 
-#### Sortir de la chaîne Plasma {#exiting-the-plasma-chain}
+#### Sortir de la chaîne plasma {#exiting-the-plasma-chain}
 
 Sortir de la chaîne Plasma est plus complexe que d'y entrer, et ce, pour plusieurs raisons. Le plus important est que, bien qu'Ethereum dispose d'informations sur l'état de la chaîne Plasma, il ne peut pas vérifier si les informations sont vraies ou non. Un utilisateur malveillant pourrait faire une assertion incorrecte (« J'ai 1000 ETH ») et s'en tirer en fournissant de fausses preuves pour soutenir sa demande.
 
@@ -62,17 +62,17 @@ Pour éviter des retraits malveillants, une « période de défi » est introdui
 
 Néanmoins, la plupart du temps, les utilisateurs sont honnêtes et font des déclarations correctes sur les fonds qu'ils possèdent. Dans ce scénario, Alice lancera une demande de retrait vers la chaîne racine (Ethereum) en soumettant une transaction au contrat Plasma.
 
-Elle doit également fournir une preuve de Merkle vérifiant qu'une transaction créant ses fonds sur la chaîne Plasma a été incluse dans un bloc. Ceci est nécessaire pour les itérations de Plasma, telles que [Plasma MVP](https://www.learnplasma.org/en/learn/mvp.html), qui utilisent un modèle [Unspent Transaction Output (UTXO)](https://en.wikipedia.org/wiki/Unspent_transaction_output).
+Elle doit également fournir une preuve de Merkle vérifiant qu'une transaction créant ses fonds sur la chaîne Plasma a été incluse dans un bloc. Ceci est nécessaire pour les itérations de Plasma, telles que [Plasma MVP](https://www.learnplasma.org/en/learn/mvp.html), qui utilisent un modèle de [sorties de transaction non dépensées (UTXO)](https://en.wikipedia.org/wiki/Unspent_transaction_output).
 
-D'autres, comme [Plasma Cash](https://www.learnplasma.org/en/learn/cash.html), représentent les fonds sous forme de [jetons non fongibles](/developers/docs/standards/tokens/erc-721/) au lieu d'UTXOs. Le retrait, dans ce cas, nécessite une preuve de propriété des jetons sur la chaîne Plasma. Pour ce faire, il faut soumettre les deux dernières transactions impliquant le jeton et fournir une preuve de Merkle vérifiant l'inclusion de ces transactions dans un bloc.
+D'autres, comme [Plasma Cash](https://www.learnplasma.org/en/learn/cash.html), représentent les fonds sous forme de [jetons non fongibles](/developers/docs/standards/tokens/erc-721/) au lieu d'UTXO. Le retrait, dans ce cas, nécessite une preuve de propriété des jetons sur la chaîne Plasma. Pour ce faire, il faut soumettre les deux dernières transactions impliquant le jeton et fournir une preuve de Merkle vérifiant l'inclusion de ces transactions dans un bloc.
 
 L'utilisateur doit également ajouter une caution à la demande de retrait comme garantie d'un comportement honnête. Si un challenger prouve que la demande de retrait d'Alice n'est pas valable, sa caution est réduite, et une partie de celle-ci va au challenger en guise de récompense.
 
 Si la période de défi s'écoule sans que personne ne fournisse de preuve de fraude, la demande de retrait d'Alice est considérée comme valide, lui permettant de récupérer des dépôts sur le contrat Plasma vers Ethereum.
 
-### Arbitrage de litige {#dispute-arbitration}
+### Arbitrage des litiges {#dispute-arbitration}
 
-Comme toute blockchain, les chaînes de plasma ont besoin d'un mécanisme pour faire respecter l'intégrité des transactions au cas où les participants agiraient de manière malveillante (par exemple, des fonds à double dépense). À cette fin, les chaînes de plasma utilisent des preuves de fraude pour arbitrer les conflits concernant la validité des transitions d'état et pénaliser les mauvais comportements. Les preuves de fraude sont utilisées comme mécanisme par lequel une chaîne enfant Plasma dépose une plainte auprès de sa chaîne mère ou de la chaîne racine.
+Comme toute blockchain, les chaînes plasma ont besoin d'un mécanisme pour faire respecter l'intégrité des transactions au cas où les participants agiraient de manière malveillante (par ex., double dépense de fonds). À cette fin, les chaînes de plasma utilisent des preuves de fraude pour arbitrer les conflits concernant la validité des transitions d'état et pénaliser les mauvais comportements. Les preuves de fraude sont utilisées comme mécanisme par lequel une chaîne enfant Plasma dépose une plainte auprès de sa chaîne mère ou de la chaîne racine.
 
 Une preuve de fraude est simplement une affirmation selon laquelle une transition d'état particulière est invalide. Par exemple, si un utilisateur (Alice) essaie de dépenser deux fois les mêmes fonds. Elle a peut-être dépensé les UTXO lors d'une transaction avec Bob et veut dépenser les mêmes UTXO (qui appartiennent maintenant à Bob) dans une autre transaction.
 
@@ -80,9 +80,9 @@ Pour empêcher le retrait, Bob construira une preuve de fraude en fournissant la
 
 Si le défi de Bob réussit, la demande de retrait d'Alice est annulée. Cependant, cette approche repose sur la capacité de Bob à surveiller la chaîne pour les demandes de retrait. Si Bob est hors ligne, Alice peut traiter le retrait malveillant une fois que la période de défi est écoulée.
 
-## Le problème de la sortie de masse de Plasma {#the-mass-exit-problem-in-plasma}
+## Le problème de la sortie de masse dans Plasma {#the-mass-exit-problem-in-plasma}
 
-Le problème de sortie de masse survient lorsqu'un grand nombre d'utilisateurs tentent de se retirer d'une chaîne Plasma en même temps. Ce problème résulte d'une des plus grandes difficultés de Plasma : **l'indisponibilité des données**.
+Le problème de sortie de masse survient lorsqu'un grand nombre d'utilisateurs tentent de se retirer d'une chaîne Plasma en même temps. L'existence de ce problème est liée à l'un des plus gros problèmes de Plasma : **l'indisponibilité des données**.
 
 La disponibilité des données est la capacité de vérifier que les informations d'un bloc proposé ont été publiées sur le réseau blockchain. Un bloc est « indisponible » si le producteur publie le bloc lui-même mais refuse de publier les données utilisées pour créer le bloc.
 
@@ -90,7 +90,7 @@ Les blocs doivent être disponibles pour que les nœuds puissent télécharger l
 
 La disponibilité des données aide également à sécuriser les protocoles de mise à l'échelle hors chaîne qui s'appuient sur la couche de base d'Ethereum. En forçant les opérateurs de ces chaînes à publier des données de transaction sur Ethereum, n'importe qui peut contester des blocs non valides en construisant des preuves de fraude qui prennent en référence l'état correct de la chaîne.
 
-Les chaînes plasma stockent principalement les données de transaction chez l'opérateur et **ne publient aucune donnée sur le réseau principal** (c'est-à-dire en dehors des engagements périodiques d'état). Cela signifie que les utilisateurs doivent compter sur l'opérateur pour fournir les données des blocs s'ils ont besoin de créer des preuves de fraude contestant des transactions invalides. Si ce système fonctionne, les utilisateurs pourront toujours utiliser des preuves de fraude pour sécuriser leurs fonds.
+Les chaînes Plasma stockent principalement les données de transaction chez l'opérateur et **ne publient aucune donnée sur le réseau principal** (c'est-à-dire, en dehors des engagements d'état périodiques). Cela signifie que les utilisateurs doivent compter sur l'opérateur pour fournir les données des blocs s'ils ont besoin de créer des preuves de fraude contestant des transactions invalides. Si ce système fonctionne, les utilisateurs pourront toujours utiliser des preuves de fraude pour sécuriser leurs fonds.
 
 Le problème commence lorsque l'opérateur, et pas n'importe quel utilisateur, est la partie qui agit de manière malveillante. Comme l'opérateur a le contrôle exclusif de la blockchain, il est davantage incité à favoriser des transitions d'état invalides à plus grande échelle, comme le vol de fonds appartenant à des utilisateurs de la chaîne plasma.
 
@@ -98,7 +98,7 @@ Dans ce cas, l'utilisation du système anti-fraude classique ne fonctionne pas.
 
 Par conséquent, la solution la plus optimiste consiste à tenter une « sortie massive » des utilisateurs de la chaîne Plasma. Cette sortie massive ralentit le projet de l'opérateur malveillant de voler des fonds et offre une certaine protection aux utilisateurs. Les demandes de retrait sont ordonnées en fonction de la date de création de chaque UTXO (ou jeton), ce qui empêche les opérateurs malveillants de devancer les utilisateurs honnêtes.
 
-Néanmoins, nous avons toujours besoin d'un moyen de vérifier la validité des demandes de retrait lors d'une sortie massive, afin d'éviter que des individus opportunistes ne profitent du chaos engendré par les sorties invalides. La solution est simple : exiger des utilisateurs qu'ils affichent le dernier **état valide de la chaîne** pour sortir leur argent.
+Néanmoins, nous avons toujours besoin d'un moyen de vérifier la validité des demandes de retrait lors d'une sortie massive, afin d'éviter que des individus opportunistes ne profitent du chaos engendré par les sorties invalides. La solution est simple : exiger des utilisateurs qu'ils publient le dernier **état valide de la chaîne** pour retirer leur argent.
 
 Mais cette approche a encore des problèmes. Par exemple, si tous les utilisateurs d'une chaîne Plasma doivent se retirer (ce qui est possible dans le cas d'un opérateur malveillant), l'ensemble de l'état valide de la chaîne Plasma doit être déversé sur la couche de base d'Ethereum en une seule fois. Avec la taille arbitraire des chaînes Plasma (haut débit = plus de données) et les contraintes sur les vitesses de traitement d'Ethereum, ce n'est pas une solution idéale.
 
@@ -106,33 +106,33 @@ Bien que les jeux de sortie soient agréables en théorie, les sorties massives
 
 ## Avantages et inconvénients de Plasma {#pros-and-cons-of-plasma}
 
-| Avantages                                                                                                                                                                                                                                                                                                   | Inconvénients                                                                                                                                                                                                                             |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Permet un débit élevé et un faible coût de transaction.                                                                                                                                                                                                                                                     | Ne prend pas en charge le calcul général (ne peut pas exécuter de contrats intelligents). Seuls les transferts de jetons de base, les échanges et quelques autres types de transactions sont pris en charge par la logique des prédicats. |
-| Convient aux transactions entre utilisateurs arbitraires (pas de surcharge par paire utilisateur si les deux sont établis sur la chaîne Plasma).                                                                                                                                                            | Nécessité de surveiller périodiquement le réseau (exigence de vivacité) ou de déléguer cette responsabilité à quelqu'un d'autre pour garantir la sécurité de vos fonds.                                                                   |
-| Les chaînes Plasma peuvent être adaptées à des cas d'utilisation spécifiques qui ne sont pas liés à la chaîne principale. N'importe qui, y compris les entreprises, peut personnaliser les contrats intelligents Plasma pour fournir une infrastructure évolutive qui fonctionne dans différents contextes. | Se repose sur un ou plusieurs opérateurs pour stocker les données et les utiliser sur demande.                                                                                                                                            |
-| Réduit la charge sur le réseau principal Ethereum en déplaçant la charge de calcul et de stockage hors chaîne.                                                                                                                                                                                              | Les retraits sont retardés de plusieurs jours pour permettre les contestations. Pour les actifs fongibles, ce problème peut être atténué par les fournisseurs de liquidités, mais il y a un coût en capital associé.                      |
-|                                                                                                                                                                                                                                                                                                             | Si trop d'utilisateurs tentent de quitter simultanément, le réseau principal Ethereum pourrait être congestionné.                                                                                                                         |
+| Avantages                                                                                                                                                                                                                                                                                                                                   | Inconvénients                                                                                                                                                                                                                                                                                |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Permet un débit élevé et un faible coût de transaction.                                                                                                                                                                                                                                                                     | Ne prend pas en charge le calcul général (ne peut pas exécuter de contrats intelligents). Seuls les transferts de jetons de base, les échanges et quelques autres types de transactions sont pris en charge par la logique des prédicats. |
+| Convient aux transactions entre utilisateurs arbitraires (pas de surcharge par paire utilisateur si les deux sont établis sur la chaîne Plasma).                                                                                                                                                         | Nécessité de surveiller périodiquement le réseau (exigence de vivacité) ou de déléguer cette responsabilité à quelqu'un d'autre pour garantir la sécurité de vos fonds.                                                                                   |
+| Les chaînes Plasma peuvent être adaptées à des cas d'utilisation spécifiques qui ne sont pas liés à la chaîne principale. N'importe qui, y compris les entreprises, peut personnaliser les contrats intelligents Plasma pour fournir une infrastructure évolutive qui fonctionne dans différents contextes. | Se repose sur un ou plusieurs opérateurs pour stocker les données et les utiliser sur demande.                                                                                                                                                                               |
+| Réduit la charge sur le réseau principal Ethereum en déplaçant la charge de calcul et de stockage hors chaîne.                                                                                                                                                                                                              | Les retraits sont retardés de plusieurs jours pour permettre les contestations. Pour les actifs fongibles, ce problème peut être atténué par les fournisseurs de liquidités, mais il y a un coût en capital associé.                                         |
+|                                                                                                                                                                                                                                                                                                                                             | Si trop d'utilisateurs tentent de quitter simultanément, le réseau principal Ethereum pourrait être congestionné.                                                                                                                                                            |
 
-## Protocoles de mise à l'échelle du plasma par rapport à la couche 2 {#plasma-vs-layer-2}
+## Plasma vs les protocoles d'évolutivité de couche 2 {#plasma-vs-layer-2}
 
-Si Plasma était autrefois considéré comme une solution de mise à l'échelle utile pour Ethereum, il a depuis été abandonné au profit de [protocoles de mise à l'échelle de couche 2 (L2)](/layer-2/). Les solutions de mise à l'échelle L2 remédient à plusieurs des problèmes de Plasma :
+Bien que Plasma ait été autrefois considéré comme une solution d'évolutivité utile pour Ethereum, il a depuis été abandonné au profit des [protocoles d'évolutivité de couche 2 (L2)](/layer-2/). Les solutions de mise à l'échelle L2 remédient à plusieurs des problèmes de Plasma :
 
 ### Efficacité {#efficiency}
 
-[Les rollups Zero-Knowledge](/developers/docs/scaling/zk-rollups) génèrent des preuves cryptographiques de la validité de chaque lot de transactions traitées hors chaîne. Cela empêche les utilisateurs (et les opérateurs) d'avancer des transitions d'état invalides, éliminant ainsi le besoin de périodes de défi et de jeux de sortie. Cela signifie également que les utilisateurs n'ont pas à surveiller périodiquement la chaîne pour sécuriser leurs fonds.
+Les [rollups ZK](/developers/docs/scaling/zk-rollups) génèrent des preuves cryptographiques de la validité de chaque lot de transactions traitées hors chaîne. Cela empêche les utilisateurs (et les opérateurs) d'avancer des transitions d'état invalides, éliminant ainsi le besoin de périodes de défi et de jeux de sortie. Cela signifie également que les utilisateurs n'ont pas à surveiller périodiquement la chaîne pour sécuriser leurs fonds.
 
 ### Prise en charge des contrats intelligents {#support-for-smart-contracts}
 
-Un autre problème du cadre plasma était [l'incapacité à prendre en charge l'exécution de contrats intelligents Ethereum](https://ethresear.ch/t/why-smart-contracts-are-not-feasible-on-plasma/2598/4). En conséquence, la plupart des implémentations de Plasma ont été construites pour des paiements simples ou l'échange de jetons ERC-20.
+Un autre problème avec le cadre Plasma était [l'incapacité à prendre en charge l'exécution des contrats intelligents d'Ethereum](https://ethresear.ch/t/why-smart-contracts-are-not-feasible-on-plasma/2598/4). En conséquence, la plupart des implémentations de Plasma ont été construites pour des paiements simples ou l'échange de jetons ERC-20.
 
-À l'inverse, les rollups optimistes sont compatibles avec la [machine virtuelle Ethereum](/developers/docs/evm/) et peuvent exécuter des [contrats intelligents](/developers/docs/smart-contracts/) natifs d'Ethereum, ce qui en fait une solution utile et _sûre_ pour la mise à l'échelle des [applications décentralisées](/developers/docs/dapps/). De même, des plans sont en cours pour [créer une mise en œuvre à connaissance zéro de l'EVM (zkEVM)](https://ethresear.ch/t/a-zk-evm-specification/11549) qui permettrait aux ZK-rollups de traiter une logique arbitraire et d'exécuter des contrats intelligents.
+Inversement, les rollups optimistes sont compatibles avec la [machine virtuelle Ethereum](/developers/docs/evm/) et peuvent exécuter des [contrats intelligents](/developers/docs/smart-contracts/) natifs d'Ethereum, ce qui en fait une solution utile et _sécurisée_ pour l'évolutivité des [applications décentralisées](/developers/docs/dapps/). De même, des projets sont en cours pour [créer une implémentation zero-knowledge de l'EVM (zkEVM)](https://ethresear.ch/t/a-zk-evm-specification/11549) qui permettrait aux rollups ZK de traiter une logique arbitraire et d'exécuter des contrats intelligents.
 
 ### Indisponibilité des données {#data-unavailability}
 
 Comme expliqué précédemment, Plasma souffre d'un problème de disponibilité des données. Si un opérateur malveillant pousse une transaction non valide sur la chaîne Plasma, les utilisateurs ne seraient pas en mesure de la contester car l'opérateur peut refuser de fournir les données nécessaires à la constitution de la preuve de fraude. Les rollups résolvent ce problème en obligeant les opérateurs à publier les données des transactions sur Ethereum, ce qui permet à quiconque de vérifier l'état de la chaîne et de créer des preuves de fraude si nécessaire.
 
-### Problème de sortie en masse {#mass-exit-problem}
+### Problème de la sortie de masse {#mass-exit-problem}
 
 Les ZK-rollups et les rollups optimistes résolvent tous deux le problème de sortie de masse de Plasma de différentes manières. Par exemple, un ZK-rollup repose sur des mécanismes cryptographiques qui garantissent que les opérateurs ne peuvent pas voler les fonds des utilisateurs, quel que soit le scénario.
 
@@ -144,7 +144,8 @@ Plasma, les chaînes latérales et la fragmentation sont assez similaires car il
 
 ### Plasma vs chaînes latérales {#plasma-vs-sidechains}
 
-Une [chaîne latérale](/developers/docs/scaling/sidechains/) est une blockchain indépendante connectée au réseau principal Ethereum via un pont bidirectionnel. [Les ponts](/bridges/) permettent aux utilisateurs d'échanger des jetons entre les deux blockchains pour effectuer des transactions sur la chaîne latérale, réduisant ainsi la congestion sur le réseau principal Ethereum et améliorant l'évolutivité. Les chaînes latérales utilisent un mécanisme de consensus séparé et sont généralement beaucoup plus petites que le réseau principal Ethereum. Par conséquent, le passage des actifs vers ces chaînes implique un risque accru ; étant donné l'absence de garanties de sécurité héritées du réseau principal Ethereum dans le modèle de la chaîne latérale, les utilisateurs risquent la perte de fonds lors d'une attaque sur la chaîne latérale.
+Une [chaîne latérale](/developers/docs/scaling/sidechains/) est une blockchain exploitée de manière indépendante et connectée au réseau principal d'Ethereum via un pont bidirectionnel. Les [ponts](/bridges/) permettent aux utilisateurs d'échanger des jetons entre les deux blockchains pour effectuer des transactions sur la chaîne latérale, réduisant ainsi la congestion sur le réseau principal d'Ethereum et améliorant l'évolutivité.
+Les chaînes latérales utilisent un mécanisme de consensus séparé et sont généralement beaucoup plus petites que le réseau principal Ethereum. Par conséquent, le passage des actifs vers ces chaînes implique un risque accru ; étant donné l'absence de garanties de sécurité héritées du réseau principal Ethereum dans le modèle de la chaîne latérale, les utilisateurs risquent la perte de fonds lors d'une attaque sur la chaîne latérale.
 
 Inversement, les chaînes Plasma tirent leur sécurité du réseau principal. Cela les rend mesurablement plus sûres que les chaînes latérales. Les chaînes latérales et Plasma peuvent avoir des protocoles de consensus différents, mais la différence est que les chaînes Plasma publient les racines Merkle pour chaque bloc sur le réseau principal Ethereum. Les racines des blocs sont des parties d'informations que nous pouvons utiliser pour vérifier celles sur les transactions qui se produisent sur une chaîne Plasma. Si une attaque se produit sur une chaîne Plasma, les utilisateurs peuvent retirer leurs fonds en toute sécurité du réseau principal en utilisant les preuves appropriées.
 
@@ -156,20 +157,20 @@ Les chaînes fragmentées commettent des « en-têtes de classement » sur le r
 
 Plasma est différent car le réseau principal ne reçoit qu'un minimum d'informations sur l'état des chaînes enfants. Cela signifie que le réseau principal ne peut pas vérifier efficacement les transactions effectuées sur les chaînes enfants, ce qui les rend moins sécurisées.
 
-**Notez que** la fragmentation de la blockchain Ethereum n'est plus sur la feuille de route. Il a été remplacé par la mise à l'échelle via des rollups et [Danksharding](/roadmap/danksharding).
+**Remarque** : la fragmentation de la blockchain Ethereum ne figure plus sur la feuille de route. Elle a été remplacée par l'évolutivité via les rollups et [Danksharding](/roadmap/danksharding).
 
-### Chaînes Plasma que vous pouvez utiliser {#use-plasma}
+### Utiliser Plasma {#use-plasma}
 
 Plusieurs projets fournissent des implémentations de Plasma que vous pouvez intégrer dans vos dApps :
 
 - [Polygon](https://polygon.technology/) (anciennement Matic Network)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Apprendre Plasma](https://www.learnplasma.org/en/)
-- [Un rappel rapide de ce que signifie « sécurité partagée » et pourquoi c'est si important](https://old.reddit.com/r/ethereum/comments/sgd3zt/a_quick_reminder_of_what_shared_security_means/)
+- [En savoir plus sur Plasma](https://www.learnplasma.org/en/)
+- [Un petit rappel de ce que signifie la "sécurité partagée" et pourquoi elle est si importante](https://old.reddit.com/r/ethereum/comments/sgd3zt/a_quick_reminder_of_what_shared_security_means/)
 - [Chaînes latérales vs Plasma vs Fragmentation](https://vitalik.eth.limo/general/2019/06/12/plasma_vs_sharding.html)
-- [Comprendre Plasma, Partie 1 : Les bases](https://www.theblockcrypto.com/amp/post/10793/understanding-plasma-part-1-the-basics)
-- [La vie et la mort de Plasma](https://medium.com/dragonfly-research/the-life-and-death-of-plasma-b72c6a59c5ad#)
+- [Comprendre Plasma, 1re partie : les bases](https://www.theblockcrypto.com/amp/post/10793/understanding-plasma-part-1-the-basics)
+- [Vie et mort de Plasma](https://medium.com/dragonfly-research/the-life-and-death-of-plasma-b72c6a59c5ad#)
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/scaling/sidechains/index.md b/public/content/translations/fr/developers/docs/scaling/sidechains/index.md
index 70913d40428..f215cc1ce80 100644
--- a/public/content/translations/fr/developers/docs/scaling/sidechains/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/sidechains/index.md
@@ -1,13 +1,13 @@
 ---
-title: Chaines latérales
-description: Une introduction aux chaînes latérales en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum.
+title: "Chaines latérales"
+description: "Une introduction aux chaînes latérales en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum."
 lang: fr
 sidebarDepth: 3
 ---
 
-Une chaîne latérale est une blockchain séparée qui fonctionne indépendamment d'Ethereum et qui est connectée au réseau principal d'Ethereum par un pont bidirectionnel. Les chaînes latérales peuvent avoir des paramètres de bloc distincts et [des algorithmes de consensus](/developers/docs/consensus-mechanisms/), qui sont souvent conçus pour un traitement efficace des transactions. L'utilisation d'une chaîne latérale implique toutefois des compromis, car elle n'hérite pas des propriétés de sécurité d'Ethereum. Contrairement aux [solutions de mise à l'échelle de couche 2](/layer-2/), les chaînes latérales ne renvoient pas les changements d'état et les données de transaction au réseau principal Ethereum.
+Une chaîne latérale est une blockchain séparée qui fonctionne indépendamment d'Ethereum et qui est connectée au réseau principal d'Ethereum par un pont bidirectionnel. Les chaînes latérales peuvent avoir des paramètres de bloc distincts et des [algorithmes de consensus](/developers/docs/consensus-mechanisms/), qui sont souvent conçus pour un traitement efficace des transactions. L'utilisation d'une chaîne latérale implique toutefois des compromis, car elle n'hérite pas des propriétés de sécurité d'Ethereum. Contrairement aux [solutions de mise à l'échelle de couche 2](/layer-2/), les chaînes latérales ne renvoient pas les changements d'état et les données de transaction au réseau principal Ethereum.
 
-Les chaînes latérales compromettent également une partie de la décentralisation ou de la sécurité pour atteindre un débit élevé ([trilemme de l'évolutivité](https://vitalik.eth.limo/general/2021/05/23/scaling.html)). Ethereum s'engage toutefois à évoluer sans compromettre la décentralisation et la sécurité, comme indiqué dans sa [déclaration de vision](/roadmap/) pour les mises à niveau.
+Les chaînes latérales compromettent également une partie de la décentralisation ou de la sécurité pour atteindre un débit élevé ([trilemme de l'évolutivité](https://vitalik.eth.limo/general/2021/05/23/scaling.html)). Ethereum s'engage toutefois à évoluer sans compromettre la décentralisation et la sécurité.
 
 ## Comment fonctionnent les chaînes latérales ? {#how-do-sidechains-work}
 
@@ -19,44 +19,44 @@ L'un des points qui rend les chaînes latérales uniques (c'est-à-dire différe
 
 - [Preuve d'autorité](/developers/docs/consensus-mechanisms/poa/)
 - [Preuve d'enjeu déléguée](https://en.bitcoin.it/wiki/Delegated_proof_of_stake)
-- [Problème des généraux byzantins](https://decrypt.co/resources/byzantine-fault-tolerance-what-is-it-explained).
+- [Tolérance aux pannes byzantines](https://decrypt.co/resources/byzantine-fault-tolerance-what-is-it-explained).
 
 Tout comme Ethereum, les chaînes latérales ont des nœuds qui vérifient et traitent les transactions, produisent des blocs et stockent l'état de la blockchain. Les validateurs sont également responsables du maintien du consensus à travers le réseau et de sa sécurisation contre les attaques malveillantes.
 
-#### Paramètres des blocs {#block-parameters}
+#### Paramètres de bloc {#block-parameters}
 
-Ethereum place des limites sur [le temps de bloc](/developers/docs/blocks/#block-time) (à savoir le temps qu'il faut pour produire de nouveaux blocs) et sur [la taille des blocs](/developers/docs/blocks/#block-size) (à savoir la quantité de données contenues par bloc libellé en gaz). Inversement, les chaînes latérales adoptent souvent des paramètres différents, tels que des temps de blocs plus rapides et des limites de gaz plus élevées, pour atteindre un débit élevé, des transactions rapides et de faibles frais.
+Ethereum impose des limites sur les [temps de bloc](/developers/docs/blocks/#block-time) (à savoir, le temps nécessaire pour produire de nouveaux blocs) et la [taille des blocs](/developers/docs/blocks/#block-size) (à savoir, la quantité de données contenues par bloc, exprimée en gaz). Inversement, les chaînes latérales adoptent souvent des paramètres différents, tels que des temps de blocs plus rapides et des limites de gaz plus élevées, pour atteindre un débit élevé, des transactions rapides et de faibles frais.
 
 Bien que cela présente certains avantages, cela a des implications critiques pour la décentralisation et la sécurité des réseaux. Les paramètres de blocs tels que la temporalité séparant chaque bloc ainsi que la taille de ces derniers peuvent accroître la difficulté d'exécuter un noeud complet, laissant quelques « supernoeuds » responsables de la sécurisation de la chaîne. Dans un tel scénario, la possibilité d'une collusion de validateurs ou d'une prise de contrôle malveillante de la chaîne augmente.
 
-Pour que les blockchains s'échelonnent sans nuire à la décentralisation, exécuter un nœud doit être ouvert à tout le monde — pas nécessairement aux parties qui disposent de matériel spécialisé. C'est pourquoi des efforts sont en cours pour s'assurer que tout le monde peut [exécuter un nœud complet](/developers/docs/nodes-and-clients/#why-should-i-run-an-ethereum-node) sur le réseau Ethereum.
+Pour que les blockchains s'échelonnent sans nuire à la décentralisation, exécuter un nœud doit être ouvert à tout le monde — pas nécessairement aux parties qui disposent de matériel spécialisé. C'est pourquoi des efforts sont en cours pour s'assurer que tout le monde puisse [exécuter un nœud complet](/developers/docs/nodes-and-clients/#why-should-i-run-an-ethereum-node) sur le réseau Ethereum.
 
 ### Compatibilité EVM {#evm-compatibility}
 
-Certaines chaînes latérales sont compatibles avec l'EVM et sont capables d'exécuter des contrats développés pour la [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Les chaînes latérales compatibles avec l'EVM prennent en charge les contrats intelligents [écrits en Solidity](/developers/docs/smart-contracts/languages/), ainsi que d'autres langages de contrats intelligents EVM, ce qui signifie que les contrats intelligents écrits pour le réseau principal Ethereum fonctionneront également sur les chaînes latérales compatibles avec l'EVM.
+Certaines chaînes latérales sont compatibles avec l'EVM et sont capables d'exécuter des contrats développés pour la [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Les chaînes latérales compatibles avec l'EVM prennent en charge les contrats intelligents [écrits en Solidity](/developers/docs/smart-contracts/languages/), ainsi que d'autres langages de contrats intelligents EVM, ce qui signifie que les contrats intelligents écrits pour le réseau principal Ethereum fonctionneront également sur des chaînes latérales compatibles avec l'EVM.
 
-Cela signifie que si vous voulez utiliser votre [dApp](/developers/docs/dapps/) sur une chaîne latérale, il suffit de déployer votre [contrat intelligent](/developers/docs/smart-contracts/) sur cette chaîne latérale. Cela ressemble en tout point à une interaction avec le réseau principal : vous écrivez vos contrats en Solidity et interagissez avec la chaîne via les RPC des chaînes latérales.
+Cela signifie que si vous voulez utiliser votre [dapp](/developers/docs/dapps/) sur une chaîne latérale, il vous suffit de déployer votre [contrat intelligent](/developers/docs/smart-contracts/) sur cette chaîne latérale. Cela ressemble en tout point à une interaction avec le réseau principal : vous écrivez vos contrats en Solidity et interagissez avec la chaîne via les RPC des chaînes latérales.
 
-Comme les chaînes latérales sont compatibles avec l'EVM, elles sont considérées comme une [solution de mise à l'échelle](/developers/docs/scaling/) utile pour les dApps natives d'Ethereum. En utilisant une dApp sur une chaîne latérale, les utilisateurs peuvent bénéficier de frais de gaz moins élevés et de transactions plus rapides, surtout si le réseau principal est encombré.
+Parce que les chaînes latérales sont compatibles avec l'EVM, elles sont considérées comme une [solution de mise à l'échelle](/developers/docs/scaling/) utile pour les dapps natives d'Ethereum. En utilisant une dApp sur une chaîne latérale, les utilisateurs peuvent bénéficier de frais de gaz moins élevés et de transactions plus rapides, surtout si le réseau principal est encombré.
 
 Cependant, comme expliqué précédemment, l'utilisation d'une chaîne latérale implique des compromis importants. Chaque chaîne latérale est responsable de sa sécurité et n'hérite pas des propriétés de sécurité d'Ethereum. Cela augmente la possibilité de comportements malveillants qui peuvent affecter les utilisateurs ou mettre leurs fonds en péril.
 
-### Mouvement des actifs {#asset-movement}
+### Mouvement d'actifs {#asset-movement}
 
-Afin qu'une blockchain séparée devienne une chaîne latérale vers le réseau principal Ethereum, elle a besoin de la capacité de faciliter le transfert des actifs depuis et vers le réseau principal Ethereum. Cette interopérabilité avec Ethereum est obtenue à l'aide d'un pont de connexion blockchain. [Les ponts](/bridges/) utilisent des contrats intelligents déployés sur le réseau principal Ethereum et une chaîne latérale pour contrôler la connexion des fonds entre eux.
+Afin qu'une blockchain séparée devienne une chaîne latérale vers le réseau principal Ethereum, elle a besoin de la capacité de faciliter le transfert des actifs depuis et vers le réseau principal Ethereum. Cette interopérabilité avec Ethereum est obtenue à l'aide d'un pont de connexion blockchain. [Les ponts](/bridges/) utilisent des contrats intelligents déployés sur le réseau principal Ethereum et une chaîne latérale pour contrôler le pontage des fonds entre eux.
 
-Alors que les ponts aident les utilisateurs à déplacer les fonds entre Ethereum et la chaîne parallèle, les actifs ne sont pas déplacés physiquement entre les deux chaînes. Au lieu de cela, le transfert des actifs entre les chaînes est effectué en utilisant les mécanismes de création (mint) et de destruction (burn). En savoir plus sur [comment les ponts fonctionnent](/developers/docs/bridges/#how-do-bridges-work).
+Alors que les ponts aident les utilisateurs à déplacer les fonds entre Ethereum et la chaîne parallèle, les actifs ne sont pas déplacés physiquement entre les deux chaînes. Au lieu de cela, le transfert des actifs entre les chaînes est effectué en utilisant les mécanismes de création (mint) et de destruction (burn). En savoir plus sur [le fonctionnement des ponts](/developers/docs/bridges/#how-do-bridges-work).
 
 ## Avantages et inconvénients des chaînes latérales {#pros-and-cons-of-sidechains}
 
-| Avantages                                                                                                                                                              | Inconvénients                                                                                                                                                                                |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| La technologie qui est derrière les chaînes latérales est bien établie et bénéficie de recherches approfondies et d'améliorations de conception.                       | Les chaînes latérales sacrifient un peu de décentralisation et de confiance pour de l'évolutivité.                                                                                           |
-| Les chaînes latérales prennent en charge le calcul général et offrent une compatibilité avec l'EVM (et peuvent exécuter des dApps natives d'Ethereum).                 | Une chaîne latérale utilise un mécanisme de consensus distinct et ne bénéficie pas des garanties de sécurité d'Ethereum.                                                                     |
-| Les chaines parallèles utilisent différents modèles de consensus pour traiter efficacement les transactions et réduire les frais de transaction pour les utilisateurs. | Les chaînes latérales nécessitent une confiance plus élevée quant à son fonctionnement (par exemple, un quorum de validateurs malveillants de la chaîne latérale peut commettre une fraude). |
-| Les chaînes latérales compatibles avec l'EVM permettent aux dApps d'élargir leur écosystème.                                                                           |                                                                                                                                                                                              |
+| Avantages                                                                                                                                                                                 | Inconvénients                                                                                                                                                                                                                   |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| La technologie qui est derrière les chaînes latérales est bien établie et bénéficie de recherches approfondies et d'améliorations de conception.                          | Les chaînes latérales sacrifient un peu de décentralisation et de confiance pour de l'évolutivité.                                                                                                              |
+| Les chaînes latérales prennent en charge le calcul général et offrent une compatibilité avec l'EVM (et peuvent exécuter des dApps natives d'Ethereum). | Une chaîne latérale utilise un mécanisme de consensus distinct et ne bénéficie pas des garanties de sécurité d'Ethereum.                                                                                        |
+| Les chaines parallèles utilisent différents modèles de consensus pour traiter efficacement les transactions et réduire les frais de transaction pour les utilisateurs.    | Les chaînes latérales nécessitent une confiance plus élevée quant à son fonctionnement (par exemple, un quorum de validateurs malveillants de la chaîne latérale peut commettre une fraude). |
+| Les chaînes latérales compatibles avec l'EVM permettent aux dApps d'élargir leur écosystème.                                                                              |                                                                                                                                                                                                                                 |
 
-### Chaînes latérales que vous pouvez utiliser {#use-sidechains}
+### Utilisation des chaînes latérales {#use-sidechains}
 
 Plusieurs projets fournissent des implémentations de chaînes latérales que vous pouvez intégrer dans vos dApps :
 
@@ -66,8 +66,8 @@ Plusieurs projets fournissent des implémentations de chaînes latérales que vo
 - [Loom Network](https://loomx.io/)
 - [Metis Andromeda](https://www.metis.io/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Scaling Ethereum dapps through Sidechains](https://medium.com/loom-network/dappchains-scaling-ethereum-dapps-through-sidechains-f99e51fff447) _8 février 2018, Georgios Konstantopoulos_
+- [Mise à l'échelle des dapps Ethereum grâce aux chaînes latérales](https://medium.com/loom-network/dappchains-scaling-ethereum-dapps-through-sidechains-f99e51fff447) _8 février 2018 - Georgios Konstantopoulos_
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/scaling/state-channels/index.md b/public/content/translations/fr/developers/docs/scaling/state-channels/index.md
index 9e7ba33ead7..8be13502cba 100644
--- a/public/content/translations/fr/developers/docs/scaling/state-channels/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/state-channels/index.md
@@ -1,6 +1,6 @@
 ---
-title: Canaux d'état
-description: Une introduction aux canaux d'état et canaux de paiement en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum.
+title: "Canaux d'état"
+description: "Une introduction aux canaux d'état et canaux de paiement en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum."
 lang: fr
 sidebarDepth: 3
 ---
diff --git a/public/content/translations/fr/developers/docs/scaling/validium/index.md b/public/content/translations/fr/developers/docs/scaling/validium/index.md
index e5a8482e99f..6bda6c7fc28 100644
--- a/public/content/translations/fr/developers/docs/scaling/validium/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/validium/index.md
@@ -1,23 +1,23 @@
 ---
-title: Validium
-description: Une introduction au Validium en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum.
+title: "Validité"
+description: "Une introduction au Validium en tant que solution de mise à l'échelle actuellement utilisée par la communauté Ethereum."
 lang: fr
 sidebarDepth: 3
 ---
 
-Validium est une [solution de mise à l'échelle](/developers/docs/scaling/) qui renforce l'intégrité des transactions à l'aide de preuves de validité telles que des[ ZK-rollups](/developers/docs/scaling/zk-rollups/), mais ne stocke pas les données de transaction sur le réseau principal Ethereum. Alors que la disponibilité des données hors chaîne introduit des compromis, elle peut conduire à des améliorations massives en termes de mise à l'échelle (les validiums peuvent traiter [~9 000 transactions ou plus par seconde](https://blog.matter-labs.io/zkrollup-vs-validium-starkex-5614e38bc263)).
+Validium est une [solution de mise à l'échelle](/developers/docs/scaling/) qui garantit l'intégrité des transactions à l'aide de preuves de validité comme les [ZK-rollups](/developers/docs/scaling/zk-rollups/), mais ne stocke pas les données des transactions sur le réseau principal Ethereum. Bien que la disponibilité des données hors chaîne introduise des compromis, elle peut entraîner des améliorations massives de l'évolutivité (les validiums peuvent traiter [~9 000 transactions, ou plus, par seconde](https://blog.matter-labs.io/zkrollup-vs-validium-starkex-5614e38bc263)).
 
 ## Prérequis {#prerequisites}
 
-Vous devez avoir lu et compris notre page sur [la mise à l'échelle d'Ethereum](/developers/docs/scaling/) et [la couche 2](/layer-2).
+Vous devriez avoir lu et compris notre page sur l'[évolutivité d'Ethereum](/developers/docs/scaling/) et la [couche 2](/layer-2).
 
 ## Qu'est-ce qu'un validium ? {#what-is-validium}
 
-Les validiums sont des solutions de mise à l'échelle qui utilisent la disponibilité et le calcul des données hors chaîne visant à améliorer le débit en traitant les transactions hors du réseau principal Ethereum. Comme les rollups à connaissance nulle (ZK-rollups), les validiums publient [des preuves à connaissance nulle](/glossary/#zk-proof) pour vérifier les transactions hors chaîne sur Ethereum. Cela permet d'éviter les transitions d'état invalides et de renforcer les garanties de sécurité d'une chaîne de validium.
+Les validiums sont des solutions de mise à l'échelle qui utilisent la disponibilité et le calcul des données hors chaîne visant à améliorer le débit en traitant les transactions hors du réseau principal Ethereum. Comme les rollups à connaissance nulle (ZK-rollups), les validiums publient des [preuves à connaissance nulle](/glossary/#zk-proof) pour vérifier les transactions hors chaîne sur Ethereum. Cela permet d'éviter les transitions d'état invalides et de renforcer les garanties de sécurité d'une chaîne de validium.
 
-Ces « preuves de validité » peuvent prendre la forme de ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) ou de ZK-STARKs (Zero-Knowledge Scalable Transparent ARgument of Knowledge). Plus d'informations sur [les preuves de zero-knowledge](https://consensys.net/blog/blockchain-explained/zero-knowledge-proofs-starks-vs-snarks/).
+Ces « preuves de validité » peuvent prendre la forme de ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) ou de ZK-STARKs (Zero-Knowledge Scalable Transparent ARgument of Knowledge). En savoir plus sur les [preuves à connaissance nulle](https://consensys.net/blog/blockchain-explained/zero-knowledge-proofs-starks-vs-snarks/).
 
-Les fonds appartenant aux utilisateurs de Validium sont contrôlés par un contrat intelligent sur Ethereum. Les validiums offrent des retraits quasi-instantanés, un peu comme les ZK-rollups ; une fois que la preuve de validité d'une demande de retrait a été vérifiée sur le réseau principal, les utilisateurs peuvent retirer des fonds en fournissant [des preuves de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/). La preuve de Merkle valide l'inclusion de la transaction de retrait de l'utilisateur dans un lot de transactions vérifiées, ce qui permet au contrat en chaîne de traiter le retrait.
+Les fonds appartenant aux utilisateurs de Validium sont contrôlés par un contrat intelligent sur Ethereum. Les validiums offrent des retraits quasi instantanés, tout comme les ZK-rollups ; une fois la preuve de validité d'une demande de retrait vérifiée sur le réseau principal, les utilisateurs peuvent retirer des fonds en fournissant des [preuves de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/). La preuve de Merkle valide l'inclusion de la transaction de retrait de l'utilisateur dans un lot de transactions vérifiées, ce qui permet au contrat en chaîne de traiter le retrait.
 
 Cependant, les utilisateurs de validium peuvent voir leurs fonds gelés et leurs retraits restreints. Cela peut se produire si les gestionnaires de la disponibilité des données sur la chaîne de validium retiennent les données d'état hors chaîne auprès des utilisateurs. Sans accès aux données de transaction, les utilisateurs ne peuvent pas calculer la preuve de Merkle nécessaire pour prouver la propriété des fonds et exécuter les retraits.
 
@@ -27,9 +27,9 @@ C'est la principale différence entre les validiums et les ZK-rollups : leur pos
 
 Les validiums sont des protocoles de mise à l'échelle construits au-dessus de la chaîne Ethereum existante. Bien qu'elle exécute des transactions hors chaîne, une chaîne validium est administrée par un ensemble de contrats intelligents déployés sur le réseau principal, notamment :
 
-1. **Contrat du vérificateur** : Le contrat du vérificateur vérifie la validité des preuves soumises par l'opérateur du validium lors des mises à jour de l'état. Il s'agit notamment de preuves de validité attestant de l'exactitude des transactions hors chaîne et de preuves de disponibilité des données vérifiant l'existence des données de transactions hors chaîne.
+1. **Contrat du vérificateur** : le contrat du vérificateur vérifie la validité des preuves soumises par l'opérateur du validium lors des mises à jour de l'état. Il s'agit notamment de preuves de validité attestant de l'exactitude des transactions hors chaîne et de preuves de disponibilité des données vérifiant l'existence des données de transactions hors chaîne.
 
-2. **Contrat principal** : Le contrat principal stocke les engagements d'état (racines de Merkle) soumis par les producteurs de blocs et met à jour l'état du validium lorsqu'une preuve de validité est vérifiée sur la chaîne. Ce contrat traite également les dépôts et les retraits de la chaîne validium.
+2. **Contrat principal** : le contrat principal stocke les engagements d'état (racines de Merkle) soumis par les producteurs de blocs et met à jour l'état du validium une fois qu'une preuve de validité est vérifiée sur la chaîne. Ce contrat traite également les dépôts et les retraits de la chaîne validium.
 
 Les validiums s'appuient également sur la chaîne principale d'Ethereum pour les éléments suivants :
 
@@ -47,7 +47,7 @@ Si le contrat du vérificateur sur la chaîne juge la preuve invalide, les trans
 
 ### Transactions {#transactions}
 
-Les utilisateurs soumettent des transactions à l'opérateur, un nœud responsable de l'exécution des transactions sur la chaîne du validium. Certains validiums peuvent utiliser un seul opérateur pour exécuter la chaîne ou s'appuyer sur un [mécanisme de preuve d'enjeu (PoS)](/developers/docs/consensus-mechanisms/pos/) pour la rotation des opérateurs.
+Les utilisateurs soumettent des transactions à l'opérateur, un nœud responsable de l'exécution des transactions sur la chaîne du validium. Certains validiums peuvent utiliser un seul opérateur pour exécuter la chaîne ou s'appuyer sur un mécanisme de [preuve d'enjeu (PoS)](/developers/docs/consensus-mechanisms/pos/) pour la rotation des opérateurs.
 
 L'opérateur regroupe les transactions en un lot et l'envoie à un circuit de validation pour validation. Le circuit de preuve accepte le lot de transactions (et d'autres données pertinentes) comme entrées et produit une preuve de validité vérifiant que les opérations ont été effectuées correctement.
 
@@ -65,15 +65,15 @@ Pour transférer des fonds sur le Mainnet, un utilisateur de validium initie une
 
 Comme mécanisme anti-censure, le protocole validium permet aux utilisateurs de se retirer directement du contrat validium sans passer par l'opérateur. Dans ce cas, les utilisateurs doivent fournir au contrat du vérificateur une preuve de Merkle montrant l'inclusion d'un compte dans la racine de l'état. Si la preuve est acceptée, l'utilisateur peut appeler la fonction de retrait du contrat principal pour sortir ses fonds du validium.
 
-### Soumission par lot {#batch-submission}
+### Soumission par lots {#batch-submission}
 
 Après avoir exécuté un lot de transactions, l'opérateur soumet la preuve de validité associée au contrat du vérificateur et propose une nouvelle racine d'état au contrat principal. Si la preuve est valide, le contrat principal met à jour l'état du validium et finalise les résultats des transactions du lot.
 
-Contrairement à un rollup ZK les producteurs de blocs sur un validium ne sont pas tenus de publier les données de transaction pour les lots de transactions (seulement les en-têtes de blocs). Cela fait de Validium un protocole de mise à l'échelle purement hors chaîne, par opposition aux protocoles de mise à l'échelle « hybrides » (c'est-à-dire de [couche 2](/layer-2/)) qui publient des données d'état sur la chaîne principale d'Ethereum en tant que `calldata`.
+Contrairement à un rollup ZK les producteurs de blocs sur un validium ne sont pas tenus de publier les données de transaction pour les lots de transactions (seulement les en-têtes de blocs). Cela fait de Validium un protocole de mise à l'échelle purement hors chaîne, par opposition aux protocoles de mise à l'échelle « hybrides » (c'est-à-dire [la couche 2](/layer-2/)) qui publient les données d'état sur la chaîne principale d'Ethereum en utilisant des données blob, `calldata` ou une combinaison des deux.
 
 ### Disponibilité des données {#data-availability}
 
-Comme nous l'avons mentionné, les validiums utilisent un modèle de disponibilité des données hors chaîne, dans lequel les opérateurs stockent toutes les données de transaction hors du réseau principal Ethereum. La faible empreinte des données sur la chaîne de validium améliore la mise à l'échelle (le débit n'est pas limité par la capacité de traitement des données d'Ethereum) et réduit les frais d'utilisation (le coût de publication des `calldata` est plus faible).
+Comme nous l'avons mentionné, les validiums utilisent un modèle de disponibilité des données hors chaîne, dans lequel les opérateurs stockent toutes les données de transaction hors du réseau principal Ethereum. La faible empreinte de données en chaîne de Validium améliore l'évolutivité (le débit n’est pas limité par la capacité de traitement des données d’Ethereum) et réduit les frais utilisateurs (le coût de publication des données sur la chaîne est moindre).
 
 La disponibilité des données hors chaîne pose toutefois un problème : les données nécessaires à la création ou à la vérification des preuves de Merkle peuvent être indisponibles. Cela signifie que les utilisateurs peuvent être dans l'incapacité de retirer des fonds du contrat en chaîne si les opérateurs agissent de manière malveillante.
 
@@ -87,17 +87,17 @@ Les validiums diffèrent dans leur approche de la gestion de la disponibilité d
 
 Pour garantir la disponibilité des données hors chaîne, certaines solutions de validium désignent un groupe d'entités de confiance, appelé collectivement comité de disponibilité des données (DAC), pour stocker des copies de l'état et fournir une preuve de la disponibilité des données. Les DAC sont plus faciles à mettre en œuvre et nécessitent moins de coordination car le nombre de membres est faible.
 
-Cependant, les utilisateurs doivent faire confiance au DAC pour rendre les données disponibles en cas de besoin (par exemple, pour générer des preuves de Merkle). Il est possible que les membres des comités de disponibilité des données [soient compromis par un acteur malveillant](https://notes.ethereum.org/DD7GyItYQ02d0ax_X-UbWg?view) qui peut alors retenir les données hors chaîne.
+Cependant, les utilisateurs doivent faire confiance au DAC pour rendre les données disponibles en cas de besoin (par exemple, pour générer des preuves de Merkle). Il est possible que les membres des comités de disponibilité des données soient [compromis par un acteur malveillant](https://notes.ethereum.org/DD7GyItYQ02d0ax_X-UbWg?view) qui peut alors retenir les données hors chaîne.
 
-[Plus d'informations sur les comités de disponibilité des données dans les validiums](https://medium.com/starkware/data-availability-e5564c416424).
+[En savoir plus sur les comités de disponibilité des données dans les validiums](https://medium.com/starkware/data-availability-e5564c416424).
 
-#### Disponibilité des données liées {#bonded-data-availability}
+#### Disponibilité des données sous caution {#bonded-data-availability}
 
 D'autres validiums exigent que les participants chargés de stocker des données hors ligne mettent en jeu (c'est-à-dire verrouillent) des jetons dans un contrat intelligent avant d'assumer leur rôle. Cet enjeu sert de « lien » pour garantir un comportement honnête entre les gestionnaires de la disponibilité des données et réduit les hypothèses de confiance. Si ces participants ne parviennent pas à prouver la disponibilité des données, la caution est réduite.
 
 Dans un système de mise à disposition des données sous caution, n'importe qui peut être désigné pour détenir des données hors chaîne dès lors qu'il fournit la mise requise. Cela élargit le groupe de gestionnaires de la disponibilité des données éligibles, réduisant ainsi la centralisation qui affecte les comités de disponibilité des données (DAC). Plus important encore, cette approche s'appuie sur des incitations cryptoéconomiques pour prévenir les activités malveillantes, ce qui est considérablement plus sûr que de désigner des parties de confiance pour sécuriser les données hors ligne dans le validium.
 
-[Plus d'informations sur la disponibilité des données cautionnées dans les validiums](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf).
+[En savoir plus sur la disponibilité des données sous caution dans les validiums](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf).
 
 ## Volitions et validium {#volitions-and-validium}
 
@@ -109,21 +109,21 @@ Une bourse décentralisée (DEX) peut préférer utiliser l'infrastructure évol
 
 ## Validiums et compatibilité EVM {#validiums-and-evm-compatibility}
 
-Comme les rollups ZK, les validiums sont surtout adaptés à des applications simples, comme les échanges de jetons et les paiements. La prise en charge du calcul général et de l'exécution de contrats intelligents parmi les validiums est difficile à mettre en œuvre, compte tenu de la surcharge considérable que représente la preuve des instructions [EVM](/developers/docs/evm/) dans un circuit de preuve à connaissance nulle (ZK).
+Comme les rollups ZK, les validiums sont surtout adaptés à des applications simples, comme les échanges de jetons et les paiements. La prise en charge du calcul général et de l'exécution des contrats intelligents au sein des validiums est difficile à mettre en œuvre, étant donné la surcharge considérable que représente la preuve des instructions [EVM](/developers/docs/evm/) dans un circuit de preuve à connaissance nulle.
 
 Certains projets de validium tentent de contourner ce problème en compilant des langages compatibles avec l'EVM (par exemple, Solidity, Vyper) pour créer un bytecode personnalisé optimisé pour une preuve efficace. L'inconvénient de cette approche est que les nouvelles VM respectueuses de la preuve de connaissance zéro peuvent ne pas prendre en charge des codes d'opérations EVM importants, et les développeurs doivent écrire directement dans le langage de haut niveau pour une expérience optimale. Cela crée encore plus de problèmes : cela oblige les développeurs à construire des dApps avec une pile de développement entièrement nouvelle et rompt la compatibilité avec l'infrastructure Ethereum actuelle.
 
 Certaines équipes tentent toutefois d'optimiser les codes d'opérations EVM existants pour les circuits de preuve de connaissance zéro. Cela aboutira au développement d'une machine virtuelle Ethereum à connaissance zéro (zkEVM), une VM compatible avec l'EVM qui produit des preuves pour vérifier l'exactitude de l'exécution des programmes. Avec une zkEVM, les chaînes validium peuvent exécuter des contrats intelligents hors chaîne et soumettre des preuves de validité pour vérifier un calcul hors chaîne (sans avoir à l'exécuter à nouveau) sur Ethereum.
 
-[Plus d'informations sur les zkEVM](https://www.alchemy.com/overviews/zkevm).
+[En savoir plus sur les zkEVM](https://www.alchemy.com/overviews/zkevm).
 
 ## Comment les validiums font-ils évoluer Ethereum ? {#scaling-ethereum-with-validiums}
 
-### 1. Stockage de données hors chaîne {#offchain-data-storage}
+### 1. Stockage des données hors chaîne {#offchain-data-storage}
 
-Les projets de mise à l'échelle de la couche 2, tels que les rollups optimistes et les rollups ZK, échangent l'évolutivité infinie des protocoles de mise à l'échelle purement hors chaîne (par exemple, [Plasma](/developers/docs/scaling/plasma/)) contre la sécurité en publiant certaines données de transaction sur la couche 1. Mais cela signifie que les propriétés d'évolutivité des rollups sont limitées par la bande passante des données sur le réseau principal d'Ethereum ([la fragementation des données](/roadmap/danksharding/) propose d'améliorer la capacité de stockage des données d'Ethereum pour cette raison).
+Les projets de mise à l'échelle de couche 2, tels que les rollups optimistes et les ZK-rollups, échangent l'évolutivité infinie des protocoles de mise à l'échelle purement hors chaîne (p. ex., [Plasma](/developers/docs/scaling/plasma/)) contre la sécurité en publiant certaines données de transaction sur la L1. Mais cela signifie que les propriétés d'évolutivité des rollups sont limitées par la bande passante des données sur le réseau principal Ethereum (la [fragmentation des données](/roadmap/danksharding/) propose d'améliorer la capacité de stockage des données d'Ethereum pour cette raison).
 
-Les validiums atteignent l'évolutivité en conservant toutes les données de transaction hors chaîne et en ne publiant que les engagements d'état (et les preuves de validité) lorsqu'ils relaient les mises à jour d'état à la chaîne Ethereum principale. L'existence de preuves de validité donne toutefois aux validiums des garanties de sécurité plus élevées que d'autres solutions de mise à l'échelle purement hors chaîne, notamment Plasma et [les chaînes latérales](/developers/docs/scaling/sidechains/). En réduisant la quantité de données qu'Ethereum doit traiter avant de valider les transactions hors chaîne, les conceptions de validium augmentent considérablement le débit sur le réseau principal.
+Les validiums atteignent l'évolutivité en conservant toutes les données de transaction hors chaîne et en ne publiant que les engagements d'état (et les preuves de validité) lorsqu'ils relaient les mises à jour d'état à la chaîne Ethereum principale. L'existence de preuves de validité, cependant, donne aux validiums des garanties de sécurité plus élevées que d'autres solutions de mise à l'échelle purement hors chaîne, y compris Plasma et les [chaînes latérales](/developers/docs/scaling/sidechains/). En réduisant la quantité de données qu'Ethereum doit traiter avant de valider les transactions hors chaîne, les conceptions de validium augmentent considérablement le débit sur le réseau principal.
 
 ### 2. Preuves récursives {#recursive-proofs}
 
@@ -131,36 +131,35 @@ Une preuve récursive est une preuve de validité qui vérifie la validité d'au
 
 En général, chaque preuve de validité que l'opérateur de validium soumet à Ethereum pour vérification valide l'intégrité d'un seul bloc. Alors qu'une seule preuve récursive peut être utilisée pour confirmer la validité de plusieurs blocs de validium en même temps - ceci est possible puisque le circuit de preuve peut agréger récursivement plusieurs preuves de blocs en une preuve finale. Si le contrat du vérificateur en chaîne accepte la preuve récursive, tous les blocs sous-jacents sont finalisés immédiatement.
 
-## Les avantages et inconvénients du validium {#pros-and-cons-of-validium}
+## Avantages et inconvénients du validium {#pros-and-cons-of-validium}
 
-| Avantages                                                                                                                                                            | Inconvénients                                                                                                                                                                                              |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Avantages                                                                                                                                                                            | Inconvénients                                                                                                                                                                                                              |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Les preuves de validité assurent l'intégrité des transactions hors chaîne et empêchent les opérateurs de finaliser des mises à jour d'état invalides.                | La production de preuves de validité nécessite un matériel spécial, ce qui pose un risque de centralisation.                                                                                               |
-| Augmente l'efficacité du capital pour les utilisateurs (pas de retard dans le retrait des fonds vers Ethereum)                                                       | Prise en charge limitée du calcul général et des contrats intelligents ; langages spécialisés requis pour le développement.                                                                                |
+| Augmente l'efficacité du capital pour les utilisateurs (pas de retard dans le retrait des fonds vers Ethereum)                                                    | Prise en charge limitée du calcul général et des contrats intelligents ; langages spécialisés requis pour le développement.                                                                                |
 | Aucune vulnérabilité à certaines attaques économiques auxquelles sont confrontés les systèmes basés sur les preuves de fraude dans des applications à valeur élevée. | Une puissance de calcul élevée est nécessaire pour générer les preuves ZK ; non rentable pour les applications à faible débit.                                                                             |
-| Réduit les frais de gaz pour les utilisateurs en ne publiant pas les données d'appel sur le réseau principal d'Ethereum.                                             | Finalité subjective plus lente (10-30 min pour générer une preuve ZK) mais plus rapide jusqu'à la finalité complète car il n'y a pas de délai de contestation.                                             |
+| Réduit les frais de gaz pour les utilisateurs en ne publiant pas les données d'appel sur le réseau principal d'Ethereum.                                             | Finalité subjective plus lente (10-30 min pour générer une preuve ZK) mais plus rapide jusqu'à la finalité complète car il n'y a pas de délai de contestation.                          |
 | Adapté à des cas d'utilisation spécifiques, comme le commerce ou les jeux de blockchain, qui privilégient la confidentialité des transactions et l'évolutivité.      | Il est possible que les utilisateurs ne puissent pas retirer des fonds, car la génération de preuves de propriété Merkle nécessite que les données hors chaîne soient disponibles à tout moment.           |
 | La disponibilité des données hors chaîne offre des niveaux de débit plus élevés et augmente l'évolutivité.                                                           | Le modèle de sécurité repose sur des hypothèses de confiance et des incitations crypto-économiques, contrairement aux rollups ZK, qui reposent uniquement sur des mécanismes de sécurité cryptographiques. |
 
-### Utiliser Validium/Volitions {#use-validium-and-volitions}
+### Utiliser Validium et Volitions {#use-validium-and-volitions}
 
 De multiples projets fournissent des implémentations de Validium et de volitions que vous pouvez intégrer dans vos dApps :
 
-**StarkWare StarkEx** - _StarkEx est une solution d'évolutivité de la couche 2 (L2) d'Ethereum qui repose sur des preuves de validité. Il peut fonctionner en mode de disponibilité des données Rollup ZK ou Validium._
+**StarkWare StarkEx** - _StarkEx est une solution d'évolutivité de couche 2 (L2) d'Ethereum qui repose sur des preuves de validité._ Il peut fonctionner en mode de disponibilité des données Rollup ZK ou Validium._
 
 - [Documentation](https://docs.starkware.co/starkex-v4/starkex-deep-dive/data-availability-modes#validium)
 - [Site Web](https://starkware.co/starkex/)
 
-**Matter Labs zkPorter**- _zkPorter est un protocole de mise à l'échelle de couche 2 s'attaquant à la disponibilité des données avec une approche hybride qui combine les idées de rollup ZK et de fragmentation. Il peut prendre en charge un nombre arbitraire de fragments, chacun ayant sa propre politique de disponibilité des données._
+**Matter Labs zkPorter** - _zkPorter est un protocole de mise à l'échelle de couche 2 qui s'attaque à la disponibilité des données avec une approche hybride combinant les idées de zkRollup et de fragmentation._ Il peut prendre en charge un nombre arbitraire de fragments, chacun ayant sa propre politique de disponibilité des données._
 
 - [Blog](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf)
 - [Documentation](https://docs.zksync.io/zksync-protocol/rollup/data-availability)
 - [Site Web](https://zksync.io/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Validium et The Layer 2 Two-By-Two - Numéro 99](https://www.buildblockchain.tech/newsletter/issues/no-99-validium-and-the-layer-2-two-by-two)
-- [Rollups ZK vs Validium](https://blog.matter-labs.io/zkrollup-vs-validium-starkex-5614e38bc263)
+- [Validium et la matrice deux par deux de la couche 2 — Numéro 99](https://www.buildblockchain.tech/newsletter/issues/no-99-validium-and-the-layer-2-two-by-two)
+- [ZK-rollups contre Validium](https://blog.matter-labs.io/zkrollup-vs-validium-starkex-5614e38bc263)
 - [Volition et le spectre émergent de la disponibilité des données](https://medium.com/starkware/volition-and-the-emerging-data-availability-spectrum-87e8bfa09bb)
-- [Rollups, Validiums, et Volitions : Découvrez les solutions de mise à l'échelle d'Ethereum les plus récentes](https://medium.com/coinmonks/rollups-vs-validiums-vs-volitions-d76300170f4a)
-- [Guide Pratique des Rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
+- [Le guide pratique des rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
diff --git a/public/content/translations/fr/developers/docs/scaling/zk-rollups/index.md b/public/content/translations/fr/developers/docs/scaling/zk-rollups/index.md
index b4d1466350e..f7d7e906988 100644
--- a/public/content/translations/fr/developers/docs/scaling/zk-rollups/index.md
+++ b/public/content/translations/fr/developers/docs/scaling/zk-rollups/index.md
@@ -1,36 +1,36 @@
 ---
-title: Rollups Zero-knowledge (ZK)
-description: Une introduction aux rollups zero-knowledge, une solution de mise à l'échelle utilisée par la Communauté Ethereum.
+title: Rollups ZK
+description: "Une introduction aux rollups zero-knowledge, une solution de mise à l'échelle utilisée par la Communauté Ethereum."
 lang: fr
 ---
 
-Les rollups zero-knowledge (ZK-rollups) sont [des solutions de mise à l'échelle](/developers/docs/scaling/) de couche 2 qui augmentent le débit sur le réseau principal Ethereum en déplaçant le calcul et le stockage d'état hors chaîne. Les rollups ZK peuvent traiter des milliers de transactions par lot, puis publier sur le réseau principal uniquement quelques données sommaires. Ces données sommaires définissent les modifications qui doivent être apportées à l'état Ethereum et certaines preuves cryptographiques que ces modifications sont correctes.
+Les rollups à divulgation nulle de connaissance (rollups ZK) sont des [solutions de mise à l'échelle](/developers/docs/scaling/) de couche 2 qui augmentent le débit sur le réseau principal Ethereum en déplaçant le calcul et le stockage de l'état hors chaîne. Les rollups ZK peuvent traiter des milliers de transactions par lot, puis publier sur le réseau principal uniquement quelques données sommaires. Ces données sommaires définissent les modifications qui doivent être apportées à l'état Ethereum et certaines preuves cryptographiques que ces modifications sont correctes.
 
 ## Prérequis {#prerequisites}
 
-Vous devez avoir lu et compris notre page sur [la mise à l'échelle d'Ethereum](/developers/docs/scaling/) et [la couche 2](/layer-2).
+Vous devriez avoir lu et compris notre page sur l'[évolutivité d'Ethereum](/developers/docs/scaling/) et la [couche 2](/layer-2).
 
 ## Qu'est-ce que les rollups zero-knowledge ? {#what-are-zk-rollups}
 
-**Les rollups à connaissance nulle (ZK-rollups)** regroupent (« roll up ») les transactions dans des lots qui sont exécutés hors chaîne. Le calcul hors chaîne réduit la quantité de données qui doivent être publiées dans la blockchain. Les opérateurs ZK-rollup soumettent un résumé des modifications requises pour représenter toutes les transactions dans un lot plutôt que d'envoyer chaque transaction individuellement. Ils produisent également [des preuves de validité](/glossary/#validity-proof) pour prouver la justesse de leurs modifications.
+**Les rollups à divulgation nulle de connaissance (rollups ZK)** regroupent (ou « roll up ») les transactions dans des lots qui sont exécutés hors chaîne. Le calcul hors chaîne réduit la quantité de données qui doivent être publiées dans la blockchain. Les opérateurs ZK-rollup soumettent un résumé des modifications requises pour représenter toutes les transactions dans un lot plutôt que d'envoyer chaque transaction individuellement. Ils produisent également des [preuves de validité](/glossary/#validity-proof) pour prouver l'exactitude de leurs modifications.
 
-L'état du ZK-rollup est maintenu par un contrat intelligent déployé sur le réseau Ethereum. Pour mettre à jour cet état, les nœuds ZK-rollup doivent soumettre une preuve de validité pour vérification. Comme mentionné ci-dessus, la preuve de validité est l'assurance cryptographique que le changement d'état proposé par le rollup correspond au résultat de l'exécution du lot de transactions donné. Cela signifie que les rollups ZK doivent uniquement fournir des preuves de validité pour finaliser les transactions sur Ethereum au lieu de poster toutes les données de transaction sur la chaîne comme les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/).
+L'état du ZK-rollup est maintenu par un contrat intelligent déployé sur le réseau Ethereum. Pour mettre à jour cet état, les nœuds ZK-rollup doivent soumettre une preuve de validité pour vérification. Comme mentionné ci-dessus, la preuve de validité est l'assurance cryptographique que le changement d'état proposé par le rollup correspond au résultat de l'exécution du lot de transactions donné. Cela signifie que les rollups ZK ne doivent fournir que des preuves de validité pour finaliser les transactions sur Ethereum, au lieu de publier toutes les données de transaction en chaîne comme les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/).
 
-Le retrait de fonds d'un rollup ZK vers Ethereum se fait sans délai car les transactions de retraits sont exécutées une fois que le contrat de rollup ZK a vérifié la preuve de validité. À l'inverse, retirer des fonds depuis les rollups optimistes est sujet à un délai afin de permettre à quiconque de contester la transaction de sortie en produisant une [preuve de fraude](/glossary/#fraud-proof).
+Le retrait de fonds d'un rollup ZK vers Ethereum se fait sans délai car les transactions de retraits sont exécutées une fois que le contrat de rollup ZK a vérifié la preuve de validité. À l'inverse, le retrait de fonds des rollups optimistes est soumis à un délai pour permettre à quiconque de contester la transaction de sortie avec une [preuve de fraude](/glossary/#fraud-proof).
 
-Les rollups ZK écrivent les transactions sur Ethereum comme `calldata`. `calldata` est l'endroit où sont stockées les données qui sont incluses dans les appels externes aux fonctions des contrats intelligents. Les informations contenues dans `calldata` sont publiées sur la blockchain, permettant à quiconque de reconstituer l'état du rollup de manière indépendante. Les rollups ZK utilisent des techniques de compression pour réduire les données de transaction. Par exemple, les comptes sont représentés par un index plutôt que par une adresse, ce qui permet d'économiser 28 octets de données. La publication des données sur la chaîne représente un coût important pour les rollups, de sorte que la compression des données peut réduire les frais pour les utilisateurs.
+Les rollups ZK écrivent les transactions sur Ethereum en tant que `calldata`. Les `calldata` sont l'endroit où sont stockées les données incluses dans les appels externes aux fonctions des contrats intelligents. Les informations dans les `calldata` sont publiées sur la blockchain, ce qui permet à quiconque de reconstituer l'état du rollup de manière indépendante. Les rollups ZK utilisent des techniques de compression pour réduire les données de transaction. Par exemple, les comptes sont représentés par un index plutôt que par une adresse, ce qui permet d'économiser 28 octets de données. La publication des données sur la chaîne représente un coût important pour les rollups, de sorte que la compression des données peut réduire les frais pour les utilisateurs.
 
-## Comment les rollups ZK interagissent avec Ethereum ? {#zk-rollups-and-ethereum}
+## Comment les rollups ZK interagissent avec Ethereum ? Les rollups ZK et Ethereum {#zk-rollups-and-ethereum}
 
 Un rollup ZK est un protocole hors chaîne qui fonctionne au dessus de la blockchain Ethereum et qui est géré par des contrats intelligents Ethereum sur la chaîne. Les rollups ZK exécutent des transactions en dehors du réseau principal, mais soumettent périodiquement des lots de transactions effectuées hors chaîne à un contrat rollup exécuté sur la chaîne. Cet enregistrement de transactions est immuable, tout comme la blockchain Ethereum, et forme la chaîne ZK-rollup.
 
 L'architecture centrale du rollup ZK est composée des éléments suivants :
 
-1. **Les contrats en chaîne** : Le fonctionnement des rollups ZK est contrôlé par des contrats intelligents s'exécutant sur Ethereum. Cela inclut le contrat principal qui stocke les blocs du rollup, suit les dépôts et surveille les mises à jour d'état. Un autre contrat publié sur la chaîne (le contrat vérificateur) vérifie les preuves à divulgation nulle soumises par les producteurs de blocs. Ainsi, Ethereum sert de couche de base ou de « couche 1 » aux rollups ZK.
+1. **Contrats en chaîne** : Comme mentionné, le protocole de rollup ZK est contrôlé par des contrats intelligents s'exécutant sur Ethereum. Cela inclut le contrat principal qui stocke les blocs du rollup, suit les dépôts et surveille les mises à jour d'état. Un autre contrat publié sur la chaîne (le contrat vérificateur) vérifie les preuves à divulgation nulle soumises par les producteurs de blocs. Ainsi, Ethereum sert de couche de base ou de « couche 1 » aux rollups ZK.
 
-2. **Machine virtuelle (VM) hors chaîne** : Alors que le protocole de rollup ZK se trouve sur Ethereum, l'exécution des transactions et le stockage des états se font sur une machine virtuelle distincte, indépendante de l'[EVM](/developers/docs/evm/). Cette VM hors chaîne est l'environnement d'exécution des transactions sur le rollup ZK et sert de couche secondaire ou de « couche 2 » pour le protocole de rollup ZK. Les preuves de validité vérifiées sur le réseau principal d'Ethereum garantissent l'exactitude des transitions d'état dans la VM hors chaîne.
+2. **Machine virtuelle (VM) hors chaîne** : Bien que le protocole de rollup ZK réside sur Ethereum, l'exécution des transactions et le stockage de l'état se font sur une machine virtuelle distincte, indépendante de l'[EVM](/developers/docs/evm/). Cette VM hors chaîne est l'environnement d'exécution des transactions sur le rollup ZK et sert de couche secondaire ou de « couche 2 » pour le protocole de rollup ZK. Les preuves de validité vérifiées sur le réseau principal d'Ethereum garantissent l'exactitude des transitions d'état dans la VM hors chaîne.
 
-Les rollups ZK sont des « solutions hybrides de mise à l'échelle », des protocoles hors chaîne qui fonctionnement indépendamment d'Ethereum tout en profitant de sa sécurité. Plus précisément, le réseau Ethereum assure la validité des mises à jour d'état sur le rollup ZK et garantit la disponibilité de données derrière chaque mise à jour de l'état du rollup. Par conséquent, les rollups ZK sont considérablement plus sûrs que les solutions de mise à l'échelle hors chaîne pures, telles que les [chaînes latérales](/developers/docs/scaling/sidechains/), qui sont responsables de leurs propriétés de sécurité, ou les [validiums](/developers/docs/scaling/validium/), qui vérifient également les transactions sur Ethereum avec des preuves de validité, mais stockent les données de transaction ailleurs.
+Les rollups ZK sont des « solutions hybrides de mise à l'échelle », des protocoles hors chaîne qui fonctionnement indépendamment d'Ethereum tout en profitant de sa sécurité. Plus précisément, le réseau Ethereum assure la validité des mises à jour d'état sur le rollup ZK et garantit la disponibilité de données derrière chaque mise à jour de l'état du rollup. Par conséquent, les rollups ZK sont considérablement plus sûrs que les solutions de mise à l'échelle purement hors chaîne, telles que les [chaînes latérales](/developers/docs/scaling/sidechains/), qui sont responsables de leurs propres propriétés de sécurité, ou les [validiums](/developers/docs/scaling/validium/), qui vérifient également les transactions sur Ethereum avec des preuves de validité, mais stockent les données de transaction ailleurs.
 
 Les rollups ZK s'appuient sur le protocole Ethereum principal pour les raisons suivantes :
 
@@ -42,7 +42,7 @@ Les rollups ZK n'ont pas besoin de publier beaucoup de données de transaction s
 
 La présence d'une chaîne est nécessaire pour que les utilisateurs puissent interagir avec le rollup. Sans accès aux données de l'état, les utilisateurs ne peuvent pas consulter le solde de leur compte ou effectuer des transactions (par exemple, des retraits) qui dépendent des informations de l'état.
 
-### Finalité de la transaction {#transaction-finality}
+### Finalité des transactions {#transaction-finality}
 
 Ethereum agit comme une couche de règlement pour les rollups ZK : Les transactions L2 ne sont finalisées que si le contrat L1 accepte la preuve de validité. Cela élimine le risque que des opérateurs malveillants corrompent la chaîne (par exemple, en volant les fonds du rollup) puisque chaque transaction doit être approuvée sur le réseau principal. De plus, Ethereum garantit que les opérations des utilisateurs ne peuvent pas être inversées une fois finalisées sur la L1.
 
@@ -58,21 +58,21 @@ En tant que mesure de sécurité, les rollups ZK permettent aux utilisateurs de
 
 Les utilisateurs du rollup ZK signent les transactions et les soumettent aux opérateurs L2 pour traitement et inclusion dans le lot suivant. Dans certains cas, l'opérateur est une entité centralisée, appelée séquenceur, qui exécute les transactions, les regroupe en lots et les soumet à L1. Dans ce système, le séquenceur est la seule entité autorisée à produire des blocs L2 et à ajouter des transactions rollup au contrat ZK-rollup.
 
-D'autres rollups ZK peuvent faire tourner le rôle d'opérateur en utilisant un ensemble de validateurs de [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Les opérateurs potentiels déposent des fonds dans le contrat de rollup, le montant de chaque mise influençant les chances de l'opérateur d'être sélectionné pour produire le prochain lot de rollup. La mise de l'opérateur peut être réduite s'il agit de manière malveillante, ce qui l'incite à poster des blocs valides.
+D'autres rollups ZK peuvent alterner le rôle de l'opérateur en utilisant un ensemble de validateurs à [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). Les opérateurs potentiels déposent des fonds dans le contrat de rollup, le montant de chaque mise influençant les chances de l'opérateur d'être sélectionné pour produire le prochain lot de rollup. La mise de l'opérateur peut être réduite s'il agit de manière malveillante, ce qui l'incite à poster des blocs valides.
 
-#### Comment les rollups ZK publient les données de transaction sur Ethereum {#how-zk-rollups-publish-transaction-data-on-ethereum}
+#### Comment les rollups ZK publient des données de transaction sur Ethereum {#how-zk-rollups-publish-transaction-data-on-ethereum}
 
-Comme expliqué précédemment, les données de transaction sont publiées sur Ethereum en tant que `calldata`. `calldata` est une zone de données dans un contrat intelligent utilisée pour passer des arguments à une fonction et se comporte de manière similaire à [la mémoire](/developers/docs/smart-contracts/anatomy/#memory). Bien que les `calldata` ne soient pas stockées dans l'état d'Ethereum, elles demeurent sur la chaîne dans le cadre des [journaux d'historique](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html?highlight=memory#logs) de la chaîne Ethereum. Les `calldata` n'affectent pas l'état d'Ethereum, ce qui en fait un moyen bon marché de stocker des données sur la chaîne.
+Comme expliqué, les données de transaction sont publiées sur Ethereum en tant que `calldata`. Les `calldata` sont une zone de données dans un contrat intelligent utilisée pour passer des arguments à une fonction et se comportent de la même manière que la [mémoire](/developers/docs/smart-contracts/anatomy/#memory). Bien que les `calldata` ne soient pas stockées dans l'état d'Ethereum, elles persistent en chaîne dans les [journaux d'historique](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html?highlight=memory#logs) de la chaîne Ethereum. Les `calldata` n'affectent pas l'état d'Ethereum, ce qui en fait un moyen peu coûteux de stocker des données en chaîne.
 
-Le mot-clé `calldata` identifie souvent la méthode du contrat intelligent appelée par une transaction et contient les entrées de la méthode sous la forme d'une séquence arbitraire d'octets. Les rollups ZK utilisent `calldata` pour publier des données de transaction compressées sur la chaîne ; l'opérateur du rollup ajoute simplement un nouveau lot en appelant la fonction requise dans le contrat du rollup et passe les données compressées comme arguments de fonction. Cela permet de réduire les coûts pour les utilisateurs, car une grande partie des frais de rollup est consacrée au stockage des données de transaction sur la chaîne.
+Le mot-clé `calldata` identifie souvent la méthode du contrat intelligent appelée par une transaction et contient les entrées de la méthode sous la forme d'une séquence arbitraire d'octets. Les rollups ZK utilisent les `calldata` pour publier des données de transaction compressées en chaîne ; l'opérateur du rollup ajoute simplement un nouveau lot en appelant la fonction requise dans le contrat du rollup et transmet les données compressées comme arguments de la fonction. Cela permet de réduire les coûts pour les utilisateurs, car une grande partie des frais de rollup est consacrée au stockage des données de transaction sur la chaîne.
 
 ### Engagements d'état {#state-commitments}
 
-L'état du rollup ZK, qui comprend les comptes et les soldes de L2, est représenté sous la forme d'un [arbre de Merkle](/whitepaper/#merkle-trees). Un hachage cryptographique de la racine de l'arbre de Merkle (Merkle root) est stocké dans le contrat en chaîne, ce qui permet au protocole de rollup de suivre les changements d'état du rollup ZK.
+L'état du rollup ZK, qui comprend les comptes et les soldes de la couche 2, est représenté sous la forme d'un [arbre de Merkle](/whitepaper/#merkle-trees). Un hachage cryptographique de la racine de l'arbre de Merkle (Merkle root) est stocké dans le contrat en chaîne, ce qui permet au protocole de rollup de suivre les changements d'état du rollup ZK.
 
 Le rollup passe à un nouvel état après l'exécution d'un nouvel ensemble de transactions. L'opérateur qui a initié la transition d'état est tenu de calculer une nouvelle racine d'état et de la soumettre au contrat en chaîne. Si la preuve de validité associée au lot est authentifiée par le contrat du vérificateur, la nouvelle racine de Merkle devient la racine d'état canonique du rollup ZK.
 
-Outre le calcul des racines d'état, l'opérateur rollup ZK crée également une racine de lot - la racine d'un arbre de Merkle comprenant toutes les transactions d'un lot. Lorsqu'un nouveau lot est soumis, le contrat de rollup stocke la racine du lot, ce qui permet aux utilisateurs de prouver qu'une transaction (par exemple, une demande de retrait) a été incluse dans le lot. Les utilisateurs devront fournir les détails de la transaction, la racine du lot et une [preuve de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/) montrant le chemin d'inclusion.
+Outre le calcul des racines d'état, l'opérateur rollup ZK crée également une racine de lot - la racine d'un arbre de Merkle comprenant toutes les transactions d'un lot. Lorsqu'un nouveau lot est soumis, le contrat de rollup stocke la racine du lot, ce qui permet aux utilisateurs de prouver qu'une transaction (par exemple, une demande de retrait) a été incluse dans le lot. Les utilisateurs devront fournir les détails de la transaction, la racine du lot et une [preuve de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/) indiquant le chemin d'inclusion.
 
 ### Preuves de validité {#validity-proofs}
 
@@ -80,11 +80,11 @@ La nouvelle racine d'état que l'opérateur du rollup ZK soumet au contrat L1 es
 
 Mais le contrat du rollup n'acceptera pas automatiquement l'engagement d'état proposé tant que l'opérateur n'aura pas prouvé que la nouvelle racine de Merkle résulte de mises à jour correctes de l'état du rollup. Pour ce faire, l'opérateur ZK-rollup produit une preuve de validité, un engagement cryptographique succinct vérifiant l'exactitude des transactions par lots.
 
-Les preuves de validité permettent aux parties de prouver l'exactitude d'une déclaration sans révéler la déclaration elle-même, c'est pourquoi elles sont également appelées preuves à connaissance zéro. Les rollups ZK utilisent des preuves de validité pour confirmer l'exactitude des transitions d'état hors chaîne sans avoir à réexécuter les transactions sur Ethereum. Ces preuves peuvent se présenter sous la forme d'un [ZK-SNARK](https://arxiv.org/abs/2202.06877) (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) ou [ZK-STARK](https://eprint.iacr.org/2018/046) (Zero-Knowledge Scalable Transparent Argument of Knowledge).
+Les preuves de validité permettent aux parties de prouver l'exactitude d'une déclaration sans révéler la déclaration elle-même, c'est pourquoi elles sont également appelées preuves à connaissance zéro. Les rollups ZK utilisent des preuves de validité pour confirmer l'exactitude des transitions d'état hors chaîne sans avoir à réexécuter les transactions sur Ethereum. Ces preuves peuvent se présenter sous la forme d'un [ZK-SNARK](https://arxiv.org/abs/2202.06877) (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) ou d'un [ZK-STARK](https://eprint.iacr.org/2018/046) (Zero-Knowledge Scalable Transparent Argument of Knowledge).
 
 Les SNARK et les STARK permettent d'attester de l'intégrité du calcul hors chaîne dans les rollups ZK, bien que chaque type de preuve ait des caractéristiques distinctes.
 
-**ZK-SNARK**
+**ZK-SNARKs**
 
 Pour que le protocole ZK-SNARK fonctionne, il est nécessaire de créer une chaîne de référence commune (CRS) : la CRS fournit des paramètres publics pour prouver et vérifier les preuves de validité. La sécurité du système de preuve dépend de la configuration du SRC ; si les informations utilisées pour créer les paramètres publics tombent en possession d'acteurs malveillants, ceux-ci peuvent être en mesure de générer de fausses preuves de validité.
 
@@ -94,13 +94,13 @@ Les configurations de confiance sont utilisées car elles augmentent la sécurit
 
 En dehors des hypothèses de confiance, les ZK-SNARK sont populaires pour leur petite taille de preuve et leur vérification en temps constant. Comme la vérification des preuves sur L1 constitue le coût le plus important de l'exploitation d'un rollup ZK, les L2 utilisent les ZK-SNARK pour générer des preuves qui peuvent être vérifiées rapidement et à moindre coût sur le réseau principal.
 
-**ZK-STARK**
+**ZK-STARKs**
 
 Comme les SNARK ZK, les STARK ZK prouvent la validité du calcul hors chaîne sans révéler les entrées. Cependant, les ZK-STARK sont considérés comme une amélioration des ZK-SNARK en raison de leur évolutivité et de leur transparence.
 
 Les ZK-STARK sont « transparents », car ils peuvent fonctionner sans la mise en place fiable d'une chaîne de référence commune (CRS). Au lieu de cela, les ZK-STARK s'appuient sur un caractère aléatoire vérifiable publiquement pour définir les paramètres de génération et de vérification des preuves.
 
-Les ZK-STARK offrent également une meilleure évolutivité car le temps nécessaire pour prouver et vérifier les preuves de validité augmente _quasi linéairement_ par rapport à la complexité du calcul sous-jacent. Avec les ZK-SNARK, les temps de preuve et de vérification évoluent _linéairement_ par rapport à la taille du calcul sous-jacent. Cela signifie que les ZK-STARK nécessitent moins de temps que les ZK-SNARK à des fins de preuve et de vérification lorsque de grands ensembles de données sont impliqués, ce qui les rend utiles pour les applications à fort volume.
+Les ZK-STARKs offrent également une meilleure évolutivité car le temps nécessaire pour prouver et vérifier les preuves de validité augmente de manière _quasi-linéaire_ par rapport à la complexité du calcul sous-jacent. Avec les ZK-SNARKs, les temps de preuve et de vérification évoluent de manière _linéaire_ par rapport à la taille du calcul sous-jacent. Cela signifie que les ZK-STARK nécessitent moins de temps que les ZK-SNARK à des fins de preuve et de vérification lorsque de grands ensembles de données sont impliqués, ce qui les rend utiles pour les applications à fort volume.
 
 Les ZK-STARK sont également protégés contre les ordinateurs quantiques, tandis que la cryptographie à courbe elliptique (ECC) utilisée dans les ZK-SNARK est largement considérée comme sensible aux attaques des ordinateurs quantiques. L'inconvénient des ZK-STARK est qu'ils produisent des preuves de plus grande taille, ce qui est plus coûteux à vérifier sur Ethereum.
 
@@ -136,13 +136,13 @@ Le circuit de vérification ZK itère sur l'ensemble du lot de transactions, vé
 
 Après que le circuit de preuve vérifie l'exactitude des mises à jour d'état, l'opérateur L2 soumet la preuve de validité calculée au contrat du vérificateur sur L1. Le circuit de vérification du contrat vérifie la validité de la preuve et vérifie également les entrées publiques qui font partie de la preuve :
 
-- **Racine du pré-état** : La racine de l'ancien état du rollup ZK (c'est-à-dire avant l'exécution des transactions groupées), reflétant le dernier état valide connu de la chaîne L2.
+- **Racine de pré-état** : L'ancienne racine d'état du rollup ZK (c.-à-d. avant l'exécution des transactions groupées), reflétant le dernier état valide connu de la chaîne de couche 2.
 
-- **Racine post-état** : La racine du nouvel état du rollup ZK (c'est-à-dire après l'exécution des transactions par lots), reflétant le tout nouvel état de la chaîne L2. La racine post-état est la racine finale dérivée après l'application des mises à jour d'état dans le circuit de preuve.
+- **Racine post-état** : La nouvelle racine d'état du rollup ZK (c.-à-d. après l'exécution des transactions par lots), reflétant le nouvel état de la chaîne de couche 2. La racine post-état est la racine finale dérivée après l'application des mises à jour d'état dans le circuit de preuve.
 
-- **Racine du lot** : La racine Merkle du lot, dérivée en _merklizant_ les transactions du lot et en hachant la racine de l'arbre.
+- **Racine du lot** : La racine Merkle du lot, dérivée en _merklisant_ les transactions du lot et en hachant la racine de l'arbre.
 
-- **Entrées des transactions** : Données associées aux transactions exécutées dans le cadre du lot soumis.
+- **Entrées de transaction** : Données associées aux transactions exécutées dans le cadre du lot soumis.
 
 Si la preuve satisfait le circuit (c'est-à-dire qu'elle est valide), cela signifie qu'il existe une séquence de transactions valides qui font passer le rollup de l'état précédent (empreintes cryptographiques de la racine du pré-état) à un nouvel état (empreintes cryptographiques de la racine du post-état). Si la racine pré-état correspond à la racine stockée dans le contrat de rollup, et que la preuve est valide, le contrat de rollup prend la racine post-état de la preuve et met à jour son arbre d'état pour refléter l'état modifié du rollup.
 
@@ -164,11 +164,11 @@ Retirer depuis un rollup ZK vers la L1 est simple. L'utilisateur initie la trans
 
 Le contrat de rollup hache les données de la transaction, vérifie si la racine du lot existe, et utilise la preuve de Merkle pour vérifier si le hachage de la transaction fait partie de la racine du lot. Ensuite, le contrat exécute la transaction de sortie et envoie les fonds à l'adresse choisie par l'utilisateur sur L1.
 
-## Les rollups ZK et la compatibilité avec la Machine Virtuelle Ethereum (EVM) {#zk-rollups-and-evm-compatibility}
+## Rollups ZK et compatibilité EVM {#zk-rollups-and-evm-compatibility}
 
-Contrairement aux rollups optimistes, les rollups ZK ne sont pas facilement compatibles avec la [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Prouver le calcul EVM général dans les circuits est plus difficile et nécessite plus de ressources que de prouver des calculs simples (comme le transfert de jetons décrit précédemment).
+Contrairement aux rollups optimistes, les rollups ZK ne sont pas directement compatibles avec la [machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Prouver le calcul EVM général dans les circuits est plus difficile et nécessite plus de ressources que de prouver des calculs simples (comme le transfert de jetons décrit précédemment).
 
-Cependant, [les progrès de la technologie de la connaissance zéro](https://hackmd.io/@yezhang/S1_KMMbGt#Why-possible-now) suscitent un regain d'intérêt pour envelopper le calcul EVM dans des preuves de connaissance zéro. Ces efforts visent à créer une mise en œuvre de l'EVM à connaissance nulle (zkEVM) qui peut vérifier efficacement l'exactitude de l'exécution d'un programme. Un zkEVM recrée les codes d'opérations EVM existants pour les prouver/vérifier dans les circuits, ce qui permet d'exécuter des contrats intelligents.
+Cependant, les [progrès de la technologie à divulgation nulle de connaissance](https://hackmd.io/@yezhang/S1_KMMbGt#Why-possible-now) suscitent un regain d'intérêt pour l'encapsulation du calcul EVM dans des preuves à divulgation nulle de connaissance. Ces efforts visent à créer une mise en œuvre de l'EVM à connaissance nulle (zkEVM) qui peut vérifier efficacement l'exactitude de l'exécution d'un programme. Un zkEVM recrée les codes d'opérations EVM existants pour les prouver/vérifier dans les circuits, ce qui permet d'exécuter des contrats intelligents.
 
 Comme l'EVM, un zkEVM passe d'un état à l'autre après avoir effectué un calcul sur certaines entrées. La différence est que le zkEVM crée également des preuves de connaissance zéro pour vérifier l'exactitude de chaque étape de l'exécution du programme. Les preuves de validité pourraient vérifier l'exactitude des opérations qui touchent l'état de la VM (mémoire, pile, stockage) et le calcul lui-même (c'est-à-dire que l'opération a appelé les bons codes d'opérations et les a exécutés correctement).
 
@@ -178,21 +178,21 @@ L'introduction des rollups ZK compatibles avec l'EVM devrait aider les développ
 
 Le montant que les utilisateurs paient pour les transactions sur les rollups ZK dépend des frais de gaz, tout comme sur le réseau principal Ethereum. Cependant, les frais de gaz fonctionnent différemment sur les couches de second niveau et sont influencés par les coûts suivants :
 
-1. **Écriture d'état** : Il y a un coût fixe pour écrire dans l'état d'Ethereum (c'est-à-dire, soumettre une transaction sur la blockchain d'Ethereum). Les rollups ZK réduisent ce coût en regroupant les transactions et en répartissant les coûts fixes entre plusieurs utilisateurs.
+1. **Écriture d'état** : Il y a un coût fixe pour écrire dans l'état d'Ethereum (c.-à-d. soumettre une transaction sur la blockchain Ethereum). Les rollups ZK réduisent ce coût en regroupant les transactions et en répartissant les coûts fixes entre plusieurs utilisateurs.
 
-2. **Data publication** : Les rollups ZK publient les données d'état de chaque transaction vers Ethereum en tant que `calldata`. Les coûts des `calldata` sont actuellement régis par le [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), qui prévoit un coût de 16 gaz pour les octets non nuls et de 4 gaz pour les octets nuls de `calldata`, respectivement. Le coût payé pour chaque transaction dépend de la quantité de `calldata` qui doit être publiée sur la chaîne à cet effet.
+2. **Publication des données** : Les rollups ZK publient les données d'état pour chaque transaction sur Ethereum en tant que `calldata`. Les coûts des `calldata` sont actuellement régis par l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), qui stipule un coût de 16 unités de gaz pour les octets non nuls et de 4 unités de gaz pour les octets nuls de `calldata`, respectivement. Le coût payé pour chaque transaction est influencé par la quantité de `calldata` qui doit être publiée en chaîne for celle-ci.
 
-3. **Frais d'opérateur L2**: Il s'agit du montant payé à l'opérateur du rollup en compensation des coûts de calcul engagés lors du traitement des transactions, un peu comme les [ frais de transaction prioritaire (pourboires)"](/developers/docs/gas/#how-are-gas-fees-calculated) sur le réseau principal d'Ethereum.
+3. **Frais d'opérateur de couche 2** : Il s'agit du montant payé à l'opérateur du rollup en compensation des coûts de calcul engagés lors du traitement des transactions, tout comme les [frais de transaction « prioritaires (pourboires) »](/developers/docs/gas/#how-are-gas-fees-calculated) sur le réseau principal Ethereum.
 
 4. **Génération et vérification des preuves** : Les opérateurs de rollup ZK doivent produire des preuves de validité pour les lots de transactions, ce qui est gourmand en ressources. La vérification des preuves à connaissance zéro sur le réseau principal coûte également du gaz (~ 500 000 gaz).
 
-En plus des transactions par lots, les rollups ZK réduisent les frais des utilisateurs en compressant les données de transaction. Vous pouvez [voir un aperçu en temps réel](https://l2fees.info/) du coût d'utilisation des rollups ZK Ethereum.
+En plus des transactions par lots, les rollups ZK réduisent les frais des utilisateurs en compressant les données de transaction. Vous pouvez [voir un aperçu en temps réel](https://l2fees.info/) du coût d'utilisation des rollups ZK d'Ethereum.
 
 ## Comment les rollups ZK font-ils évoluer Ethereum ? {#scaling-ethereum-with-zk-rollups}
 
 ### Compression des données de transaction {#transaction-data-compression}
 
-Les rollups ZK augmentent le débit de la couche de base d'Ethereum en transférant les calculs hors chaîne, mais le véritable coup de pouce pour la mise à l'échelle provient de la compression des données de transaction. La [taille des blocs](/developers/docs/blocks/#block-size) d'Ethereum limite les données que chaque bloc peut contenir et, par extension, le nombre de transactions traitées par bloc. En compressant les données liées aux transactions, les rollups ZK augmentent considérablement le nombre de transactions traitées par bloc.
+Les rollups ZK augmentent le débit de la couche de base d'Ethereum en transférant les calculs hors chaîne, mais le véritable coup de pouce pour la mise à l'échelle provient de la compression des données de transaction. La [taille de bloc](/developers/docs/blocks/#block-size) d'Ethereum limite la quantité de données que chaque bloc peut contenir et, par extension, le nombre de transactions traitées par bloc. En compressant les données liées aux transactions, les rollups ZK augmentent considérablement le nombre de transactions traitées par bloc.
 
 Les rollups ZK peuvent mieux comprimer les données de transaction que les rollups optimistes puisqu'ils n'ont pas besoin d'enregistrer toutes les données nécessaires pour valider chaque transaction. Ils ne doivent comptabiliser que les données minimales requises pour reconstruire le dernier état des comptes et des soldes sur le rollup.
 
@@ -206,51 +206,52 @@ Les preuves récursives, cependant, permettent de finaliser plusieurs blocs avec
 
 ### Avantages et inconvénients des rollups ZK {#zk-rollups-pros-and-cons}
 
-| Avantages                                                                                                                                                                                                                          | Inconvénients                                                                                                                                                                                                                   |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Les preuves de validité garantissent l'exactitude des transactions hors chaîne et empêchent les opérateurs d'exécuter des transitions d'état invalides.                                                                            | Le coût associé au calcul et à la vérification des preuves de validité est substantiel et peut augmenter les frais pour les utilisateurs de rollup.                                                                             |
-| Offre une finalité de transaction plus rapide car les mises à jour d'état sont approuvées une fois que les preuves de validité sont vérifiées sur L1.                                                                              | La construction de rollups ZK compatibles avec l'EVM est difficile en raison de la complexité de la technologie de la connaissance zéro.                                                                                        |
-| S'appuie sur des mécanismes cryptographiques sans confiance pour la sécurité, et non sur l'honnêteté d'acteurs incités comme avec [les rollups optimistes](/developers/docs/scaling/optimistic-rollups/#optimistic-pros-and-cons). | La production de preuves de validité nécessite un matériel spécialisé, ce qui pourrait générer une centralisation de la chaîne aux mains de quelques acteurs.                                                                   |
-| Stocke les données nécessaires pour récupérer l'état hors chaîne sur la couche 1, ce qui garantit la sécurité, la résistance à la censure et la décentralisation.                                                                  | Les opérateurs centralisés (séquenceurs) peuvent influencer l'ordre des transactions.                                                                                                                                           |
-| Les utilisateurs bénéficient d'une plus grande efficacité du capital et peuvent retirer des fonds de L2 sans délai.                                                                                                                | Les exigences matérielles peuvent réduire le nombre de participants qui peuvent forcer la chaîne à progresser, ce qui augmente le risque que des opérateurs malveillants gèlent l'état du rollup et censurent les utilisateurs. |
-| Ne dépend pas des hypothèses de vivacité et les utilisateurs n'ont pas à valider la chaîne pour protéger leurs fonds.                                                                                                              | Certains systèmes de preuve (par exemple, ZK-SNARK) nécessitent une installation de confiance qui, si elle est mal gérée, pourrait potentiellement compromettre le modèle de sécurité d'un rollup ZK.                           |
-| Une meilleure compression des données peut contribuer à réduire les coûts de publication des `calldata` sur Ethereum et à minimiser les frais de rollup pour les utilisateurs.                                                     |                                                                                                                                                                                                                                 |
+| Avantages                                                                                                                                                                                                                                        | Inconvénients                                                                                                                                                                                                                                   |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Les preuves de validité garantissent l'exactitude des transactions hors chaîne et empêchent les opérateurs d'exécuter des transitions d'état invalides.                                                                          | Le coût associé au calcul et à la vérification des preuves de validité est substantiel et peut augmenter les frais pour les utilisateurs de rollup.                                                                             |
+| Offre une finalité de transaction plus rapide car les mises à jour d'état sont approuvées une fois que les preuves de validité sont vérifiées sur L1.                                                                            | La construction de rollups ZK compatibles avec l'EVM est difficile en raison de la complexité de la technologie de la connaissance zéro.                                                                                        |
+| Repose sur des mécanismes cryptographiques sans confiance pour la sécurité, et non sur l'honnêteté d'acteurs incités comme avec les [rollups optimistes](/developers/docs/scaling/optimistic-rollups/#optimistic-pros-and-cons). | La production de preuves de validité nécessite un matériel spécialisé, ce qui pourrait générer une centralisation de la chaîne aux mains de quelques acteurs.                                                                   |
+| Stocke les données nécessaires pour récupérer l'état hors chaîne sur la couche 1, ce qui garantit la sécurité, la résistance à la censure et la décentralisation.                                                                | Les opérateurs centralisés (séquenceurs) peuvent influencer l'ordre des transactions.                                                                                                                        |
+| Les utilisateurs bénéficient d'une plus grande efficacité du capital et peuvent retirer des fonds de L2 sans délai.                                                                                                              | Les exigences matérielles peuvent réduire le nombre de participants qui peuvent forcer la chaîne à progresser, ce qui augmente le risque que des opérateurs malveillants gèlent l'état du rollup et censurent les utilisateurs. |
+| Ne dépend pas des hypothèses de vivacité et les utilisateurs n'ont pas à valider la chaîne pour protéger leurs fonds.                                                                                                            | Certains systèmes de preuve (par exemple, ZK-SNARK) nécessitent une installation de confiance qui, si elle est mal gérée, pourrait potentiellement compromettre le modèle de sécurité d'un rollup ZK.        |
+| Une meilleure compression des données peut aider à réduire les coûts de publication des `calldata` sur Ethereum et à minimiser les frais de rollup pour les utilisateurs.                                                        |                                                                                                                                                                                                                                                 |
 
-### Les rollups ZK en images {#zk-video}
+### Une explication visuelle des rollups ZK {#zk-video}
 
 Regardez la vidéo de Finematics qui explique les rollups ZK :
 
 <YouTube id="7pWxCklcNsU" start="406" />
 
-
-## Qui travaille sur une zkEVM ? {#zkevm-projects}
+## Qui travaille sur une zkEVM ? Projets zkEVM {#zkevm-projects}
 
 Les projets fonctionnant sur les zkEVM comprennent :
 
-- **[zkEVM](https://github.com/privacy-scaling-explorations/zkevm-specs)** - _zkEVM est un projet financé par la Fondation Ethereum pour développer un ZK-rollup compatible EVM et un mécanisme destiné à générer des preuves de validité pour les blocs Ethereum._
+- **[zkEVM](https://github.com/privacy-scaling-explorations/zkevm-specs)** - _zkEVM est un projet financé par la Fondation Ethereum pour développer un rollup ZK compatible avec l'EVM et un mécanisme pour générer des preuves de validité pour les blocs Ethereum._
+
+- **[Polygon zkEVM](https://polygon.technology/solutions/polygon-zkevm)** - _est un rollup ZK décentralisé sur le réseau principal Ethereum fonctionnant sur une machine virtuelle Ethereum à divulgation nulle de connaissance (zkEVM) qui exécute les transactions Ethereum de manière transparente, y compris les contrats intelligents avec des validations par preuve à divulgation nulle de connaissance._
 
-- **[Polygon Hermez](https://polygon.technology/solutions/polygon-zkevm)** - _Hermez est un rollup ZK décentralisé sur le réseau principal Ethereum travaillant sur une machine virtuelle Ethereum à connaissance nulle (zkEVM) qui exécute les transactions Ethereum de manière transparente, y compris les contrats intelligents avec des validations de preuve à connaissance nulle._
+- **[Scroll](https://scroll.io/blog/zkEVM)** - _Scroll est une entreprise axée sur la technologie qui travaille à la création d'une solution native zkEVM de couche 2 pour Ethereum._
 
-- **[Scroll](https://scroll.io/blog/zkEVM)** - _Scroll est une entreprise axée sur la technologie travaillant à la création d'une solution native zkEVM de couche 2 pour Ethereum._
+- **[Taiko](https://taiko.xyz)** - _Taiko est un rollup ZK décentralisé, équivalent à Ethereum (un [ZK-EVM de type 1](https://vitalik.eth.limo/general/2022/08/04/zkevm.html))._
 
-- **[Taiko](https://taiko.xyz)** - _Taiko est un ZK-rollup décentralisé, équivalent à Ethereum (un [Type 1 ZK-EVM](https://vitalik.eth.limo/general/2022/08/04/zkevm.html))._
+- **[ZKsync](https://docs.zksync.io/)** - _ZKsync Era est un rollup ZK compatible EVM construit par Matter Labs, propulsé par son propre zkEVM._
 
-- **[ZKsync](https://docs.zksync.io/)** - _Zksync Era est un ZK rollup compatible avec l'EVM développé par Matter Labs, propulsé par son propre zkEVM._
+- **[Starknet](https://starkware.co/starknet/)** - _StarkNet est une solution de mise à l'échelle de couche 2 compatible EVM, conçue par StarkWare._
 
-- **[Starknet](https://starkware.co/starknet/)** - _StarkNet est une solution de mise à l'échelle de la couche 2 compatible avec l'EVM, conçue par StarkWare._
+- **[Morph](https://www.morphl2.io/)** - _Morph est une solution de mise à l'échelle de rollup hybride qui utilise la preuve ZK pour résoudre le problème de contestation de l'état de la couche 2._
 
-- **[Morph](https://www.morphl2.io/)** - _Morph est une solution hybride de mise à l'échelle des rollups qui utilise la preuve zk pour résoudre le problème de l'état de la couche 2._
+- **[Linea](https://linea.build)** - _Linea est un ZK-EVM de couche 2 équivalent à Ethereum, conçu par Consensys et entièrement aligné avec l'écosystème Ethereum._
 
-## Lecture supplémentaire sur les rollups ZK {#further-reading-on-zk-rollups}
+## Lectures complémentaires sur les rollups ZK {#further-reading-on-zk-rollups}
 
-- [Qu'est-ce que les Rollups Zero Knowledge ?](https://coinmarketcap.com/alexandria/glossary/zero-knowledge-rollups)
-- [Qu'est-ce que les rollups zero-knowledge ?](https://alchemy.com/blog/zero-knowledge-rollups)
-- [Guide pratique des rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
+- [Que sont les rollups à divulgation nulle de connaissance ?](https://coinmarketcap.com/alexandria/glossary/zero-knowledge-rollups)
+- [Que sont les rollups à divulgation nulle de connaissance ?](https://alchemy.com/blog/zero-knowledge-rollups)
+- [Le guide pratique des rollups Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
 - [STARKs vs SNARKs](https://consensys.net/blog/blockchain-explained/zero-knowledge-proofs-starks-vs-snarks/)
 - [Qu'est-ce qu'un zkEVM ?](https://www.alchemy.com/overviews/zkevm)
-- [Types de ZK-EVM : Équivalent Ethereum, équivalent EVM, Type 1, Type 4, et autres termes tendance en crypto](https://taiko.mirror.xyz/j6KgY8zbGTlTnHRFGW6ZLVPuT0IV0_KmgowgStpA0K4)
-- [Introduction au zkEVM](https://hackmd.io/@yezhang/S1_KMMbGt)
-- [Que sont les secondes couches ZK-EVM ?](https://linea.mirror.xyz/qD18IaQ4BROn_Y40EBMTUTdJHYghUtdECscSWyMvm8M)
-- [Ressources géniales pour zkEVM](https://github.com/LuozhuZhang/awesome-zkevm)
-- [Les dessous de ZK-SNARKS](https://vitalik.eth.limo/general/2017/02/01/zk_snarks.html)
-- [Comment les SNARK sont-ils possibles ?](https://vitalik.eth.limo/general/2021/01/26/snarks.html)
+- [Types de ZK-EVM : Équivalent à Ethereum, équivalent à l'EVM, Type 1, Type 4 et autres mots à la mode cryptiques](https://taiko.mirror.xyz/j6KgY8zbGTlTnHRFGW6ZLVPuT0IV0_KmgowgStpA0K4)
+- [Intro au zkEVM](https://hackmd.io/@yezhang/S1_KMMbGt)
+- [Que sont les ZK-EVM de couche 2 ?](https://linea.mirror.xyz/qD18IaQ4BROn_Y40EBMTUTdJHYghUtdECscSWyMvm8M)
+- [Ressources Awesome-zkEVM](https://github.com/LuozhuZhang/awesome-zkevm)
+- [Les ZK-SNARKS sous le capot](https://vitalik.eth.limo/general/2017/02/01/zk_snarks.html)
+- [Comment les SNARKs sont-ils possibles ?](https://vitalik.eth.limo/general/2021/01/26/snarks.html)
diff --git a/public/content/translations/fr/developers/docs/security/index.md b/public/content/translations/fr/developers/docs/security/index.md
index b1507a57ed5..0c590878d9e 100644
--- a/public/content/translations/fr/developers/docs/security/index.md
+++ b/public/content/translations/fr/developers/docs/security/index.md
@@ -1,6 +1,6 @@
 ---
-title: Sécurité
-description: Considérations de sécurité pour les développeurs Ethereum
+title: "Sécurité"
+description: "Considérations de sécurité pour les développeurs Ethereum"
 lang: fr
 ---
 
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md b/public/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md
index 0369da7db4d..887d23559b6 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md
@@ -1,6 +1,6 @@
 ---
 title: Anatomie des contrats intelligents
-description: 'Examen approfondi des composantes d''un contrat intelligent : les fonctions, les données et les variables.'
+description: "Examen approfondi des composantes d'un contrat intelligent : les fonctions, les données et les variables."
 lang: fr
 ---
 
@@ -8,20 +8,20 @@ Les contrats intelligents sont des programmes qui s'exécutent à une adresse su
 
 ## Prérequis {#prerequisites}
 
-Assurez-vous de commencer par lire la page [Contrats intelligents](/developers/docs/smart-contracts/). Ce document part du principe que vous êtes déjà familiarisé avec des langages de programmation comme JavaScript ou Python.
+Assurez-vous d'avoir d'abord lu la page sur les [contrats intelligents](/developers/docs/smart-contracts/). Ce document part du principe que vous êtes déjà familiarisé avec des langages de programmation comme JavaScript ou Python.
 
 ## Données {#data}
 
-Toute donnée relative à un contrat doit être affectée à un emplacement : soit `storage` soit `memory`. Il est coûteux de modifier le stockage dans un contrat intelligent. Vous devez donc décider de l'endroit où vous souhaitez conserver vos données.
+Toute donnée de contrat doit être affectée à un emplacement : soit `storage`, soit `memory`. Il est coûteux de modifier le stockage dans un contrat intelligent. Vous devez donc décider de l'endroit où vous souhaitez conserver vos données.
 
 ### Stockage {#storage}
 
 Les données persistantes sont appelées stockage et sont représentées par des variables d'état. Ces valeurs sont stockées en permanence sur la blockchain. Vous devez déclarer le type afin que le contrat puisse garder une trace de la quantité de stockage nécessaire sur la blockchain quand il compile.
 
 ```solidity
-// Solidity example
+// Exemple Solidity
 contract SimpleStorage {
-    uint storedData; // State variable
+    uint storedData; // Variable d'état
     // ...
 }
 ```
@@ -31,9 +31,9 @@ contract SimpleStorage {
 storedData: int128
 ```
 
-Si vous avez déjà programmé des langages orientés objet, vous serez probablement familiarisé avec la plupart des types. Cependant, le type `address` devrait être nouveau pour vous si vous commencez à développer pour Ethereum.
+Si vous avez déjà programmé des langages orientés objet, vous serez probablement familiarisé avec la plupart des types. Cependant, `address` devrait être nouveau pour vous si vous débutez dans le développement Ethereum.
 
-Un type `address ` peut contenir une adresse Ethereum qui équivaut à 20 octets ou 160 bits, ce qui donne une adresse en notation hexadécimale commençant par 0x.
+Un type `address` peut contenir une adresse Ethereum qui équivaut à 20 octets ou 160 bits. ce qui donne une adresse en notation hexadécimale commençant par 0x.
 
 Les autres types incluent les :
 
@@ -41,22 +41,22 @@ Les autres types incluent les :
 - nombres entiers ;
 - numéros de points fixes ;
 - tableaux d'octets de taille fixe ;
-- tableaux d'octets de taille dynamique ;
-- littéraux rationnels et entiers ;
-- littéraux de chaîne ;
-- nombres hexadécimaux ;
-- énumérations.
+- tableaux d'octets de taille dynamique
+- littéraux rationnels et entiers
+- littéraux de chaîne
+- littéraux hexadécimaux
+- énumérations
 
 Pour plus d'explications, consultez les pages ci-dessous :
 
-- [Types Vyper](https://vyper.readthedocs.io/en/v0.1.0-beta.6/types.html#value-types)
-- [Types Solidity](https://solidity.readthedocs.io/en/latest/types.html#value-types)
+- [Voir les types Vyper](https://docs.vyperlang.org/en/v0.1.0-beta.6/types.html#value-types)
+- [Voir les types Solidity](https://docs.soliditylang.org/en/latest/types.html#value-types)
 
 ### Mémoire {#memory}
 
 Les valeurs qui ne sont stockées que pendant la durée de l'exécution d'une fonction de contrat sont appelées variables de mémoire. Celles-ci n'étant pas stockées de façon permanente sur la blockchain, elles sont donc moins chères à utiliser.
 
-Pour en savoir plus sur la façon dont l'EVM conserve les données (stockage, mémoire et pile) consultez la documentation [Solidity](https://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html?highlight=memory#storage-memory-and-the-stack).
+Apprenez-en davantage sur la façon dont l'EVM stocke les données (le stockage, la mémoire et la pile) dans la [documentation de Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#storage-memory-and-the-stack).
 
 ### Variables d'environnement {#environment-variables}
 
@@ -64,10 +64,10 @@ En plus des variables que vous définissez sur votre contrat, il existent quelqu
 
 Exemples :
 
-| **Propriété**     | **Variable d'état** | **Description**                         |
-| ----------------- | ------------------- | --------------------------------------- |
-| `block.timestamp` | uint256             | Horodatage de la période du bloc actuel |
-| `msg.sender`      | address             | Expéditeur du message (appel en cours)  |
+| **Propriété**     | **Variable d'état** | **Description**                                           |
+| ----------------- | ------------------- | --------------------------------------------------------- |
+| `block.timestamp` | uint256             | Horodatage de la période du bloc actuel                   |
+| `msg.sender`      | Adresse             | Expéditeur du message (appel en cours) |
 
 ## Fonctions {#functions}
 
@@ -75,14 +75,14 @@ En termes simples, les fonctions peuvent obtenir ou définir des informations en
 
 Il existe deux types d'appels de fonctions :
 
-- `internal` - Ces fonctions ne créent pas d'appel EVM
-  - Les fonctions internes et les variables d'état ne peuvent être accédées qu'en interne (c'est-à-dire à partir du contrat actuel ou des contrats qui en découlent)
-- `external` - Ces fonctions créent un appel EVM
-  - Les fonctions externes font partie de l'interface du contrat, ce qui signifie qu'elles peuvent être appelées à partir d'autres contrats et via des transactions. Une fonction externe `f` ne peut pas être appelée en interne (par ex., `f()` ne fonctionne pas, mais `this.f()` fonctionne).
+- `internal` – celles-ci ne créent pas d'appel EVM
+  - Les fonctions internes et les variables d'état ne sont accessibles qu'en interne (c'est-à-dire depuis le contrat actuel ou les contrats qui en dérivent)
+- `external` – celles-ci créent un appel EVM
+  - Les fonctions externes font partie de l'interface du contrat, ce qui signifie qu'elles peuvent être appelées à partir d'autres contrats et via des transactions. Une fonction externe `f` ne peut pas être appelée en interne (c.-à-d. que `f()` ne fonctionne pas, mais `this.f()` fonctionne).
 
-Elles peuvent également être de type `public` ou `private`
+Elles peuvent également être `public` ou `private`
 
-- Les fonctions `public` peuvent être appelées en interne à l'intérieur du contrat ou à l'extérieur via des messages
+- Les fonctions `public` peuvent être appelées en interne depuis le contrat ou en externe via des messages
 - Les fonctions `private` ne sont visibles que pour le contrat dans lequel elles sont définies et non dans les contrats dérivés
 
 Les fonctions et les variables d'état peuvent être rendues publiques ou privées
@@ -96,11 +96,11 @@ function update_name(string value) public {
 }
 ```
 
-- Le paramètre `value` de type `string` est passé dans la fonction : `update_name`.
-- Il est déclaré `public`, ce qui signifie que n'importe qui peut y accéder.
-- Il n'est pas déclaré comme `view`, il peut donc modifier l'état du contrat
+- Le paramètre `value` de type `string` est passé dans la fonction : `update_name`
+- Elle est déclarée `public`, ce qui signifie que n'importe qui peut y accéder
+- Elle n'est pas déclarée `view`, elle peut donc modifier l'état du contrat
 
-### Voir les fonctions {#view-functions}
+### Fonctions View {#view-functions}
 
 Ces fonctions promettent de ne pas modifier l’état des données du contrat. Les exemples courants sont les fonctions « getter » - vous pouvez utiliser ceci pour obtenir le solde d'un utilisateur par exemple.
 
@@ -123,27 +123,27 @@ def readName() -> string:
 Voici ce qui est considéré comme une modification d'état :
 
 1. Écriture dans les variables d'état
-2. [Émission d'événements](https://solidity.readthedocs.io/en/v0.7.0/contracts.html#events)
-3. [Création d'autres contrats](https://solidity.readthedocs.io/en/v0.7.0/control-structures.html#creating-contracts)
-4. Utilisation d'`autodestruct`
+2. [Émettre des événements](https://docs.soliditylang.org/en/v0.7.0/contracts.html#events).
+3. [Créer d'autres contrats](https://docs.soliditylang.org/en/v0.7.0/control-structures.html#creating-contracts).
+4. Utiliser `selfdestruct`.
 5. Envoi d'ether via des appels
-6. Appel d'une fonction non marquée `view` ni `pure`
+6. Appeler toute fonction non marquée `view` ou `pure`.
 7. Utilisation d'appels de bas niveau
 8. Utilisation d'un assemblage en ligne conteant certains opcodes
 
-### Fonctions du constructeur {#constructor-functions}
+### Fonctions constructeur {#constructor-functions}
 
-Les fonctions `constructor` ne sont exécutées qu'une seule fois lors du premier déploiement du contrat. Comme `constructor` dans de nombreux langages de programmation basés sur des classes, ces fonctions initialisent souvent les variables d'état à leurs valeurs spécifiées.
+Les fonctions `constructor` ne sont exécutées qu'une seule fois lors du premier déploiement du contrat. Comme le `constructor` dans de nombreux langages de programmation orientés objet, ces fonctions initialisent souvent les variables d'état à leurs valeurs spécifiées.
 
 ```solidity
-// Solidity example
-// Initializes the contract's data, setting the `owner`
-// to the address of the contract creator.
+// Exemple Solidity
+// Initialise les données du contrat, en définissant l'`owner`
+// sur l'adresse du créateur du contrat.
 constructor() public {
-    // All smart contracts rely on external transactions to trigger its functions.
-    // `msg` is a global variable that includes relevant data on the given transaction,
-    // such as the address of the sender and the ETH value included in the transaction.
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
+    // Tous les contrats intelligents s'appuient sur des transactions externes pour déclencher leurs fonctions.
+    // `msg` est une variable globale qui inclut des données pertinentes sur la transaction donnée,
+    // comme l'adresse de l'expéditeur et la valeur en ETH incluse dans la transaction.
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
     owner = msg.sender;
 }
 ```
@@ -162,12 +162,12 @@ def __init__(_beneficiary: address, _bidding_time: uint256):
 
 En plus des variables et des fonctions que vous définissez pour votre contrat, il existe des fonctions spéciales intégrées. Exemple le plus évident :
 
-- `address.send()` - Solidity
-- `send(address)` - Vyper
+- `address.send()` – Solidity
+- `send(address)` – Vyper
 
 Celles-ci permettent aux contrats d’envoyer des ETH à d’autres comptes.
 
-## Fonctions d'écriture {#writing-functions}
+## Écrire des fonctions {#writing-functions}
 
 Votre fonction a besoin des éléments suivants :
 
@@ -180,26 +180,26 @@ Votre fonction a besoin des éléments suivants :
 pragma solidity >=0.4.0 <=0.6.0;
 
 contract ExampleDapp {
-    string dapp_name; // state variable
+    string dapp_name; // variable d'état
 
-    // Called when the contract is deployed and initializes the value
+    // Appelé lorsque le contrat est déployé et initialise la valeur
     constructor() public {
-        dapp_name = "My Example dapp";
+        dapp_name = "Ma dapp d'exemple";
     }
 
-    // Get Function
+    // Fonction Get
     function read_name() public view returns(string) {
         return dapp_name;
     }
 
-    // Set Function
+    // Fonction Set
     function update_name(string value) public {
         dapp_name = value;
     }
 }
 ```
 
-Un contrat complet pourrait ressembler à cela. Ici la fonction `constructor` fournit une valeur initiale pour la variable `dapp_name`.
+Un contrat complet pourrait ressembler à cela. Ici, la fonction `constructor` fournit une valeur initiale pour la variable `dapp_name`.
 
 ## Événements et journaux {#events-and-logs}
 
@@ -207,38 +207,39 @@ Les événements permettent à votre contrat intelligent de communiquer avec vot
 
 ## Exemples annotés {#annotated-examples}
 
-Voici quelques exemples rédigés en Solidity. Si vous souhaitez jouer avec le code, vous pouvez interagir avec dans [Remix](http://remix.ethereum.org).
+Voici quelques exemples rédigés en Solidity. Si vous souhaitez vous amuser avec le code, vous pouvez interagir avec celui-ci dans [Remix](http://remix.ethereum.org).
 
 ### Hello world {#hello-world}
 
 ```solidity
-// Specifies the version of Solidity, using semantic versioning.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// Spécifie la version de Solidity, en utilisant le versionnage sémantique.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
 pragma solidity ^0.5.10;
 
-// Defines a contract named `HelloWorld`.
-// A contract is a collection of functions and data (its state).
-// Once deployed, a contract resides at a specific address on the Ethereum blockchain.
-    // Declares a state variable `message` of type `string`.
-    // State variables are variables whose values are permanently stored in contract storage.
-    // The keyword `public` makes variables accessible from outside a contract
-    // and creates a function that other contracts or clients can call to access the value.
-    string public message;
+// Définit un contrat nommé `HelloWorld`.
+// Un contrat est une collection de fonctions et de données (son état).
+// Une fois déployé, un contrat réside à une adresse spécifique sur la blockchain Ethereum.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+contract HelloWorld {
 
-    // Similar to many class-based object-oriented languages, a constructor is
-    // a special function that is only executed upon contract creation.
+    // Déclare une variable d'état `message` de type `string`.
+    // Les variables d'état sont des variables dont les valeurs sont stockées en permanence dans le stockage du contrat.
+    // Le mot-clé `public` rend les variables accessibles depuis l'extérieur d'un contrat
+    // et crée une fonction que d'autres contrats ou clients peuvent appeler pour accéder à la valeur.
+    string public message;
 
-    // Constructors are used to initialize the contract's data.
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+    // Similaire à de nombreux langages orientés objet basés sur des classes, un constructeur est
+    // une fonction spéciale qui n'est exécutée que lors de la création du contrat.
+    // Les constructeurs sont utilisés pour initialiser les données du contrat.
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
     constructor(string memory initMessage) public {
-        // Accepts a string argument `initMessage` and sets the value
-        // into the contract's `message` storage variable).
-
+        // Accepte un argument de chaîne `initMessage` et définit la valeur
+        // dans la variable de stockage `message` du contrat.
         message = initMessage;
     }
 
-    // A public function that accepts a string argument
-    // and updates the `message` storage variable.
+    // Une fonction publique qui accepte un argument de chaîne
+    // et met à jour la variable de stockage `message`.
     function update(string memory newMessage) public {
         message = newMessage;
     }
@@ -251,59 +252,58 @@ pragma solidity ^0.5.10;
 pragma solidity ^0.5.10;
 
 contract Token {
-    // An `address` is comparable to an email address - it's used to identify an account on Ethereum.
-    // Addresses can represent a smart contract or an external (user) accounts.
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/types.html#address
+    // Un `address` est comparable à une adresse e-mail - il est utilisé pour identifier un compte sur Ethereum.
+    // Les adresses peuvent représenter un contrat intelligent ou des comptes externes (utilisateur).
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/types.html#address
     address public owner;
 
-    // A `mapping` is essentially a hash table data structure.
-    // This `mapping` assigns an unsigned integer (the token balance) to an address (the token holder).
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/types.html#mapping-types
+    // Un `mapping` est essentiellement une structure de données de table de hachage.
+    // Ce `mapping` attribue un entier non signé (le solde de jetons) à une adresse (le détenteur de jetons).
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/types.html#mapping-types
     mapping (address => uint) public balances;
 
-    // Events allow for logging of activity on the blockchain.
-    // Ethereum clients can listen for events in order to react to contract state changes.
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#events
+    // Les événements permettent de journaliser l'activité sur la blockchain.
+    // Les clients Ethereum peuvent écouter les événements afin de réagir aux changements d'état du contrat.
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#events
     event Transfer(address from, address to, uint amount);
 
-    // Initializes the contract's data, setting the `owner`
-    // to the address of the contract creator.
+    // Initialise les données du contrat, en définissant l'`owner`
+    // sur l'adresse du créateur du contrat.
     constructor() public {
-        // All smart contracts rely on external transactions to trigger its functions.
-
-        // `msg` is a global variable that includes relevant data on the given transaction,
-        // such as the address of the sender and the ETH value included in the transaction.
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
+        // Tous les contrats intelligents s'appuient sur des transactions externes pour déclencher leurs fonctions.
+        // `msg` est une variable globale qui inclut des données pertinentes sur la transaction donnée,
+        // comme l'adresse de l'expéditeur et la valeur en ETH incluse dans la transaction.
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
         owner = msg.sender;
     }
 
-    // Creates an amount of new tokens and sends them to an address.
+    // Crée un montant de nouveaux jetons et les envoie à une adresse.
     function mint(address receiver, uint amount) public {
-        // `require` is a control structure used to enforce certain conditions.
-        // If a `require` statement evaluates to `false`, an exception is triggered,
-        // which reverts all changes made to the state during the current call.
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
+        // `require` est une structure de contrôle utilisée pour appliquer certaines conditions.
+        // Si une déclaration `require` est évaluée à `false`, une exception est déclenchée,
+        // qui annule toutes les modifications apportées à l'état au cours de l'appel actuel.
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
 
-        // Only the contract owner can call this function
-        require(msg.sender == owner, "You are not the owner.");
+        // Seul le propriétaire du contrat peut appeler cette fonction
+        require(msg.sender == owner, "Vous n'êtes pas le propriétaire.");
 
-        // Enforces a maximum amount of tokens
-        require(amount < 1e60, "Maximum issuance exceeded");
+        // Applique un montant maximum de jetons
+        require(amount < 1e60, "Émission maximale dépassée");
 
-        // Increases the balance of `receiver` by `amount`
+        // Augmente le solde de `receiver` de `amount`
         balances[receiver] += amount;
     }
 
-    // Sends an amount of existing tokens from any caller to an address.
+    // Envoie un montant de jetons existants de n'importe quel appelant à une adresse.
     function transfer(address receiver, uint amount) public {
-        // The sender must have enough tokens to send
-        require(amount <= balances[msg.sender], "Insufficient balance.");
+        // L'expéditeur doit avoir suffisamment de jetons à envoyer
+        require(amount <= balances[msg.sender], "Solde insuffisant.");
 
-        // Adjusts token balances of the two addresses
+        // Ajuste les soldes de jetons des deux adresses
         balances[msg.sender] -= amount;
         balances[receiver] += amount;
 
-        // Emits the event defined earlier
+        // Émet l'événement défini plus tôt
         emit Transfer(msg.sender, receiver, amount);
     }
 }
@@ -314,74 +314,74 @@ contract Token {
 ```solidity
 pragma solidity ^0.5.10;
 
-// Imports symbols from other files into the current contract.
-// In this case, a series of helper contracts from OpenZeppelin.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#importing-other-source-files
+// Importe des symboles d'autres fichiers dans le contrat actuel.
+// Dans ce cas, une série de contrats d'aide d'OpenZeppelin.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#importing-other-source-files
 
 import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import "../node_modules/@openzeppelin/contracts/introspection/ERC165.sol";
 import "../node_modules/@openzeppelin/contracts/math/SafeMath.sol";
 
-// The `is` keyword is used to inherit functions and keywords from external contracts.
-// In this case, `CryptoPizza` inherits from the `IERC721` and `ERC165` contracts.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#inheritance
+// Le mot-clé `is` est utilisé pour hériter des fonctions et des mots-clés de contrats externes.
+// Dans ce cas, `CryptoPizza` hérite des contrats `IERC721` et `ERC165`.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#inheritance
 contract CryptoPizza is IERC721, ERC165 {
-    // Uses OpenZeppelin's SafeMath library to perform arithmetic operations safely.
-    // Learn more: https://docs.openzeppelin.com/contracts/2.x/api/math#SafeMath
+    // Utilise la bibliothèque SafeMath d'OpenZeppelin pour effectuer des opérations arithmétiques en toute sécurité.
+    // En savoir plus : https://docs.openzeppelin.com/contracts/2.x/api/math#SafeMath
     using SafeMath for uint256;
 
-    // Constant state variables in Solidity are similar to other languages
-    // but you must assign from an expression which is constant at compile time.
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constant-state-variables
+    // Les variables d'état constantes dans Solidity sont similaires à d'autres langages
+    // mais vous devez les affecter à partir d'une expression qui est constante au moment de la compilation.
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constant-state-variables
     uint256 constant dnaDigits = 10;
     uint256 constant dnaModulus = 10 ** dnaDigits;
     bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
 
-    // Struct types let you define your own type
-    // Learn more: https://solidity.readthedocs.io/en/v0.5.10/types.html#structs
+    // Les types struct vous permettent de définir votre propre type
+    // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/types.html#structs
     struct Pizza {
         string name;
         uint256 dna;
     }
 
-    // Creates an empty array of Pizza structs
+    // Crée un tableau vide de structs Pizza
     Pizza[] public pizzas;
 
-    // Mapping from pizza ID to its owner's address
+    // Mappage de l'ID de la pizza à l'adresse de son propriétaire
     mapping(uint256 => address) public pizzaToOwner;
 
-    // Mapping from owner's address to number of owned token
+    // Mappage de l'adresse du propriétaire au nombre de jetons possédés
     mapping(address => uint256) public ownerPizzaCount;
 
-    // Mapping from token ID to approved address
+    // Mappage de l'ID du jeton à l'adresse approuvée
     mapping(uint256 => address) pizzaApprovals;
 
-    // You can nest mappings, this example maps owner to operator approvals
+    // Vous pouvez imbriquer des mappages, cet exemple mappe le propriétaire aux approbations de l'opérateur
     mapping(address => mapping(address => bool)) private operatorApprovals;
 
-    // Internal function to create a random Pizza from string (name) and DNA
+    // Fonction interne pour créer une Pizza aléatoire à partir d'une chaîne (nom) et d'un ADN
     function _createPizza(string memory _name, uint256 _dna)
-        // The `internal` keyword means this function is only visible
-        // within this contract and contracts that derive this contract
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#visibility-and-getters
+        // Le mot-clé `internal` signifie que cette fonction n'est visible
+        // qu'à l'intérieur de ce contrat et des contrats qui dérivent de ce contrat
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#visibility-and-getters
         internal
-        // `isUnique` is a function modifier that checks if the pizza already exists
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html#function-modifiers
+        // `isUnique` est un modificateur de fonction qui vérifie si la pizza existe déjà
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html#function-modifiers
         isUnique(_name, _dna)
     {
-        // Adds Pizza to array of Pizzas and get id
+        // Ajoute une Pizza au tableau de Pizzas et obtient l'ID
         uint256 id = SafeMath.sub(pizzas.push(Pizza(_name, _dna)), 1);
 
-        // Checks that Pizza owner is the same as current user
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
+        // Vérifie que le propriétaire de la Pizza est le même que l'utilisateur actuel
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
 
-        // note that address(0) is the zero address,
-        // indicating that pizza[id] is not yet allocated to a particular user.
+        // notez que address(0) est l'adresse zéro,
+        // indiquant que pizza[id] n'est pas encore alloué à un utilisateur particulier.
 
         assert(pizzaToOwner[id] == address(0));
 
-        // Maps the Pizza to the owner
+        // Mappe la Pizza au propriétaire
         pizzaToOwner[id] = msg.sender;
         ownerPizzaCount[msg.sender] = SafeMath.add(
             ownerPizzaCount[msg.sender],
@@ -389,38 +389,37 @@ contract CryptoPizza is IERC721, ERC165 {
         );
     }
 
-    // Creates a random Pizza from string (name)
+    // Crée une Pizza aléatoire à partir d'une chaîne (nom)
     function createRandomPizza(string memory _name) public {
         uint256 randDna = generateRandomDna(_name, msg.sender);
         _createPizza(_name, randDna);
     }
 
-    // Generates random DNA from string (name) and address of the owner (creator)
+    // Génère un ADN aléatoire à partir d'une chaîne (nom) et de l'adresse du propriétaire (créateur)
     function generateRandomDna(string memory _str, address _owner)
         public
-        // Functions marked as `pure` promise not to read from or modify the state
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#pure-functions
+        // Les fonctions marquées comme `pure` promettent de ne pas lire ou modifier l'état
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#pure-functions
         pure
         returns (uint256)
     {
-        // Generates random uint from string (name) + address (owner)
+        // Génère un uint aléatoire à partir d'une chaîne (nom) + adresse (propriétaire)
         uint256 rand = uint256(keccak256(abi.encodePacked(_str))) +
             uint256(_owner);
         rand = rand % dnaModulus;
         return rand;
     }
 
-    // Returns array of Pizzas found by owner
+    // Renvoie un tableau des Pizzas trouvées par propriétaire
     function getPizzasByOwner(address _owner)
         public
-        // Functions marked as `view` promise not to modify state
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#view-functions
+        // Les fonctions marquées comme `view` promettent de ne pas modifier l'état
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#view-functions
         view
         returns (uint256[] memory)
     {
-        // Uses the `memory` storage location to store values only for the
-        // lifecycle of this function call.
-        // Learn more: https://solidity.readthedocs.io/en/v0.5.10/introduction-to-smart-contracts.html#storage-memory-and-the-stack
+        // Utilise l'emplacement de stockage `memory` pour stocker des valeurs uniquement pour le cycle de vie de cet appel de fonction.
+        // En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/introduction-to-smart-contracts.html#storage-memory-and-the-stack
         uint256[] memory result = new uint256[](ownerPizzaCount[_owner]);
         uint256 counter = 0;
         for (uint256 i = 0; i < pizzas.length; i++) {
@@ -432,28 +431,28 @@ contract CryptoPizza is IERC721, ERC165 {
         return result;
     }
 
-    // Transfers Pizza and ownership to other address
+    // Transfère la Pizza et la propriété à une autre adresse
     function transferFrom(address _from, address _to, uint256 _pizzaId) public {
-        require(_from != address(0) && _to != address(0), "Invalid address.");
-        require(_exists(_pizzaId), "Pizza does not exist.");
-        require(_from != _to, "Cannot transfer to the same address.");
-        require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved.");
+        require(_from != address(0) && _to != address(0), "Adresse non valide.");
+        require(_exists(_pizzaId), "La pizza n'existe pas.");
+        require(_from != _to, "Impossible de transférer à la même adresse.");
+        require(_isApprovedOrOwner(msg.sender, _pizzaId), "L'adresse n'est pas approuvée.");
 
         ownerPizzaCount[_to] = SafeMath.add(ownerPizzaCount[_to], 1);
         ownerPizzaCount[_from] = SafeMath.sub(ownerPizzaCount[_from], 1);
         pizzaToOwner[_pizzaId] = _to;
 
-        // Emits event defined in the imported IERC721 contract
+        // Émet un événement défini dans le contrat IERC721 importé
         emit Transfer(_from, _to, _pizzaId);
         _clearApproval(_to, _pizzaId);
     }
 
     /**
-     * Safely transfers the ownership of a given token ID to another address
-     * If the target address is a contract, it must implement `onERC721Received`,
-     * which is called upon a safe transfer, and return the magic value
+     * Transfère en toute sécurité la propriété d'un ID de jeton donné à une autre adresse
+     * Si l'adresse cible est un contrat, elle doit implémenter `onERC721Received`,
+     * qui est appelée lors d'un transfert sécurisé, et renvoyer la valeur magique
      * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`;
-     * otherwise, the transfer is reverted.
+     * sinon, le transfert est annulé.
     */
     function safeTransferFrom(address from, address to, uint256 pizzaId)
         public
@@ -463,11 +462,11 @@ contract CryptoPizza is IERC721, ERC165 {
     }
 
     /**
-     * Safely transfers the ownership of a given token ID to another address
-     * If the target address is a contract, it must implement `onERC721Received`,
-     * which is called upon a safe transfer, and return the magic value
+     * Transfère en toute sécurité la propriété d'un ID de jeton donné à une autre adresse
+     * Si l'adresse cible est un contrat, elle doit implémenter `onERC721Received`,
+     * qui est appelée lors d'un transfert sécurisé, et renvoyer la valeur magique
      * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`;
-     * otherwise, the transfer is reverted.
+     * sinon, le transfert est annulé.
      */
     function safeTransferFrom(
         address from,
@@ -476,12 +475,12 @@ contract CryptoPizza is IERC721, ERC165 {
         bytes memory _data
     ) public {
         this.transferFrom(from, to, pizzaId);
-        require(_checkOnERC721Received(from, to, pizzaId, _data), "Must implement onERC721Received.");
+        require(_checkOnERC721Received(from, to, pizzaId, _data), "Doit implémenter onERC721Received.");
     }
 
     /**
-     * Internal function to invoke `onERC721Received` on a target address
-     * The call is not executed if the target address is not a contract
+     * Fonction interne pour invoquer `onERC721Received` sur une adresse cible
+     * L'appel n'est pas exécuté si l'adresse cible n'est pas un contrat
      */
     function _checkOnERC721Received(
         address from,
@@ -502,13 +501,13 @@ contract CryptoPizza is IERC721, ERC165 {
         return (retval == _ERC721_RECEIVED);
     }
 
-    // Burns a Pizza - destroys Token completely
-    // The `external` function modifier means this function is
-    // part of the contract interface and other contracts can call it
+    // Brûle une Pizza - détruit complètement le jeton
+    // Le modificateur de fonction `external` signifie que cette fonction
+    // fait partie de l'interface du contrat et que d'autres contrats peuvent l'appeler
     function burn(uint256 _pizzaId) external {
-        require(msg.sender != address(0), "Invalid address.");
-        require(_exists(_pizzaId), "Pizza does not exist.");
-        require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved.");
+        require(msg.sender != address(0), "Adresse non valide.");
+        require(_exists(_pizzaId), "La pizza n'existe pas.");
+        require(_isApprovedOrOwner(msg.sender, _pizzaId), "L'adresse n'est pas approuvée.");
 
         ownerPizzaCount[msg.sender] = SafeMath.sub(
             ownerPizzaCount[msg.sender],
@@ -517,58 +516,58 @@ contract CryptoPizza is IERC721, ERC165 {
         pizzaToOwner[_pizzaId] = address(0);
     }
 
-    // Returns count of Pizzas by address
+    // Renvoie le nombre de Pizzas par adresse
     function balanceOf(address _owner) public view returns (uint256 _balance) {
         return ownerPizzaCount[_owner];
     }
 
-    // Returns owner of the Pizza found by id
+    // Renvoie le propriétaire de la Pizza trouvé par ID
     function ownerOf(uint256 _pizzaId) public view returns (address _owner) {
         address owner = pizzaToOwner[_pizzaId];
-        require(owner != address(0), "Invalid Pizza ID.");
+        require(owner != address(0), "ID de Pizza non valide.");
         return owner;
     }
 
-    // Approves other address to transfer ownership of Pizza
+    // Approuve une autre adresse pour transférer la propriété de la Pizza
     function approve(address _to, uint256 _pizzaId) public {
-        require(msg.sender == pizzaToOwner[_pizzaId], "Must be the Pizza owner.");
+        require(msg.sender == pizzaToOwner[_pizzaId], "Doit être le propriétaire de la Pizza.");
         pizzaApprovals[_pizzaId] = _to;
         emit Approval(msg.sender, _to, _pizzaId);
     }
 
-    // Returns approved address for specific Pizza
+    // Renvoie l'adresse approuvée pour une Pizza spécifique
     function getApproved(uint256 _pizzaId)
         public
         view
         returns (address operator)
     {
-        require(_exists(_pizzaId), "Pizza does not exist.");
+        require(_exists(_pizzaId), "La pizza n'existe pas.");
         return pizzaApprovals[_pizzaId];
     }
 
     /**
-     * Private function to clear current approval of a given token ID
-     * Reverts if the given address is not indeed the owner of the token
+     * Fonction privée pour effacer l'approbation actuelle d'un ID de jeton donné
+     * Annule si l'adresse donnée n'est pas en effet le propriétaire du jeton
      */
     function _clearApproval(address owner, uint256 _pizzaId) private {
-        require(pizzaToOwner[_pizzaId] == owner, "Must be pizza owner.");
-        require(_exists(_pizzaId), "Pizza does not exist.");
+        require(pizzaToOwner[_pizzaId] == owner, "Doit être le propriétaire de la pizza.");
+        require(_exists(_pizzaId), "La pizza n'existe pas.");
         if (pizzaApprovals[_pizzaId] != address(0)) {
             pizzaApprovals[_pizzaId] = address(0);
         }
     }
 
     /*
-     * Sets or unsets the approval of a given operator
-     * An operator is allowed to transfer all tokens of the sender on their behalf
+     * Définit ou annule l'approbation d'un opérateur donné
+     * Un opérateur est autorisé à transférer tous les jetons de l'expéditeur en leur nom
      */
     function setApprovalForAll(address to, bool approved) public {
-        require(to != msg.sender, "Cannot approve own address");
+        require(to != msg.sender, "Impossible d'approuver sa propre adresse");
         operatorApprovals[msg.sender][to] = approved;
         emit ApprovalForAll(msg.sender, to, approved);
     }
 
-    // Tells whether an operator is approved by a given owner
+    // Indique si un opérateur est approuvé par un propriétaire donné
     function isApprovedForAll(address owner, address operator)
         public
         view
@@ -577,20 +576,20 @@ contract CryptoPizza is IERC721, ERC165 {
         return operatorApprovals[owner][operator];
     }
 
-    // Takes ownership of Pizza - only for approved users
+    // Prend la propriété de la Pizza - uniquement pour les utilisateurs approuvés
     function takeOwnership(uint256 _pizzaId) public {
-        require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved.");
+        require(_isApprovedOrOwner(msg.sender, _pizzaId), "L'adresse n'est pas approuvée.");
         address owner = this.ownerOf(_pizzaId);
         this.transferFrom(owner, msg.sender, _pizzaId);
     }
 
-    // Checks if Pizza exists
+    // Vérifie si la Pizza existe
     function _exists(uint256 pizzaId) internal view returns (bool) {
         address owner = pizzaToOwner[pizzaId];
         return owner != address(0);
     }
 
-    // Checks if address is owner or is approved to transfer Pizza
+    // Vérifie si l'adresse est propriétaire ou est approuvée pour transférer la Pizza
     function _isApprovedOrOwner(address spender, uint256 pizzaId)
         internal
         view
@@ -605,7 +604,7 @@ contract CryptoPizza is IERC721, ERC165 {
             this.isApprovedForAll(owner, spender));
     }
 
-    // Check if Pizza is unique and doesn't exist yet
+    // Vérifie si la Pizza est unique et n'existe pas encore
     modifier isUnique(string memory _name, uint256 _dna) {
         bool result = true;
         for (uint256 i = 0; i < pizzas.length; i++) {
@@ -617,19 +616,19 @@ contract CryptoPizza is IERC721, ERC165 {
                 result = false;
             }
         }
-        require(result, "Pizza with such name already exists.");
+        require(result, "Une pizza avec ce nom existe déjà.");
         _;
     }
 
-    // Returns whether the target address is a contract
+    // Renvoie si l'adresse cible est un contrat
     function isContract(address account) internal view returns (bool) {
         uint256 size;
-        // Currently there is no better way to check if there is a contract in an address
-        // than to check the size of the code at that address.
+        // Actuellement, il n'y a pas de meilleure façon de vérifier s'il y a un contrat à une adresse
+        // que de vérifier la taille du code à cette adresse.
         // Voir https://ethereum.stackexchange.com/a/14016/36603
-        // pour plus de détails sur le fonctionnement.
-        // TODO Vérifiez cela à nouveau avant la version Serenity, car toutes les adresses seront alors contractuelles
-        // .
+        // pour plus de détails sur son fonctionnement.
+        // TODO Vérifier à nouveau avant la sortie de Serenity, car toutes les adresses seront
+        // alors des contrats.
         // solium-disable-next-line security/no-inline-assembly
         assembly {
             size := extcodesize(account)
@@ -639,20 +638,20 @@ contract CryptoPizza is IERC721, ERC165 {
 }
 ```
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 Consultez la documentation Solidity et Vyper pour une vue d'ensemble plus complète des contrats intelligents :
 
-- [Solidity](https://solidity.readthedocs.io/)
-- [Vyper](https://vyper.readthedocs.io/)
+- [Solidity](https://docs.soliditylang.org/)
+- [Vyper](https://docs.vyperlang.org/en/stable/)
 
 ## Sujets connexes {#related-topics}
 
 - [Contrats intelligents](/developers/docs/smart-contracts/)
-- [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/)
+- [Machine Virtuelle Ethereum](/developers/docs/evm/)
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Réduire les contrats pour respecter la limite de taille](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _ - Quelques conseil pratiques pour réduire la taille de votre contrat intelligent_
-- [Consigner les données des contrats intelligents avec des événements](/developers/tutorials/logging-events-smart-contracts/) _- Introduction aux événements de contrats intelligents et comment vous pouvez les utiliser pour consigner les données_
-- [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 la taille des contrats pour combattre la limite de taille des contrats](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _– Quelques conseils pratiques pour réduire la taille de votre contrat intelligent._
+- [Journaliser les données des contrats intelligents avec des événements](/developers/tutorials/logging-events-smart-contracts/) _– Une introduction aux événements de contrats intelligents et comment vous pouvez les utiliser pour journaliser des données._
+- [Interagir avec d'autres contrats depuis Solidity](/developers/tutorials/interact-with-other-contracts-from-solidity/) _– Comment déployer un contrat intelligent à partir d'un contrat existant et interagir avec lui._
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/compiling/index.md b/public/content/translations/fr/developers/docs/smart-contracts/compiling/index.md
index 54d80085488..55b29fd8648 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/compiling/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/compiling/index.md
@@ -1,6 +1,6 @@
 ---
 title: Compiler des contrat intelligents
-description: Explication de la raison d'une compilation et pourquoi elle est nécessaire pour les contrats intelligents
+description: "Explication de la raison d'une compilation et pourquoi elle est nécessaire pour les contrats intelligents"
 lang: fr
 incomplete: true
 ---
@@ -9,41 +9,41 @@ Vous devez compiler vos contrats pour que votre application Web et la machine vi
 
 ## Prérequis {#prerequisites}
 
-Il peut être utile de commencer par lire nos pages sur les [contrats intelligents](/developers/docs/smart-contracts/) et la [machine virtuelle Ethereum](/developers/docs/evm/) avant de vous intéresser à la compilation.
+Il peut être utile d'avoir lu notre introduction aux [contrats intelligents](/developers/docs/smart-contracts/) et à la [machine virtuelle Ethereum](/developers/docs/evm/) avant d'aborder la compilation.
 
 ## L'EVM {#the-evm}
 
-Pour que l'[EVM](/developers/docs/evm/) puisse exécuter un contrat, il doit être en **bytecode**. La compilation a pour effet de transformer ceci :
+Pour que l'[EVM](/developers/docs/evm/) puisse exécuter votre contrat, il doit être en **bytecode**. La compilation a pour effet de transformer ceci :
 
 ```solidity
 pragma solidity 0.4.24;
 
 contract Greeter {
 
-    function greet() public constant returns (string) {
+    function greet() public view returns (string memory) {
         return "Hello";
     }
 
 }
 ```
 
-**en cela :**
+**en ceci :**
 
 ```
 PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0x41 JUMPI PUSH1 0x0 CALLDATALOAD PUSH29 0x100000000000000000000000000000000000000000000000000000000 SWAP1 DIV PUSH4 0xFFFFFFFF AND DUP1 PUSH4 0xCFAE3217 EQ PUSH2 0x46 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x52 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x5B PUSH2 0xD6 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 DUP1 PUSH1 0x20 ADD DUP3 DUP2 SUB DUP3 MSTORE DUP4 DUP2 DUP2 MLOAD DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP DUP1 MLOAD SWAP1 PUSH1 0x20 ADD SWAP1 DUP1 DUP4 DUP4 PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x9B JUMPI DUP1 DUP3 ADD MLOAD DUP2 DUP5 ADD MSTORE PUSH1 0x20 DUP2 ADD SWAP1 POP PUSH2 0x80 JUMP JUMPDEST POP POP POP POP SWAP1 POP SWAP1 DUP2 ADD SWAP1 PUSH1 0x1F AND DUP1 ISZERO PUSH2 0xC8 JUMPI DUP1 DUP3 SUB DUP1 MLOAD PUSH1 0x1 DUP4 PUSH1 0x20 SUB PUSH2 0x100 EXP SUB NOT AND DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP JUMPDEST POP SWAP3 POP POP POP PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST PUSH1 0x60 PUSH1 0x40 DUP1 MLOAD SWAP1 DUP2 ADD PUSH1 0x40 MSTORE DUP1 PUSH1 0x5 DUP2 MSTORE PUSH1 0x20 ADD PUSH32 0x48656C6C6F000000000000000000000000000000000000000000000000000000 DUP2 MSTORE POP SWAP1 POP SWAP1 JUMP STOP LOG1 PUSH6 0x627A7A723058 KECCAK256 SLT 0xec 0xe 0xf5 0xf8 SLT 0xc7 0x2d STATICCALL ADDRESS SHR 0xdb COINBASE 0xb1 BALANCE 0xe8 0xf8 DUP14 0xda 0xad DUP13 LOG1 0x4c 0xb4 0x26 0xc2 DELEGATECALL PUSH7 0x8994D3E002900
 ```
 
-Ils sont appelés **codes d'opérations**. Les codes d'opérations sont les instructions de bas niveau que la machine virtuelle Ethereum (EVM) peut exécuter. Chaque code d'opération représente une opération spécifique, comme des opérations arithmétiques, des opérations logique, des manipulations de données, des flux de contrôle, etc.
+C'est ce que l'on appelle des **codes d'opérations**. Les codes d'opérations sont les instructions de bas niveau que la machine virtuelle Ethereum (EVM) peut exécuter. Chaque code d'opération représente une opération spécifique, comme des opérations arithmétiques, des opérations logique, des manipulations de données, des flux de contrôle, etc.
 
 [En savoir plus sur les codes d'opérations](/developers/docs/evm/opcodes/)
 
 ## Applications Web {#web-applications}
 
-Le compilateur produira également l'**interface binaire-programme (ABI)** dont vous avez besoin pour que votre application comprenne le contrat et appelle ses fonctions.
+Le compilateur produira également l'**interface binaire d'application (ABI)**, dont vous avez besoin pour que votre application comprenne le contrat et appelle les fonctions du contrat.
 
 L'ABI est un fichier JSON qui décrit le contrat déployé et ses fonctions de contrat intelligent. Cela aide à combler le fossé entre Web2 et Web3
 
-Une [bibliothèque cliente JavaScript](/developers/docs/apis/javascript/) va lire l'**ABI** afin de vous laisser appeler votre contrat intelligent dans l'interface de votre application Web.
+Une [bibliothèque cliente JavaScript](/developers/docs/apis/javascript/) lira l'**ABI** pour vous permettre d'appeler votre contrat intelligent depuis l'interface de votre application web.
 
 Vous trouverez ci-dessous l’ABI pour le contrat de jetons ERC-20. Un jeton ERC-20 est un jeton que vous pouvez échanger sur Ethereum.
 
@@ -272,11 +272,11 @@ Vous trouverez ci-dessous l’ABI pour le contrat de jetons ERC-20. Un jeton ERC
 ]
 ```
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Spécification ABI](https://solidity.readthedocs.io/en/v0.7.0/abi-spec.html) _- Solidity_
+- [Spécification de l'ABI](https://solidity.readthedocs.io/en/v0.7.0/abi-spec.html) _– Solidity_
 
 ## Sujets connexes {#related-topics}
 
 - [Bibliothèques clientes JavaScript](/developers/docs/apis/javascript/)
-- [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/)
+- [Machine virtuelle Ethereum](/developers/docs/evm/)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/composability/index.md b/public/content/translations/fr/developers/docs/smart-contracts/composability/index.md
index 1029b01e766..015a78dd268 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/composability/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/composability/index.md
@@ -1,13 +1,13 @@
 ---
-title: Composabilité des contrats intelligents
-description:
+title: "Composabilité des contrats intelligents"
+description: "Découvrez comment les contrats intelligents peuvent être combinés comme des blocs Lego pour créer des dapps complexes en réutilisant les composants existants."
 lang: fr
 incomplete: true
 ---
 
-## Une Brève introduction {#a-brief-introduction}
+## Une brève introduction {#a-brief-introduction}
 
-Les contrats intelligents sont publics sur Ethereum et peuvent être considérés comme des API ouvertes. Vous n'avez pas besoin de rédiger votre propre contrat intelligent pour devenir développeur de DApps, il vous suffit de savoir comment interagir avec eux. Par exemple, vous pouvez utiliser les contrats intelligents existants d'[Uniswap](https://uniswap.exchange/swap), un système d'échange décentralisé, pour gérer toute la logique d'échange de jetons dans votre application. Vous n'avez pas besoin de partir de zéro. Découvrez certains de leurs contrats [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) et [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts).
+Sur Ethereum, les contrats intelligents sont publics. Ils peuvent être considérés comme des API ouvertes. Vous n'avez pas besoin de rédiger votre propre contrat intelligent pour devenir développeur de DApps, il vous suffit de savoir comment interagir avec eux. Par exemple, vous pouvez utiliser les contrats intelligents existants d'[Uniswap](https://uniswap.exchange/swap), un échange décentralisé, pour gérer toute la logique d'échange de jetons dans votre application – vous n'avez pas besoin de repartir de zéro. Consultez certains de leurs contrats [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) et [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts).
 
 ## Qu'est-ce que la composabilité ? {#what-is-composability}
 
@@ -19,21 +19,21 @@ Sur Ethereum, chaque contrat intelligent est une sorte de Lego : vous pouvez uti
 
 Les contrats intelligents sur Ethereum agissent comme des API publics, ainsi tout le monde peut interagir avec le contrat ou les réutiliser pour y ajouter des fonctionnalités pour un dapps. La composabilité des contrats intelligents repose généralement sur trois principes : la modularité, l'autonomie et la découverte :
 
-**1. Modularité** : C'est la capacité de chaque composant à effectuer une tâche spécifique. Dans Ethereum, chaque contrat intelligent a un cas d'utilisation spécifique (comme indiqué dans l'exemple Uniswap).
+**1. Modularité** : C'est la capacité des composants individuels à effectuer une tâche spécifique. Dans Ethereum, chaque contrat intelligent a un cas d'utilisation spécifique (comme indiqué dans l'exemple Uniswap).
 
-**2. Autonomie** : Les composants composables doivent pouvoir fonctionner de manière indépendante. Chaque contrat intelligent dans Ethereum s'exécute automatiquement et peut fonctionner sans compter sur d'autres éléments du système.
+**2. Autonomie** : Les composants composables doivent pouvoir fonctionner de manière indépendante. Chaque contrat intelligent dans Ethereum s'exécute automatiquement et peut fonctionner sans compter sur d'autres éléments du système.
 
-**3. Découverte** : Les développeurs ne peuvent pas appeler des contrats externes ou intégrer des bibliothèques logicielles dans des applications si les premières ne sont pas disponibles publiquement. Grâce à leur conception, les contrats intelligents sont open-source ; n'importe qui peut appeler un contrat intelligent ou récupérer le code base.
+**3. Découvrabilité** : Les développeurs ne peuvent pas appeler de contrats externes ou intégrer des bibliothèques logicielles dans des applications si ces derniers ne sont pas publiquement disponibles. Grâce à leur conception, les contrats intelligents sont open-source ; n'importe qui peut appeler un contrat intelligent ou récupérer le code base.
 
-## Les avantages de la composabilité {#benefits-of-composability}
+## Avantages de la composabilité {#benefits-of-composability}
 
-### Un cycle de développement plus court {#shorter-development-cycle}
+### Cycle de développement plus court {#shorter-development-cycle}
 
-La composabilité réduit le travail des développeurs lors de la création de [dapps](/apps/#what-are-dapps). [Comme le dit Naval Ravikant :](https://twitter.com/naval/status/1444366754650656770) « L'Open Source signifie que tout problème doit être résolu une fois. »
+La composabilité réduit le travail que les développeurs doivent effectuer lors de la création de [dapps](/apps/#what-are-dapps). [Comme le dit Naval Ravikant :](https://twitter.com/naval/status/1444366754650656770) « L'open source signifie que chaque problème ne doit être résolu qu'une seule fois. »
 
 S'il y a un contrat intelligent qui résout un problème, d'autres développeurs peuvent le réutiliser, de sorte qu'ils n'aient pas à résoudre le même problème. De cette façon, les développeurs peuvent utiliser des bibliothèques logicielles existantes et ajouter des fonctionnalités supplémentaires pour créer de nouvelles DApps.
 
-### Amélioration de l'innovation {#greater-innovation}
+### Innovation accrue {#greater-innovation}
 
 La composabilité encourage l'innovation et l'expérimentation puisque les développeurs sont libres de réutiliser, modifier, dupliquer ou intégrer du code open-source pour créer les résultats souhaités. En conséquence, les équipes de développement passent moins de temps sur les fonctionnalités de base et peuvent allouer plus de temps à expérimenter de nouvelles fonctionnalités.
 
@@ -43,13 +43,13 @@ L'interopérabilité entre les composants de l'écosystème Ethereum améliore l
 
 Nous utiliserons un exemple de négociation d'arbitrage pour illustrer les avantages de l'interopérabilité :
 
-Si un jeton se négocie plus à la hausse sur la `plateforme d'échange A` que sur la `plateforme d'échange B`, vous pouvez tirer parti de la différence de prix pour faire des profits. Cependant, vous ne pouvez le faire que si vous avez suffisamment de capitaux pour financer la transaction (c.-à-d. acheter le jeton sur une `plateforme d'échange B` et le vendre sur la `plateforme d'échange A`).
+Si un jeton se négocie à un prix plus élevé sur `exchange A` que sur `exchange B`, vous pouvez profiter de la différence de prix pour réaliser un bénéfice. Cependant, vous ne pouvez le faire que si vous disposez de suffisamment de capital pour financer la transaction (c'est-à-dire acheter le jeton sur `exchange B` et le vendre sur `exchange A`).
 
-Dans un scénario où vous ne disposez pas de fonds suffisants pour couvrir la négociation, un prêt flash pourrait être idéal. [Les prêts Flash](/defi/#flash-loans) sont très techniques, mais l'idée de base est que vous pouvez emprunter des actifs (sans garantie) et les retourner de la même façon dans _une transaction_.
+Dans un scénario où vous ne disposez pas de fonds suffisants pour couvrir la négociation, un prêt flash pourrait être idéal. [Les prêts Flash](/defi/#flash-loans) sont très techniques, mais l'idée de base est que vous pouvez emprunter des actifs (sans garantie) et les restituer au sein d'_une_ seule transaction.
 
-Pour revenir à notre exemple initial, un trader d'arbitrage peut contracter un important prêt flash, acheter des jetons à partir de `la plateforme d'échange B`, les vendre sur `la plateforme d'échange B`, rembourser le capital + intérêt, et conserver le profit au cours de la même transaction. Cette logique complexe nécessite de combiner des appels à plusieurs contrats, ce qui ne serait pas possible si les contrats intelligents n'avaient pas d'interopérabilité.
+Pour en revenir à notre exemple initial, un trader d'arbitrage peut contracter un important prêt flash, acheter des jetons sur `exchange B`, les vendre sur `exchange A`, rembourser le capital et les intérêts, et conserver le bénéfice, le tout au sein de la même transaction. Cette logique complexe nécessite de combiner des appels à plusieurs contrats, ce qui ne serait pas possible si les contrats intelligents n'avaient pas d'interopérabilité.
 
-## Exemples de composabilité dans Ethereum {#composability-in-ethereum}
+## Exemples de composabilité sur Ethereum {#composability-in-ethereum}
 
 ### Échanges de jetons {#token-swaps}
 
@@ -57,20 +57,20 @@ Si vous créez une DApp qui requiert que les transactions soient payées en ETH,
 
 ### Gouvernance {#governance}
 
-Construire des systèmes de gouvernance sur mesure pour une [DAO](/dao/) peut être coûteux et prendre du temps. À la place, vous pourriez utiliser un ensemble d'outils de gouvernance Open-Source, comme [Aragon Client](https://client.aragon.org/), pour amorcer votre DAO et créer rapidement un cadre de gouvernance.
+Créer des systèmes de gouvernance sur mesure pour une [DAO](/dao/) peut être coûteux et chronophage. À la place, vous pourriez utiliser une boîte à outils de gouvernance open source, telle qu'[Aragon Client](https://client.aragon.org/), pour lancer votre DAO afin de créer rapidement un cadre de gouvernance.
 
-### Gestion des identités {#identity-management}
+### Gestion de l'identité {#identity-management}
 
-Au lieu de créer un système personnalisé d'authentification ou de s'appuyer sur des fournisseurs centralisés, vous pouvez intégrer des outils décentralisés d'identité (DID en anglais) pour gérer l'authentification des utilisateurs. Un exemple est [SpruceID](https://www.spruceid.com/), une boite à outils Open-Source qui offre une fonctionnalité « Connexion avec Ethereum » et qui permet aux utilisateurs de s'authentifier avec un portefeuille Ethereum.
+Au lieu de créer un système personnalisé d'authentification ou de s'appuyer sur des fournisseurs centralisés, vous pouvez intégrer des outils décentralisés d'identité (DID en anglais) pour gérer l'authentification des utilisateurs. Un exemple est [SpruceID](https://www.spruceid.com/), une boîte à outils open source qui offre une fonctionnalité « Se connecter avec Ethereum » qui permet aux utilisateurs d'authentifier leur identité avec un portefeuille Ethereum.
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Kickstart your Dapp frontend development with create-eth-app](/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/) _- Comment utiliser create-eth-app pour créer facilement des applications originales avec les contrats intelligents populaires._
+- [Démarrez rapidement le développement de votre frontend de dapp avec create-eth-app](/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/) _– Un aperçu de l'utilisation de create-eth-app pour créer des applications avec des contrats intelligents populaires prêts à l'emploi._
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
-- [La composabilité, c'est l'innovation](https://future.a16z.com/how-composability-unlocks-crypto-and-everything-else/)
-- [Pourquoi la composabilité est importante pour le Web3](https://hackernoon.com/why-composability-matters-for-web3)
-- [Qu'est-ce que la composabilité ?](https://blog.aragon.org/what-is-composability/#:~:text=Aragon,connect%20to%20every%20other%20piece.)
+- [La composabilité, c'est l'innovation](https://a16zcrypto.com/posts/article/how-composability-unlocks-crypto-and-everything-else/)
+- [Pourquoi la composabilité est-elle importante pour le Web3](https://hackernoon.com/why-composability-matters-for-web3)
+- [Qu'est-ce que la composabilité ?](https://blog.aragon.org/what-is-composability/#:~:text=Aragon,connect%20to%20every%20other%20piece.)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/deploying/index.md b/public/content/translations/fr/developers/docs/smart-contracts/deploying/index.md
index e7170331a13..7ef626ae28f 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/deploying/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/deploying/index.md
@@ -1,59 +1,59 @@
 ---
-title: Déployer des contrat intelligents
-description:
+title: "Déployer des contrat intelligents"
+description: "Apprenez à déployer des contrats intelligents sur les réseaux Ethereum, y compris les conditions préalables, les outils et les étapes de déploiement."
 lang: fr
 ---
 
 Vous devez déployer votre contrat intelligent afin qu'il soit disponible pour les utilisateurs sur un réseau Ethereum.
 
-Déployer un contrat intelligent consiste à envoyer sur la blockchain une transaction contenant le code du contrat intelligent compilé sans spécifier de destinataire.
+Pour déployer un contrat intelligent, il vous suffit d'envoyer une transaction Ethereum contenant le code compilé du contrat intelligent sans spécifier de destinataire.
 
 ## Prérequis {#prerequisites}
 
-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.
+Vous devriez comprendre 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 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.
+Le déploiement d'un contrat coûte également de l'éther (ETH) puisqu'il est stocké sur la blockchain. Vous devriez 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/).
+Enfin, vous devrez compiler votre contrat avant de le déployer, alors assurez-vous d'avoir lu la documentation sur la [compilation des contrats intelligents](/developers/docs/smart-contracts/compiling/).
 
 ## Comment déployer un contrat intelligent {#how-to-deploy-a-smart-contract}
 
 ### Ce dont vous aurez besoin {#what-youll-need}
 
-- Le bytecode de votre contrat - il est généré par la [compilation](/developers/docs/smart-contracts/compiling/).
+- Le bytecode de votre contrat – il est généré via 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/) avec une clé d'API
+- un accès à un [nœud Ethereum](/developers/docs/nodes-and-clients/), soit en exécutant le vôtre, en vous connectant à un nœud public, ou via une clé API en utilisant un [service de nœud](/developers/docs/nodes-and-clients/nodes-as-a-service/)
 
 ### Étapes pour déployer un contrat intelligent {#steps-to-deploy}
 
-Les étapes spécifiques dépendent du cadre de développement en question. Par exemple, vous pouvez consulter la [documentation de Hardhat sur le déploiement de vos contrats](https://hardhat.org/docs/tutorial/deploying) ou [la documentation de Foundry sur le déploiement et la vérification d'un contrat intelligent](https://book.getfoundry.sh/forge/deploying). Une fois déployé, votre contrat aura une adresse Ethereum comme les autres [comptes](/developers/docs/accounts/) et pourra être vérifié à l'aide [d'outils de vérification du code source](/developers/docs/smart-contracts/verifying/#source-code-verification-tools).
+Les étapes spécifiques dépendent du cadre de développement en question. Par exemple, vous pouvez consulter la [documentation de Hardhat sur le déploiement de vos contrats](https://hardhat.org/docs/tutorial/deploying) ou la [documentation de Foundry sur le déploiement et la vérification d'un contrat intelligent](https://book.getfoundry.sh/forge/deploying). Une fois déployé, votre contrat aura une adresse Ethereum comme les autres [comptes](/developers/docs/accounts/) et pourra être vérifié à l'aide d'[outils de vérification du code source](/developers/docs/smart-contracts/verifying/#source-code-verification-tools).
 
 ## Outils connexes {#related-tools}
 
-**Remix - _L'IDE Remix permet le développement, le déploiement et l'administration de contrats intelligents pour des blockchains similaires à Ethereum_**
+**Remix - _L'IDE Remix permet le développement, le déploiement et l'administration de contrats intelligents pour des blockchains de type Ethereum_**
 
 - [Remix](https://remix.ethereum.org)
 
-**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 - _Plateforme de développement Web3 qui fournit des outils de débogage, d'observabilité et des blocs de construction d'infrastructure pour le développement, le test, la surveillance et l'exploitation de contrats intelligents_**
 
 - [tenderly.co](https://tenderly.co/)
 - [Documentation](https://docs.tenderly.co/)
 - [GitHub](https://github.com/Tenderly)
 - [Discord](https://discord.gg/eCWjuvt)
 
-**Hardhat - _Un environnement de programmation pour compiler, déployer, tester et débugger vos logiciels Ethereum_**
+**Hardhat - _Un environnement de développement pour compiler, déployer, tester et déboguer vos logiciels Ethereum_**
 
 - [hardhat.org](https://hardhat.org/getting-started/)
-- [Documentation sur le déploiement de contrats](https://hardhat.org/docs/tutorial/deploying)
+- [Documentation sur le déploiement de vos contrats](https://hardhat.org/docs/tutorial/deploying)
 - [GitHub](https://github.com/nomiclabs/hardhat)
 - [Discord](https://discord.com/invite/TETZs2KK4k)
 
-**thirdweb - _Déployez facilement n'importe quel contrat sur n'importe quelle chaîne compatible EVM en une seule commande_**
+**thirdweb - _Déployez facilement n'importe quel contrat sur n'importe quelle chaîne compatible EVM, en utilisant une seule commande_**
 
 - [Documentation](https://portal.thirdweb.com/deploy/)
 
-**Crossmint - _Plateforme de développement Web3 de niveau entreprise pour déployer des contrats intelligents, permettre les paiements par carte de crédit et inter-chaînes et utiliser des API pour créer, distribuer, vendre, stocker et modifier des NFT._**
+**Crossmint - _Plateforme de développement Web3 de niveau entreprise pour déployer des contrats intelligents, activer les paiements par carte de crédit et inter-chaînes, et utiliser des API pour créer, distribuer, vendre, stocker et modifier des NFT._**
 
 - [crossmint.com](https://www.crossmint.com)
 - [Documentation](https://docs.crossmint.com)
@@ -62,19 +62,19 @@ Les étapes spécifiques dépendent du cadre de développement en question. Par
 
 ## 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_
-- [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_
+- [Déployer votre premier contrat intelligent](/developers/tutorials/deploying-your-first-smart-contract/) _– Une introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum._
+- [Hello World | Tutoriel de contrat intelligent](/developers/tutorials/hello-world-smart-contract/) _– Un tutoriel facile à suivre pour créer et déployer un contrat intelligent de base sur Ethereum._
+- [Interagir avec d'autres contrats depuis Solidity](/developers/tutorials/interact-with-other-contracts-from-solidity/) _– Comment déployer un contrat intelligent à partir d'un contrat existant et interagir avec lui._
+- [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 maintenir sous la limite et économiser du gaz_
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [https://docs.openzeppelin.com/learn/deploying-and-interacting](https://docs.openzeppelin.com/learn/deploying-and-interacting) - _OpenZeppelin_
-- [Déploiement de vos contrats avec Hardhat](https://hardhat.org/docs/tutorial/deploying) - _Nomic Labs_
+- [Déployer vos contrats avec Hardhat](https://hardhat.org/docs/tutorial/deploying) - _Nomic Labs_
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
-## Thèmes connexes {#related-topics}
+## Sujets connexes {#related-topics}
 
 - [Frameworks de développement](/developers/docs/frameworks/)
 - [Exécuter un nœud Ethereum](/developers/docs/nodes-and-clients/run-a-node/)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/formal-verification/index.md b/public/content/translations/fr/developers/docs/smart-contracts/formal-verification/index.md
index 7c43dec0543..a37c74cbf4b 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/formal-verification/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/formal-verification/index.md
@@ -1,12 +1,12 @@
 ---
-title: Vérification formelle des contrats intelligents
-description: Un aperçu de la vérification formelle des contrats intelligents Ethereum
+title: "Vérification formelle des contrats intelligents"
+description: "Un aperçu de la vérification formelle des contrats intelligents Ethereum"
 lang: fr
 ---
 
 [Les contrats intelligents](/developers/docs/smart-contracts/) permettent de créer des applications décentralisées, sans confiance et robustes qui introduisent de nouveaux cas d'utilisation et déverrouillent la valeur pour les utilisateurs. Parce que les contrats intelligents gèrent de grandes quantités de valeur, la sécurité est une considération essentielle pour les développeurs.
 
-La vérification formelle est l'une des techniques recommandées pour améliorer [la sécurité du contrat intelligent](/developers/docs/smart-contracts/security/). La vérification formelle, qui utilise [des méthodes formelles](https://www.brookings.edu/techstream/formal-methods-as-a-path-toward-better-cybersecurity/) pour spécifier, concevoir et vérifier les programmes a été utilisée pendant des années pour assurer l'exactitude des systèmes matériels et logiciels critiques.
+La vérification formelle est l'une des techniques recommandées pour améliorer [la sécurité des contrats intelligents](/developers/docs/smart-contracts/security/). La vérification formelle, qui utilise [des méthodes formelles](https://www.brookings.edu/techstream/formal-methods-as-a-path-toward-better-cybersecurity/) pour spécifier, concevoir et vérifier les programmes, est utilisée depuis des années pour garantir l'exactitude des systèmes matériels et logiciels critiques.
 
 Lorsqu'elle est mise en œuvre dans des contrats intelligents, la vérification formelle peut prouver que la logique commerciale d'un contrat répond à une spécification prédéfinie. Pa rapport à d'autres méthodes d'évaluation de la justesse du code contractuel, comme les tests, la vérification formelle donne des garanties plus solides qu'un contrat intelligent est correct sur le plan fonctionnel.
 
@@ -20,79 +20,79 @@ Les comportements attendus du système (un contrat intelligent dans ce cas) sont
 
 En informatique, un [modèle formel](https://en.wikipedia.org/wiki/Model_of_computation) est une description mathématique d'un processus de calcul. Les programmes sont abstraits en fonctions mathématiques (équations), avec le modèle décrivant comment les sorties aux fonctions sont calculées en entrée donnée.
 
-Les modèles formels fournissent un niveau d'abstraction sur lequel l'analyse du comportement d'un programme peut être évaluée. L'existence de modèles formels permet la création d'une _spécification formelle_ qui décrit les propriétés souhaitées du modèle en question.
+Les modèles formels fournissent un niveau d'abstraction sur lequel l'analyse du comportement d'un programme peut être évaluée. L'existence de modèles formels permet la création d'une _spécification formelle_, qui décrit les propriétés souhaitées du modèle en question.
 
 Différentes techniques sont utilisées pour modéliser des contrats intelligents pour la vérification formelle. Par exemple, certains modèles sont utilisés pour expliquer le comportement à haut niveau d'un contrat intelligent. Ces techniques de modélisation appliquent une vue en boîte noire aux contrats intelligents, les considérant comme des systèmes qui acceptent les entrées et exécutent le calcul basé sur ces entrées.
 
 Les modèles de haut niveau se concentrent sur la relation entre les contrats intelligents et les agents externes, tels que les comptes détenus à l'extérieur (EOA), les comptes contractuels et l'environnement blockchain. De tels modèles sont utiles pour définir des propriétés qui spécifient comment un contrat doit se comporter en réponse à certaines interactions de l'utilisateur.
 
-Inversement, d'autres modèles formels se concentrent sur le comportement de bas niveau d'un contrat intelligent. Bien que les modèles de haut niveau puissent contribuer à raisonner sur les fonctionnalités d'un contrat, ils peuvent échouer à saisir des détails sur le fonctionnement interne de l'implémentation. Les modèles de bas niveau appliquent une vue en boîte blanche à l'analyse du programme et s'appuient sur des représentations de bas niveau des applications du contrat intelligent, comme le programme trace et [ contrôle les graphiques de flux](https://en.wikipedia.org/wiki/Control-flow_graph), afin de réfléchir sur les propriétés pertinentes pour l'exécution d'un contrat.
+Inversement, d'autres modèles formels se concentrent sur le comportement de bas niveau d'un contrat intelligent. Bien que les modèles de haut niveau puissent contribuer à raisonner sur les fonctionnalités d'un contrat, ils peuvent échouer à saisir des détails sur le fonctionnement interne de l'implémentation. Les modèles de bas niveau appliquent une vue en boîte blanche à l'analyse de programmes et s'appuient sur des représentations de bas niveau d'applications de contrats intelligents, telles que les traces de programme et les [graphes de flux de contrôle](https://en.wikipedia.org/wiki/Control-flow_graph), pour raisonner sur les propriétés pertinentes pour l'exécution d'un contrat.
 
-Les modèles de bas niveau sont considérés comme idéaux puisqu'ils représentent l'exécution réelle d'un contrat intelligent dans l'environnement d'exécution d'Ethereum (c'est-à-dire l'[EVM](/developers/docs/evm/)). Les techniques de modélisation de bas niveau sont particulièrement utiles pour établir des propriétés de sécurité critiques dans les contrats intelligents et détecter les vulnérabilités potentielles.
+Les modèles de bas niveau sont considérés comme idéaux, car ils représentent l'exécution réelle d'un contrat intelligent dans l'environnement d'exécution d'Ethereum (c'est-à-dire l'[EVM](/developers/docs/evm/)). Les techniques de modélisation de bas niveau sont particulièrement utiles pour établir des propriétés de sécurité critiques dans les contrats intelligents et détecter les vulnérabilités potentielles.
 
 ### Qu'est-ce que la vérification formelle ? {#what-is-a-formal-specification}
 
 Une spécification est simplement une exigence technique à laquelle un système particulier doit satisfaire. Dans la programmation, les spécifications représentent des idées générales sur l'exécution d'un programme (c'est-à-dire ce que le programme doit faire).
 
-Dans le contexte des contrats intelligents, les spécifications formelles font référence aux _propriétés_- descriptions formelles des exigences qu'un contrat doit satisfaire. De telles propriétés sont décrites comme des « invariants » et représentent des assertions logiques sur l'exécution d'un contrat qui doivent rester vraies dans toutes les circonstances possibles, sans aucune exception.
+Dans le contexte des contrats intelligents, les spécifications formelles font référence aux _propriétés_ : des descriptions formelles des exigences qu'un contrat doit satisfaire. De telles propriétés sont décrites comme des « invariants » et représentent des assertions logiques sur l'exécution d'un contrat qui doivent rester vraies dans toutes les circonstances possibles, sans aucune exception.
 
 Ainsi, nous pouvons considérer une spécification formelle comme un ensemble de déclarations écrites dans un langage formel décrivant l'exécution prévue d'un contrat intelligent. Les spécifications couvrent les propriétés d'un contrat et définissent comment le contrat devrait se comporter dans des circonstances différentes. Le but de la vérification officielle est de déterminer si un contrat intelligent possède ces propriétés (invariants) et si ces propriétés ne sont pas enfreintes pendant l'exécution.
 
 Les spécifications formelles sont cruciales pour la mise en œuvre sécurisée de contrats intelligents. Les contrats qui ne mettent pas en œuvre les invariants ou qui ont leurs propriétés violées pendant l'exécution sont sujets à des vulnérabilités qui peuvent nuire aux fonctionnalités ou causer des exploits malveillants.
 
-## Types de spécifications formelles des contrats intelligents {#formal-specifications-for-smart-contracts}
+## Types de spécifications formelles pour les contrats intelligents {#formal-specifications-for-smart-contracts}
 
 Les spécifications formelles permettent un raisonnement mathématique sur la justesse de l'exécution du programme. Comme pour les modèles formels, les spécifications formelles peuvent capturer des propriétés de haut niveau ou un comportement de bas niveau lors de l’implémentation d'un contrat.
 
-Les spécifications formelles sont dérivées de l'utilisation des éléments de la [logique des programmes](https://en.wikipedia.org/wiki/Logic_programming), qui permettent un raisonnement formel sur les propriétés d'un programme. La logique d'un programme comporte des règles formelles qui expriment (en langage mathématique) le comportement attendu d'un programme. Diverses logiques de programme sont utilisées pour créer des spécifications formelles, notamment [la logique d'accessibilité](https://en.wikipedia.org/wiki/Reachability_problem), [la logique temporelle](https://en.wikipedia.org/wiki/Temporal_logic) et [la logique de Hoare](https://en.wikipedia.org/wiki/Hoare_logic).
+Les spécifications formelles sont dérivées d'éléments de la [logique de programmation](https://en.wikipedia.org/wiki/Logic_programming), qui permettent un raisonnement formel sur les propriétés d'un programme. La logique d'un programme comporte des règles formelles qui expriment (en langage mathématique) le comportement attendu d'un programme. Diverses logiques de programme sont utilisées pour créer des spécifications formelles, notamment la [logique d'accessibilité](https://en.wikipedia.org/wiki/Reachability_problem), la [logique temporelle](https://en.wikipedia.org/wiki/Temporal_logic) et la [logique de Hoare](https://en.wikipedia.org/wiki/Hoare_logic).
 
-Les spécifications formelles des contrats intelligents peuvent être classées en deux catégories : les spécifications de **haut niveau** ou les spécifications de **bas niveau**. Quelle que soit la catégorie à laquelle appartient une spécification, elle doit décrire de manière adéquate et sans ambiguïté la propriété du système analysé.
+Les spécifications formelles pour les contrats intelligents peuvent être classées en deux catégories : les spécifications de **haut niveau** ou les spécifications de **bas niveau**. Quelle que soit la catégorie à laquelle appartient une spécification, elle doit décrire de manière adéquate et sans ambiguïté la propriété du système analysé.
 
 ### Spécifications de haut niveau {#high-level-specifications}
 
-Comme son nom l'indique, une spécification de haut niveau (également appelée « spécification orientée modèle ») décrit le comportement de haut niveau d'un programme. Les spécifications de haut niveau modélisent un contrat intelligent comme une [machine à états finis](https://en.wikipedia.org/wiki/Finite-state_machine) (finite state machine, FSM), qui peut passer d'un état à l'autre en effectuant des opérations, la logique temporelle étant utilisée pour définir les propriétés formelles du modèle FSM.
+Comme son nom l'indique, une spécification de haut niveau (également appelée « spécification orientée modèle ») décrit le comportement de haut niveau d'un programme. Les spécifications de haut niveau modélisent un contrat intelligent comme une [machine à états finis](https://en.wikipedia.org/wiki/Finite-state_machine) (FSM), qui peut passer d'un état à l'autre en effectuant des opérations, la logique temporelle étant utilisée pour définir les propriétés formelles du modèle FSM.
 
-[Les logiques temporelles](https://en.wikipedia.org/wiki/Temporal_logic) sont des « règles de raisonnement sur des propositions qualifiées en termes de temps (par exemple, " j'ai _toujours_ faim " ou " j'aurai faim _un jour_ "). » Appliquées à la vérification formelle, les logiques temporelles sont utilisées pour énoncer des assertions sur le comportement correct de systèmes modélisés comme des machines à états. Plus précisément, une logique temporelle décrit les états futurs dans lesquels un contrat intelligent peut se trouver et la manière dont il passe d'un état à l'autre.
+Les [logiques temporelles](https://en.wikipedia.org/wiki/Temporal_logic) sont des « règles de raisonnement sur des propositions qualifiées en termes de temps (p. ex., \ Appliquées à la vérification formelle, les logiques temporelles sont utilisées pour énoncer des assertions sur le comportement correct de systèmes modélisés comme des machines à états. Plus précisément, une logique temporelle décrit les états futurs dans lesquels un contrat intelligent peut se trouver et la manière dont il passe d'un état à l'autre.
 
-Les spécifications de haut niveau tiennent généralement compte de deux propriétés temporelles essentielles pour les contrats intelligents : la **sécurité** et la **permanence**. Les propriétés de sécurité représentent l'idée que « rien de mauvais n'arrive jamais » et expriment généralement l'invariance. Une propriété de sécurité peut définir des exigences logicielles générales, telles que l'absence de [deadlock](https://www.techtarget.com/whatis/definition/deadlock), ou exprimer des propriétés spécifiques à un domaine pour les contrats (par exemple, des invariants sur le contrôle d'accès pour les fonctions, des valeurs admissibles de variables d'état ou des conditions pour les transferts de jetons).
+Les spécifications de haut niveau capturent généralement deux propriétés temporelles critiques pour les contrats intelligents : la **sécurité** et la **vivacité**. Les propriétés de sécurité représentent l'idée que « rien de mauvais n'arrive jamais » et expriment généralement l'invariance. Une propriété de sécurité peut définir des exigences logicielles générales, telles que l'absence d'[interblocage](https://www.techtarget.com/whatis/definition/deadlock), ou exprimer des propriétés spécifiques au domaine pour les contrats (p. ex., les invariants sur le contrôle d'accès pour les fonctions, les valeurs admissibles des variables d'état ou les conditions pour les transferts de jetons).
 
-Prenons par exemple cette exigence de sécurité qui couvre les conditions d'utilisation de `transfer()` ou de `transferFrom()` dans les contrats de jetons ERC-20 : _« Le solde d'un expéditeur n'est jamais inférieur à la quantité demandée de jetons à envoyer. »_. Cette description en langage naturel d'un invariant contractuel peut être traduite en une spécification formelle (mathématique), dont la validité peut ensuite être rigoureusement vérifiée.
+Prenez par exemple cette exigence de sécurité qui couvre les conditions d'utilisation de `transfer()` ou `transferFrom()` dans les contrats de jeton ERC-20 : _« Le solde d'un expéditeur n'est jamais inférieur au montant de jetons demandé pour l'envoi. »_. Cette description en langage naturel d'un invariant contractuel peut être traduite en une spécification formelle (mathématique), dont la validité peut ensuite être rigoureusement vérifiée.
 
-Les propriétés de vivacité affirment que « quelque chose de bien finit par se produire » et concernent la capacité d'un contrat à passer par différents états. La « liquidité », qui désigne la capacité d'un contrat à transférer ses soldes aux utilisateurs qui en font la demande, est un exemple de propriété de vivacité. En cas de violation de cette propriété, les utilisateurs ne pourraient pas retirer les actifs stockés dans le contrat, comme cela s'est produit lors de l'incident du [Parity wallet](https://www.cnbc.com/2017/11/08/accidental-bug-may-have-frozen-280-worth-of-ether-on-parity-wallet.html).
+Les propriétés de vivacité affirment que « quelque chose de bien finit par se produire » et concernent la capacité d'un contrat à passer par différents états. La « liquidité », qui désigne la capacité d'un contrat à transférer ses soldes aux utilisateurs qui en font la demande, est un exemple de propriété de vivacité. Si cette propriété est violée, les utilisateurs ne pourraient pas retirer les actifs stockés dans le contrat, comme ce qui s'est passé avec l'[incident du portefeuille Parity](https://www.cnbc.com/2017/11/08/accidental-bug-may-have-frozen-280-worth-of-ether-on-parity-wallet.html).
 
 ### Spécifications de bas niveau {#low-level-specifications}
 
 Les spécifications de haut niveau prennent comme point de départ un modèle d'état fini d'un contrat et définissent les propriétés souhaitées de ce modèle. En revanche, les spécifications de bas niveau (également appelées « spécifications axées sur les propriétés ») modélisent souvent les programmes (contrats intelligents) comme des systèmes comprenant une collection de fonctions mathématiques et décrivent le comportement correct de ces systèmes.
 
-Pour simplifier, les spécifications de bas niveau analysent les _traces de programme_ et tentent de définir les propriétés d'un contrat intelligent à partir de ces traces. Les traces font référence à des séquences d'exécutions de fonctions qui modifient l'état d'un contrat intelligent ; par conséquent, les spécifications de bas niveau permettent de préciser les exigences relatives à l'exécution interne d'un contrat.
+En termes plus simples, les spécifications de bas niveau analysent les _traces de programme_ et tentent de définir les propriétés d'un contrat intelligent sur ces traces. Les traces font référence à des séquences d'exécutions de fonctions qui modifient l'état d'un contrat intelligent ; par conséquent, les spécifications de bas niveau permettent de préciser les exigences relatives à l'exécution interne d'un contrat.
 
 Les spécifications formelles de bas niveau peuvent être données sous forme de propriétés de type Hoare ou d'invariants sur les chemins d'exécution.
 
 ### Propriétés de style Hoare {#hoare-style-properties}
 
-[La logique Hoare](https://en.wikipedia.org/wiki/Hoare_logic) fournit un ensemble de règles formelles pour raisonner sur la correction des programmes, y compris les contrats intelligents. Une propriété de style Hoare est représentée par un triple Hoare `{P}c{Q}`, où `c` est un programme et `P` et `Q` sont des prédicats sur l'état de `c` (c'est-à-dire le programme), formellement décrits comme des _prérequis_ et des _conditions ulérieures_, respectivement.
+La [logique de Hoare](https://en.wikipedia.org/wiki/Hoare_logic) fournit un ensemble de règles formelles pour raisonner sur l'exactitude des programmes, y compris les contrats intelligents. Une propriété de style Hoare est représentée par un triplet de Hoare `{P}c{Q}`, où `c` est un programme et `P` et `Q` sont des prédicats sur l'état de `c` (c.-à-d. le programme), décrits formellement comme des _préconditions_ et des _postconditions_, respectivement.
 
-Un prérequis est un prédicat décrivant les conditions requises pour l'exécution correcte d'une fonction ; les utilisateurs qui font appel au contrat doivent satisfaire à cette exigence. Une condition ultérieure est un prédicat décrivant la condition qu'une fonction établit si elle est correctement exécutée ; les utilisateurs peuvent s'attendre à ce que cette condition soit vraie après avoir appelé la fonction. Un _invariant_ en logique Hoare est un prédicat qui est préservé par l'exécution d'une fonction (c'est-à-dire qu'il ne change pas).
+Un prérequis est un prédicat décrivant les conditions requises pour l'exécution correcte d'une fonction ; les utilisateurs qui font appel au contrat doivent satisfaire à cette exigence. Une condition ultérieure est un prédicat décrivant la condition qu'une fonction établit si elle est correctement exécutée ; les utilisateurs peuvent s'attendre à ce que cette condition soit vraie après avoir appelé la fonction. Un _invariant_ dans la logique de Hoare est un prédicat qui est préservé par l'exécution d'une fonction (c.-à-d. qu'il ne change pas).
 
-Les spécifications de type Hoare peuvent garantir soit _une correction partielle_, soit _une correction totale_. La mise en œuvre d'une fonction contractuelle est « partiellement correcte » si le prérequis est vrai avant l'exécution de la fonction, et si l'exécution se termine, la condition ultérieure est également vraie. La preuve de l'exactitude totale est obtenue si un prérequis est vrai avant l'exécution de la fonction, si l'exécution est garantie comme devant se terminer et si, lorsqu'elle se termine, la condition ultérieure est vraie.
+Les spécifications de style Hoare peuvent garantir soit une _correction partielle_, soit une _correction totale_. La mise en œuvre d'une fonction contractuelle est « partiellement correcte » si le prérequis est vrai avant l'exécution de la fonction, et si l'exécution se termine, la condition ultérieure est également vraie. La preuve de l'exactitude totale est obtenue si un prérequis est vrai avant l'exécution de la fonction, si l'exécution est garantie comme devant se terminer et si, lorsqu'elle se termine, la condition ultérieure est vraie.
 
 Il est difficile d'obtenir une preuve de l'exactitude totale, car certaines exécutions peuvent être retardées avant de se terminer, ou ne jamais se terminer du tout. Cela dit, la question de savoir si l'exécution se termine est sans doute discutable puisque le mécanisme de gaz d'Ethereum empêche les boucles de programme infinies (l'exécution se termine soit avec succès, soit en raison d'une erreur de type « panne de gaz »).
 
 Les spécifications des contrats intelligents créées à l'aide de la logique Hoare comporteront des conditions préalables, des conditions ultérieures et des invariants définis pour l'exécution des fonctions et des boucles dans un contrat. Les prérequis incluent souvent la possibilité d'entrées erronées dans une fonction, les conditions ultérieures décrivant la réponse attendue à ces entrées (par exemple, le lancement d'une exception spécifique). De cette manière, les propriétés de type Hoare sont efficaces pour garantir l'exactitude de la mise en œuvre des contrats.
 
-De nombreux cadres de vérification formelle utilisent des spécifications de type Hoare pour prouver l'exactitude sémantique des fonctions. Il est également possible d'ajouter des propriétés de type Hoare (sous forme d'assertions) directement au code du contrat en utilisant les instructions `require` et `assert` dans Solidity.
+De nombreux cadres de vérification formelle utilisent des spécifications de type Hoare pour prouver l'exactitude sémantique des fonctions. Il est également possible d'ajouter des propriétés de style Hoare (en tant qu'assertions) directement au code du contrat en utilisant les instructions `require` et `assert` dans Solidity.
 
-Les instructions `require` expriment une condition préalable ou un invariant et sont souvent utilisées pour valider les entrées de l'utilisateur, tandis que `assert` capture une condition ultérieure nécessaire pour la sécurité. Par exemple, un contrôle d'accès approprié pour les fonctions (un exemple de propriété de sécurité) peut être réalisé en utilisant `require` comme vérification de la condition préalable de l'identité du compte appelant. De même, un invariant sur les valeurs admissibles des variables d'état dans un contrat (par exemple, le nombre total de jetons en circulation) peut être protégé contre les violations en utilisant `assert` pour confirmer l'état du contrat après l'exécution de la fonction.
+Les instructions `require` expriment une précondition ou un invariant et sont souvent utilisées pour valider les entrées de l'utilisateur, tandis que `assert` capture une postcondition nécessaire à la sécurité. Par exemple, un contrôle d'accès approprié pour les fonctions (un exemple de propriété de sécurité) peut être réalisé en utilisant `require` comme vérification de la précondition de l'identité du compte appelant. De même, un invariant sur les valeurs admissibles des variables d'état dans un contrat (par exemple, le nombre total de jetons en circulation) peut être protégé contre les violations en utilisant `assert` pour confirmer l'état du contrat après l'exécution de la fonction.
 
 ### Propriétés au niveau de la trace {#trace-level-properties}
 
 Les spécifications basées sur les traces décrivent les opérations qui permettent à un contrat de passer d'un état à l'autre et les relations entre ces opérations. Comme expliqué précédemment, les traces sont des séquences d'opérations qui modifient l'état d'un contrat d'une manière particulière.
 
-Cette approche repose sur un modèle de contrats intelligents en tant que systèmes de transition d'état avec certains états prédéfinis (décrits par des variables d'état) ainsi qu'un ensemble de transitions prédéfinies (décrites par des fonctions de contrat). En outre, un [graphique de flux de contrôle](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/) (CFG), qui est une représentation graphique du flux d'exécution d'un programme, est souvent utilisé pour décrire la sémantique opérationnelle d'un contrat. Ici, chaque trace représentée comme un chemin sur le graphe du flux de contrôle.
+Cette approche repose sur un modèle de contrats intelligents en tant que systèmes de transition d'état avec certains états prédéfinis (décrits par des variables d'état) ainsi qu'un ensemble de transitions prédéfinies (décrites par des fonctions de contrat). De plus, un [graphe de flux de contrôle](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/) (GFC), qui est une représentation graphique du flux d'exécution d'un programme, est souvent utilisé pour décrire la sémantique opérationnelle d'un contrat. Ici, chaque trace représentée comme un chemin sur le graphe du flux de contrôle.
 
 En premier lieu, les spécifications de niveau de trace sont utilisées pour expliquer les modèles d'exécution interne dans les contrats intelligents. En créant des spécifications de niveau de trace, nous affirmons que les chemins d'exécution sont admissibles (c'est-à-dire les transitions d'état) pour un contrat intelligent. En utilisant des techniques, telles que l'exécution symbolique, nous pouvons formellement vérifier que l'exécution ne suit jamais un chemin non défini dans le modèle formel.
 
-Utilisons un exemple de contrat [DAO](/dao/) qui a des fonctions accessibles au public pour décrire les propriétés de niveau de trace. Ici, nous supposons que le contrat DAO permet aux utilisateurs d'effectuer les opérations suivantes :
+Utilisons un exemple de contrat [DAO](/dao/) qui possède des fonctions accessibles au public pour décrire les propriétés au niveau de la trace. Ici, nous supposons que le contrat DAO permet aux utilisateurs d'effectuer les opérations suivantes :
 
 - Déposer des fonds
 
@@ -100,27 +100,27 @@ Utilisons un exemple de contrat [DAO](/dao/) qui a des fonctions accessibles au
 
 - Demander un remboursement s'ils ne votent pas sur une proposition
 
-Un exemple de propriétés au niveau de la trace pourrait être : _"les utilisateurs qui ne déposent pas de fonds ne peuvent pas voter une proposition"_ ou _"les utilisateurs qui ne votent pas une proposition devraient toujours être en mesure de demander un remboursement"_. Les deux propriétés font valoir les séquences d'exécution préférées (le vote ne peut pas se produire _avant_ de déposer des fonds et réclamer un remboursement ne peut pas se produire _après_ le vote d'une proposition).
+Des exemples de propriétés au niveau de la trace pourraient être _« les utilisateurs qui ne déposent pas de fonds ne peuvent pas voter sur une proposition »_ ou _« les utilisateurs qui ne votent pas sur une proposition devraient toujours pouvoir demander un remboursement »_. Ces deux propriétés affirment des séquences d'exécution préférées (le vote ne peut pas avoir lieu _avant_ le dépôt de fonds et la demande de remboursement ne peut pas avoir lieu _après_ le vote sur une proposition).
 
 ## Techniques de vérification formelle des contrats intelligents {#formal-verification-techniques}
 
-### Vérification du modèle {#model-checking}
+### Vérification de modèles {#model-checking}
 
 La vérification du modèle est une technique de vérification formelle dans laquelle un algorithme vérifie un modèle formel d'un contrat intelligent par rapport à ses spécifications. Dans la vérification des modèles, les contrats intelligents sont souvent représentés comme des systèmes de transition d'état, tandis que les propriétés sur les états de contrat autorisés sont définies en utilisant une logique temporelle.
 
-La vérification de modèles nécessite la création d'une représentation mathématique abstraite d'un système (à savoir un contrat) et exprimant les propriétés de ce système à l'aide de formules enracinées dans la [logique propositionnelle](https://www.baeldung.com/cs/propositional-logic). Cela simplifie la tâche de l'algorithme de vérification du modèle, à savoir prouver qu'un modèle mathématique réponde à une formule logique donnée.
+La vérification de modèles nécessite la création d'une représentation mathématique abstraite d'un système (c'est-à-dire un contrat) et l'expression des propriétés de ce système à l'aide de formules ancrées dans la [logique propositionnelle](https://www.baeldung.com/cs/propositional-logic). Cela simplifie la tâche de l'algorithme de vérification du modèle, à savoir prouver qu'un modèle mathématique réponde à une formule logique donnée.
 
-La vérification du modèle lors de la vérification formelle est principalement utilisé pour évaluer les propriétés temporelles qui décrivent le comportement d'un contrat au fil du temps. Les propriétés temporelles pour les contrats intelligents incluent _sécurité_ et _disponibilité_, ce que nous avons expliqué plus tôt.
+La vérification du modèle lors de la vérification formelle est principalement utilisé pour évaluer les propriétés temporelles qui décrivent le comportement d'un contrat au fil du temps. Les propriétés temporelles pour les contrats intelligents incluent la _sécurité_ et la _vivacité_, que nous avons expliquées précédemment.
 
-Par exemple, une propriété de sécurité liée au contrôle d'accès (p. ex. _Seul le propriétaire du contrat peut appeler `auto-détruit`_) peut être écrite en logique formelle. Par la suite, l'algorithme de vérification du modèle peut vérifier si le contrat satisfait à cette spécification formelle.
+Par exemple, une propriété de sécurité liée au contrôle d'accès (p. ex., _Seul le propriétaire du contrat peut appeler `selfdestruct`_) peut être écrite en logique formelle. Par la suite, l'algorithme de vérification du modèle peut vérifier si le contrat satisfait à cette spécification formelle.
 
 La vérification du modèle utilise l'exploration de l'espace d'état, qui implique la construction de tous les états possibles d'un contrat intelligent et de tenter de trouver des états accessibles qui entraînent des violations des biens. Cependant, cela peut conduire à un nombre infini d'états (connu sous le nom de « problème d'explosion d'état »), donc les vérificateurs de modèles s'appuient sur des techniques d'abstraction pour rendre possible une analyse efficace des contrats intelligents.
 
-### Preuve du théorème {#theorem-proving}
+### Démonstration de théorèmes {#theorem-proving}
 
 La démonstration de théorèmes est une méthode de raisonnement mathématique sur la justesse des programmes, y compris les contrats intelligents. Il s'agit de transformer le modèle du système d'un contrat et ses spécifications en formules mathématiques (déclarations logiques).
 
-L'objectif de la démonstration de théorèmes est de vérifier l'équivalence logique entre ces déclarations. L'« équivalence logique » (également appelée « bi-implication logique ») est un type de relation entre deux déclarations, la première déclaration étant vraie _si et seulement si_ la seconde déclaration est également vraie.
+L'objectif de la démonstration de théorèmes est de vérifier l'équivalence logique entre ces déclarations. L'« équivalence logique » (également appelée « bi-implication logique ») est un type de relation entre deux déclarations, la première déclaration étant vraie _si et seulement si_ la seconde déclaration est également vraie.
 
 La relation requise (équivalence logique) entre les déclarations sur le modèle d’un contrat et sa propriété est formulée comme une déclaration prouvable (appelée théorème). En utilisant un système formel d'inférence, le démonstrateur de théorème automatisé peut vérifier la validité du théorème. En d’autres termes, un démonstrateur de théorème peut prouver de manière concluante que le modèle d’un contrat intelligent correspond exactement à ses spécifications.
 
@@ -128,15 +128,15 @@ Alors que la vérification des modèles modélise les contrats comme des systèm
 
 En conséquence, une assistance humaine est souvent nécessaire pour guider le démonstrateur de théorème dans la dérivation des preuves d’exactitude. L'utilisation de l'effort humain dans la démonstration du théorème rend l'utilisation plus coûteuse que le contrôle des modèles, qui est entièrement automatisé.
 
-### Symbolic Execution {#symbolic-execution}
+### Exécution symbolique {#symbolic-execution}
 
-L'exécution symbolique est une méthode d'analyse d'un contrat intelligent en exécutant des fonctions à l'aide de _valeurs symboliques_ (p. ex., `x > 5`) au lieu de _valeurs concrètes_  (p. ex., `x == 5`). En tant que technique de vérification formelle, l'exécution symbolique est utilisée pour justifier formellement les propriétés de niveau de trace dans le code d'un contrat.
+L'exécution symbolique est une méthode d'analyse d'un contrat intelligent qui exécute des fonctions en utilisant des _valeurs symboliques_ (p. ex., `x > 5`) au lieu de _valeurs concrètes_ (p. ex., `x == 5`). En tant que technique de vérification formelle, l'exécution symbolique est utilisée pour justifier formellement les propriétés de niveau de trace dans le code d'un contrat.
 
-L'exécution symbolique représente une trace d'exécution en tant que formule mathématique sur des valeurs d'entrée symboliques, autrement appelée un _prédicat de chemin_. Un [solutionneur SMT](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories) est utilisé pour vérifier si un prédicat de chemin est « réalisable » (c.-à-d. s'il existe une valeur qui peut satisfaire la formule). Si un chemin vulnérable est satisfaisant, le solutionneur SMT génère une valeur concrète qui déclenche l'exécution vers ce chemin.
+L'exécution symbolique représente une trace d'exécution comme une formule mathématique sur des valeurs d'entrée symboliques, autrement appelée un _prédicat de chemin_. Un [solveur SMT](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories) est utilisé pour vérifier si un prédicat de chemin est \ Si un chemin vulnérable est satisfaisant, le solutionneur SMT génère une valeur concrète qui déclenche l'exécution vers ce chemin.
 
-Supposons que la fonction d'un contrat intelligent prend comme entrée une valeur `uint` (`x`) et revient lorsque `x` est supérieur à `5` et aussi inférieur à `10`. Trouver une valeur pour `x` qui déclenche l'erreur en utilisant une procédure de test normale nécessiterait de passer par des dizaines de cas de test (ou plus) sans l'assurance de trouver une entrée déclenchant une erreur.
+Supposons que la fonction d'un contrat intelligent prenne en entrée une valeur `uint` (`x`) et s'annule lorsque `x` est supérieur à `5` et également inférieur à `10`. Trouver une valeur pour `x` qui déclenche l'erreur en utilisant une procédure de test normale nécessiterait de passer par des dizaines de cas de test (ou plus) sans l'assurance de trouver une entrée déclenchant une erreur.
 
-Inversement, un outil d'exécution symbolique exécuterait la fonction avec la valeur symbolique : `X > 5 ∧ X < 10` (à savoir, `x` est supérieur à 5 ET `x` est inférieur à 10). Le prédicat de chemin associé `x = X > 5 ∧ X < 10` serait alors donné à résoudre à un solutionneur SMT. Si une valeur particulière satisfait la formule `x = X > 5 ∧ X < 10`, le solutionneur SMT la calculera — par exemple, ce dernier peut produire `7` comme une valeur pour `x`.
+Inversement, un outil d'exécution symbolique exécuterait la fonction avec la valeur symbolique : `X > 5 ∧ X < 10` (c.-à-d., `x` est supérieur à 5 ET `x` est inférieur à 10). Le prédicat de chemin associé `x = X > 5 ∧ X < 10` serait alors donné à résoudre à un solveur SMT. Si une valeur particulière satisfait la formule `x = X > 5 ∧ X < 10`, le solveur SMT la calculera — par exemple, ce dernier peut produire `7` comme une valeur pour `x`.
 
 Parce que l'exécution symbolique repose sur les entrées d'un programme, et l'ensemble des entrées pour explorer tous les états accessibles est potentiellement infini, c'est toujours une forme de test. Cependant, comme le montre l’exemple, l’exécution symbolique est plus efficace que les tests réguliers pour trouver des entrées qui déclenchent des violations des propriétés.
 
@@ -152,37 +152,38 @@ function safe_add(uint x, uint y) returns(uint z){
   require(z>=y);
 
   return z;
+}
 ```
 
-Une trace d'exécution qui aboutirait à un dépassement d'entier aurait besoin de satisfaire la formule : `z = x + y ET (z >= x) ET (z=>y) ET (z < x OU z < y)` Une telle formule est peu susceptible d'être résolue, donc cela sert de preuve mathématique que la fonction `safe_add` ne déborde jamais.
+Une trace d'exécution qui aboutit à un débordement d'entier devrait satisfaire la formule : `z = x + y AND (z >= x) AND (z >= y) AND (z < x OR z < y)`. Une telle formule a peu de chances d'être résolue, elle sert donc de preuve mathématique que la fonction `safe_add` ne déborde jamais.
 
-### Pourquoi utiliser la vérification formelle des contrats intelligents ? {#benefits-of-formal-verification}
+### Pourquoi utiliser la vérification formelle des contrats intelligents ? Avantages de la vérification formelle {#benefits-of-formal-verification}
 
-#### Nécessité de fiabilité {#need-for-reliability}
+#### Nécessité de la fiabilité {#need-for-reliability}
 
-La vérification formelle est utilisée pour évaluer la justesse des systèmes critiques de sécurité dont la défaillance peut avoir des conséquences dévastatrices, comme la mort, des blessures ou la ruine financière. Les contrats intelligents sont des applications de grande valeur qui contrôlent d'énormes quantités de valeur, et de simples erreurs de conception peuvent conduire à [des pertes irrécupérables pour les utilisateurs](https://www.freecodecamp.org/news/a-hacker-stole-31m-of-ether-how-it-happened-and-what-it-means-for-ethereum-9e5dc29e33ce/amp/). Cependant, la vérification formelle d'un contrat avant son déploiement peut accroître les garanties qu'il fonctionnera comme prévu une fois exécuté sur la blockchain.
+La vérification formelle est utilisée pour évaluer la justesse des systèmes critiques de sécurité dont la défaillance peut avoir des conséquences dévastatrices, comme la mort, des blessures ou la ruine financière. Les contrats intelligents sont des applications de grande valeur qui contrôlent d'énormes quantités de valeur, et de simples erreurs de conception peuvent entraîner des [pertes irrécupérables pour les utilisateurs](https://www.freecodecamp.org/news/a-hacker-stole-31m-of-ether-how-it-happened-and-what-it-means-for-ethereum-9e5dc29e33ce/amp/). Cependant, la vérification formelle d'un contrat avant son déploiement peut accroître les garanties qu'il fonctionnera comme prévu une fois exécuté sur la blockchain.
 
 La fiabilité est une qualité très recherchée dans tout contrat intelligent, surtout parce que le code déployé sur la machine virtuelle Ethereum (EVM) est généralement immuable. Avec les mises à niveau postérieures au lancement qui ne sont pas facilement accessibles, la nécessité de garantir la fiabilité des contrats rend la vérification formelle nécessaire. La vérification formelle est capable de détecter les problèmes délicats, tels que les soupassements et dépassements d'entier, la réadmission et les mauvaises optimisations gazières, qui peuvent faire glisser les vérificateurs et les testeurs passés.
 
-#### Prouver la justesse fonctionnelle {#prove-functional-correctness}
+#### Prouver l'exactitude fonctionnelle {#prove-functional-correctness}
 
 Les tests de programmes sont la méthode la plus courante pour prouver qu'un contrat intelligent satisfait à certaines exigences. Cela implique l'exécution d'un contrat avec un échantillon des données dont il est censé traiter et analyser le comportement. Si le contrat renvoie les résultats escomptés pour les données de l'échantillon, les développeurs auront alors une preuve objective de son exactitude.
 
-Cependant, cette approche ne peut pas prouver une exécution correcte pour les valeurs d'entrée qui ne font pas partie de l'échantillon. Par conséquent, tester un contrat peut aider à détecter les bogues (à savoir si certains chemins de code ne parviennent pas à retourner les résultats souhaités pendant l'exécution), mais **cela ne prouve pas de façon concluante l'absence de bogues**.
+Cependant, cette approche ne peut pas prouver une exécution correcte pour les valeurs d'entrée qui ne font pas partie de l'échantillon. Par conséquent, le test d'un contrat peut aider à détecter des bogues (c.-à-d., si certains chemins de code ne parviennent pas à renvoyer les résultats souhaités pendant l'exécution), mais **il ne peut pas prouver de manière concluante l'absence de bogues**.
 
-Inversement, la vérification formelle peut formellement prouver qu'un contrat intelligent satisfait aux exigences pour une gamme infinie d'exécutions _sans_ exécuter le contrat du tout. Cela nécessite de créer une spécification formelle qui décrit précisément les comportements contractuels corrects et qui développe un modèle formel (mathématique) du système du contrat. Ensuite, nous pouvons suivre une procédure formelle de preuve pour vérifier la cohérence entre le modèle du contrat et ses spécifications.
+Inversement, la vérification formelle peut prouver formellement qu'un contrat intelligent satisfait aux exigences pour une gamme infinie d'exécutions _sans_ exécuter le contrat du tout. Cela nécessite de créer une spécification formelle qui décrit précisément les comportements contractuels corrects et qui développe un modèle formel (mathématique) du système du contrat. Ensuite, nous pouvons suivre une procédure formelle de preuve pour vérifier la cohérence entre le modèle du contrat et ses spécifications.
 
 Avec une vérification formelle, la question de vérifier si la logique commerciale d'un contrat satisfait aux exigences est une proposition mathématique qui peut être prouvée ou infirmée. En prouvant formellement une proposition, nous pouvons vérifier un nombre infini de cas de tests avec un nombre limité d'étapes. De cette manière, la vérification officielle a de meilleures chances de prouver qu'un contrat est fonctionnellement correct en ce qui concerne une spécification.
 
-#### Objectifs de vérification idéaux {#ideal-verification-targets}
+#### Cibles de vérification idéales {#ideal-verification-targets}
 
 Un objectif de vérification décrit le système à vérifier formellement. La vérification formelle est mieux utilisée dans les « systèmes embarqués » (petits logiciels simples qui font partie d'un plus grand système). Ils sont également idéaux pour les domaines spécialisés qui ont peu de règles, car cela facilite la modification d'outils de vérification des propriétés spécifiques au domaine.
 
 Les contrats intelligents, du moins dans une certaine mesure, satisfont aux deux exigences. Par exemple, la petite taille des contrats Ethereum les rend susceptibles de faire l'objet d'une vérification formelle. De même, l'EVM respecte des règles simples, ce qui facilite la spécification et la vérification des propriétés sémantiques des programmes exécutant dans l'EVM.
 
-### Un cycle de développement plus rapide {#faster-development-cycle}
+### Cycle de développement plus rapide {#faster-development-cycle}
 
-Des techniques de vérification formelles, telles que la vérification de modèles et l'exécution symbolique, sont généralement plus efficaces que l'analyse régulière du code du contrat intelligent (effectué pendant les tests ou l'audit). C'est parce que la vérification formelle repose sur des valeurs symboliques pour tester les assertions (« Que se passe-t-il si un utilisateur essaie de retirer _n_ ? ») contrairement aux tests qui utilisent des valeurs concrètes (« que se passe-t-il si un utilisateur essaie de retirer 5 éthers ? »).
+Des techniques de vérification formelles, telles que la vérification de modèles et l'exécution symbolique, sont généralement plus efficaces que l'analyse régulière du code du contrat intelligent (effectué pendant les tests ou l'audit). En effet, la vérification formelle s'appuie sur des valeurs symboliques pour tester les assertions (\ contrairement aux tests qui utilisent des valeurs concrètes (« que se passe-t-il si un utilisateur essaie de retirer 5 éthers ? »).
 
 Les variables d'entrée symbolique peuvent couvrir plusieurs classes de valeurs concrètes, de sorte que les approches de vérification formelle promettent plus de couverture de code dans un laps de temps plus court. Lorsqu'elle est utilisée efficacement, la vérification formelle peut accélérer le cycle de développement pour les développeurs.
 
@@ -190,7 +191,7 @@ La vérification formelle améliore également le processus de construction d'ap
 
 ## Inconvénients de la vérification formelle {#drawbacks-of-formal-verification}
 
-### Coût de la main d'œuvre {#cost-of-manual-labor}
+### Coût de la main-d'œuvre manuelle {#cost-of-manual-labor}
 
 La vérification formelle, en particulier la vérification semi-automatisée, au cours de laquelle un humain guide le démonstrateur pour tirer des preuves d'exactitude, nécessite un travail manuel considérable. En outre, la création de spécifications formelles est une activité complexe qui exige un haut niveau de compétence.
 
@@ -206,65 +207,65 @@ Si les spécifications sont mal écrites, les violations des biens, qui pointent
 
 La vérification formelle rencontre un certain nombre de problèmes de performance. Par exemple, les problèmes d'explosion d'état et de chemin rencontrés lors de la vérification des modèles et de la vérification symbolique peuvent affecter les procédures de vérification. En outre, les outils de vérification formelle utilisent souvent des solutionneurs SMT et d'autres solutionneurs de contraintes dans leur couche sous-jacente, et ces derniers se basent sur des procédures informatiques intensives.
 
-De plus, il n'est pas toujours possible pour les vérificateurs de programme de déterminer si une propriété (décrite comme une formule logique) peut être satisfaite ou non (le « [problème de décidabilité](https://en.wikipedia.org/wiki/Decision_problem)") car un programme ne pourrait jamais se terminer. En tant que tel, il peut être impossible de prouver certaines propriétés d'un contrat même s'il est bien spécifié.
+De plus, il n'est pas toujours possible pour les vérificateurs de programme de déterminer si une propriété (décrite comme une formule logique) peut être satisfaite ou non (le « [problème de la décision](https://en.wikipedia.org/wiki/Decision_problem) ») car un programme pourrait ne jamais se terminer. En tant que tel, il peut être impossible de prouver certaines propriétés d'un contrat même s'il est bien spécifié.
 
-## Outils de vérification formels pour les contrats intelligents Ethereum {#formal-verification-tools}
+## Outils de vérification formelle pour les contrats intelligents Ethereum {#formal-verification-tools}
 
-### Langues de spécification pour la création de spécifications formelles {#specification-languages}
+### Langages de spécification pour la création de spécifications formelles {#specification-languages}
 
-**Act** : _*Act permet de spécifier les mises à jour de stockage, les prérequis et les conditions ultérieures ainsi que les invariants contractuels. Sa suite d'outils a également des backends éprouvés capables de démontrer de nombreuses propriétés via Coq, les solutionneurs SMT, ou hem.**
+**Act** : __Act permet la spécification des mises à jour de stockage, des pré/postconditions et des invariants de contrat. Sa suite d'outils a également des backends éprouvés capables de démontrer de nombreuses propriétés via Coq, les solutionneurs SMT, ou hem.__
 
 - [GitHub](https://github.com/ethereum/act)
-- [Documentation](https://ethereum.github.io/act/)
+- [Documentation](https://github.com/argotorg/act)
 
-**Scribble** - _*Scribble transforme des annotations de code dans le langage de spécification Scribble en assertions concrètes qui vérifient la spécification.**
+**Scribble** - __Scribble transforme les annotations de code dans le langage de spécification Scribble en assertions concrètes qui vérifient la spécification.__
 
 - [Documentation](https://docs.scribble.codes/)
 
-**Dafny** - _*Dafny est un langage de programmation prêt à la vérification qui repose sur des annotations de haut niveau pour raisonner et prouver la justesse du code.**
+**Dafny** - __Dafny est un langage de programmation prêt pour la vérification qui s'appuie sur des annotations de haut niveau pour raisonner sur le code et en prouver l'exactitude.__
 
 - [GitHub](https://github.com/dafny-lang/dafny)
 
-### Vérificateurs de programme pour vérifier la justesse {#program-verifiers}
+### Vérificateurs de programme pour contrôler l'exactitude {#program-verifiers}
 
-**Certora Prouver** - _Certora Prouver est un outil de vérification formelle automatique pour vérifier la justesse du code dans les contrats intelligents. Les spécifications sont écrites en CVL (Certora Verification Language), avec des violations de propriétés détectées à l'aide d'une combinaison d'analyse statique et de résolution de contraintes._
+**Certora Prover** - _Certora Prover est un outil de vérification formelle automatique pour vérifier l'exactitude du code dans les contrats intelligents. Les spécifications sont écrites en CVL (Certora Verification Language), avec des violations de propriétés détectées à l'aide d'une combinaison d'analyse statique et de résolution de contraintes._
 
 - [Site Web](https://www.certora.com/)
 - [Documentation](https://docs.certora.com/en/latest/index.html)
 
-**Solidity SMTChecker** - _*SMTChecker de Solidity est un vérificateur de modèle intégré basé sur SMT ( Satisfiability Modulo Théories) et résolution d'Horn. Il confirme si le code source d'un contrat correspond aux spécifications lors de la compilation et vérifie statiquement les violations des propriétés de sécurité.**
+**Solidity SMTChecker** - __Le SMTChecker de Solidity est un vérificateur de modèle intégré basé sur SMT (Satisfiability Modulo Theories) et la résolution de Horn. Il confirme si le code source d'un contrat correspond aux spécifications lors de la compilation et vérifie statiquement les violations des propriétés de sécurité.__
 
 - [GitHub](https://github.com/ethereum/solidity)
 
-**solc-verify** - _*solc-verify est une version étendue du compilateur Solidity qui peut effectuer une vérification formelle automatisée sur le code Solidity à l'aide d'annotations et de vérification de programme modulaire.**
+**solc-verify** - __solc-verify est une version étendue du compilateur Solidity qui peut effectuer une vérification formelle automatisée sur le code Solidity à l'aide d'annotations et de la vérification modulaire de programme.__
 
 - [GitHub](https://github.com/SRI-CSL/solidity)
 
-**KEVM** - _*KEVM est une sémantique formelle de la machine virtuelle (EVM) Ethereum écrite dans le cadre K. KEVM est exécutable et peut prouver certaines assertions liées à la propriété en utilisant la logique d'accessibilité.**
+**KEVM** - __KEVM est une sémantique formelle de la machine virtuelle Ethereum (EVM) écrite dans le framework K. KEVM est exécutable et peut prouver certaines assertions liées à la propriété en utilisant la logique d'accessibilité.__
 
 - [GitHub](https://github.com/runtimeverification/evm-semantics)
 - [Documentation](https://jellopaper.org/)
 
-### Cadres logiques pour la démonstration du théorème {#theorem-provers}
+### Cadres logiques pour la démonstration de théorèmes {#theorem-provers}
 
 **Isabelle** - _Isabelle/HOL est un assistant de preuve qui permet d'exprimer des formules mathématiques dans un langage formel et fournit des outils pour prouver ces formules. L'application principale est la formalisation de preuves mathématiques et en particulier la vérification formelle, qui comprennent la preuve de la justesse du matériel ou des logiciels informatiques et la preuve des propriétés des langages et protocoles informatiques._
 
 - [GitHub](https://github.com/isabelle-prover)
 - [Documentation](https://isabelle.in.tum.de/documentation.html)
 
-**Coq** - _Coq est un démonstrateur de théorème interactif qui vous permet de définir des programmes en utilisant des théorèmes et de générer interactivement des preuves de correction vérifiées par la machine._
+**Rocq** - _Rocq est un démonstrateur de théorème interactif qui vous permet de définir des programmes en utilisant des théorèmes et de générer interactivement des preuves de correction vérifiées par machine._
 
-- [GitHub](https://github.com/coq/coq)
-- [Documentation](https://coq.github.io/doc/v8.13/refman/index.html)
+- [GitHub](https://github.com/rocq-prover/rocq)
+- [Documentation](https://rocq-prover.org/docs)
 
-### Outils basés sur l'exécution symbolique pour détecter les modèles vulnérables dans les contrats intelligents {#symbolic-execution-tools}
+### Outils basés sur l'exécution symbolique pour la détection de modèles vulnérables dans les contrats intelligents {#symbolic-execution-tools}
 
-**Manticore** - _*Un outil d'analyse de bytecode EVM basé sur l'exécution symbolique*.*
+**Manticore** - __Un outil d'analyse du bytecode de l'EVM basé sur l'exécution symbolique.__
 
 - [GitHub](https://github.com/trailofbits/manticore)
 - [Documentation](https://github.com/trailofbits/manticore/wiki)
 
-**hevm** - _*hevm est un moteur d'exécution symbolique et vérificateur d'équivalence pour le bytecode EVM.**
+**hevm** - __hevm est un moteur d'exécution symbolique et un vérificateur d'équivalence pour le bytecode de l'EVM.__
 
 - [GitHub](https://github.com/dapphub/dapptools/tree/master/src/hevm)
 
@@ -275,9 +276,9 @@ De plus, il n'est pas toujours possible pour les vérificateurs de programme de
 
 ## En savoir plus {#further-reading}
 
-- [Comment fonctionne la vérification formelle des contrats intelligents](https://runtimeverification.com/blog/how-formal-verification-of-smart-contracts-works/)
-- [Comment la vérification formelle peut assurer des contrats intelligents parfaits](https://media.consensys.net/how-formal-verification-can-ensure-flawless-smart-contracts-cbda8ad99bd1)
-- [Aperçu des projets de vérification formelle dans l'écosystème Ethereum](https://github.com/leonardoalt/ethereum_formal_verification_overview)
-- [Vérification formelle du dépôt Ethereum 2.0 de bout en bout Contrat intelligent](https://runtimeverification.com/blog/end-to-end-formal-verification-of-ethereum-2-0-deposit-smart-contract/)
-- [Vérification formelle du contrat intelligent le plus populaire au monde](https://www.zellic.io/blog/formal-verification-weth)
+- [Fonctionnement de la vérification formelle des contrats intelligents](https://runtimeverification.com/blog/how-formal-verification-of-smart-contracts-works/)
+- [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)
+- [Un aperçu des projets de vérification formelle dans l'écosystème Ethereum](https://github.com/leonardoalt/ethereum_formal_verification_overview)
+- [Vérification formelle de bout en bout du contrat intelligent de dépôt d'Ethereum 2.0](https://runtimeverification.com/blog/end-to-end-formal-verification-of-ethereum-2-0-deposit-smart-contract/)
+- [Vérifier formellement le contrat intelligent le plus populaire au monde](https://www.zellic.io/blog/formal-verification-weth)
 - [SMTChecker et vérification formelle](https://docs.soliditylang.org/en/v0.8.15/smtchecker.html)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/index.md b/public/content/translations/fr/developers/docs/smart-contracts/index.md
index 025a206d5f9..40303c68f71 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/index.md
@@ -1,24 +1,24 @@
 ---
 title: Introduction aux contrats intelligents
-description: Présentation des contrats intelligents, axée sur leurs caractéristiques uniques et leurs limites
+description: "Présentation des contrats intelligents, axée sur leurs caractéristiques uniques et leurs limites"
 lang: fr
 ---
 
-## Qu'est-ce qu'un contrat intelligent ? {#what-is-a-smart-contract}
+## Qu'est-ce qu'un contrat intelligent ? Qu'est-ce qu'un contrat intelligent ? {#what-is-a-smart-contract}
 
 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/). 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.
+Les contrats intelligents sont 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}
 
 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/).
 
-Assurez-vous d'avoir lu les pages [Contrats](/developers/docs/accounts/), [Transactions](/developers/docs/transactions/) et [Machine virtuelle Ethereum](/developers/docs/evm/) avant de vous lancer dans le monde des contrats intelligents.
+Assurez-vous d'avoir lu les articles sur les [comptes](/developers/docs/accounts/), les [transactions](/developers/docs/transactions/) et la [machine virtuelle Ethereum](/developers/docs/evm/) avant de vous lancer dans le monde des contrats intelligents.
 
-## Distributeur automatique numérique {#a-digital-vending-machine}
+## Un distributeur automatique numérique {#a-digital-vending-machine}
 
-La meilleure métaphore pour décrire un contrat intelligent est peut-être celle d'un distributeur automatique, tel que décrit par [Nick Szabo](https://unenumerated.blogspot.com/). Avec les bonnes entrées, une certaine sortie est garantie.
+La meilleure métaphore pour un contrat intelligent est peut-être celle d'un distributeur automatique, comme le décrit [Nick Szabo](https://unenumerated.blogspot.com/). Avec les bonnes entrées, une certaine sortie est garantie.
 
 Pour obtenir une sucrerie d'un distributeur automatique :
 
@@ -35,28 +35,28 @@ pragma solidity 0.8.7;
 
 contract VendingMachine {
 
-    // Declare state variables of the contract
+    // Déclarer les variables d'état du contrat
     address public owner;
     mapping (address => uint) public cupcakeBalances;
 
-    // When 'VendingMachine' contract is deployed:
-    // 1. set the deploying address as the owner of the contract
-    // 2. set the deployed smart contract's cupcake balance to 100
+    // Lorsque le contrat 'VendingMachine' est déployé :
+    // 1. définir l'adresse de déploiement comme propriétaire du contrat
+    // 2. définir le solde de cupcakes du contrat intelligent déployé à 100
     constructor() {
         owner = msg.sender;
         cupcakeBalances[address(this)] = 100;
     }
 
-    // Allow the owner to increase the smart contract's cupcake balance
+    // Permettre au propriétaire d'augmenter le solde de cupcakes du contrat intelligent
     function refill(uint amount) public {
-        require(msg.sender == owner, "Only the owner can refill.");
+        require(msg.sender == owner, "Seul le propriétaire peut réapprovisionner.");
         cupcakeBalances[address(this)] += amount;
     }
 
-    // Allow anyone to purchase cupcakes
+    // Permettre à n'importe qui d'acheter des cupcakes
     function purchase(uint amount) public payable {
-        require(msg.value >= amount * 1 ether, "You must pay at least 1 ETH per cupcake");
-        require(cupcakeBalances[address(this)] >= amount, "Not enough cupcakes in stock to complete this purchase");
+        require(msg.value >= amount * 1 ether, "Vous devez payer au moins 1 ETH par cupcake");
+        require(cupcakeBalances[address(this)] >= amount, "Pas assez de cupcakes en stock pour finaliser cet achat");
         cupcakeBalances[address(this)] -= amount;
         cupcakeBalances[msg.sender] += amount;
     }
@@ -65,18 +65,18 @@ contract VendingMachine {
 
 Tout comme un distributeur automatique peut remplacer un employé dans une boutique, les contrats intelligents peuvent remplacer les intermédiaires dans bon nombre d'industries.
 
-## Sans autorisation {#permissionless}
+## Sans permission {#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 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.
+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 déploiement d'un contrat intelligent est une transaction, vous devez donc payer du [gaz](/developers/docs/gas/) de la même manière que 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 :
 
-- Solidity
+- solidity
 - Vyper
 
-[Plus d'infos sur les langages](/developers/docs/smart-contracts/languages/)
+[En savoir plus sur les langages](/developers/docs/smart-contracts/languages/)
 
-Toutefois, pour que la machine virtuelle Ethereum puisse interpréter et stocker un contrat, il doit être compilé avant d'être déployé. [Plus d'infos sur la compilation](/developers/docs/smart-contracts/compiling/)
+Toutefois, pour que la machine virtuelle Ethereum puisse interpréter et stocker un contrat, il doit être compilé avant d'être déployé. [En savoir plus sur la compilation](/developers/docs/smart-contracts/compiling/)
 
 ## Composabilité {#composability}
 
@@ -88,25 +88,25 @@ En savoir plus sur la [composabilité des contrats intelligents](/developers/doc
 
 Les contrats intelligents seuls ne peuvent pas obtenir d'informations sur les événements du "monde réel", dans la mesure où ils ne peuvent pas récupérer de données depuis des sources hors chaîne. Cela signifie qu'ils ne peuvent pas réagir aux événements du monde réel. C'est un choix délibéré. Le fait de s'appuyer sur des informations externes pourrait compromettre le consensus, qui est essentiel en matière de sécurité et de décentralisation.
 
-Il est toutefois important que les applications de la blockchain puissent utiliser des données hors chaîne. Pour ce faire, il est possible d'utiliser des [oracles](/developers/docs/oracles/), des outils capables d'ingérer des données hors chaîne et de les mettre à la disposition des contrats intelligents.
+Il est toutefois important que les applications de la blockchain puissent utiliser des données hors chaîne. La solution réside dans les [oracles](/developers/docs/oracles/), des outils qui ingèrent des données hors chaîne et les mettent à la disposition des contrats intelligents.
 
-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).
+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. Il est possible de contourner ce problème en utilisant [le Diamond Pattern](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é.
+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. Les contrats multisig requièrent N signatures parmi M signatures possibles et acceptables (où N ≤ M et M > 1) pour s'exécuter. `N = 3, M = 5` et `N = 4, M = 7` sont couramment utilisés. 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}
+## Ressources sur les contrats intelligents {#smart-contract-resources}
 
-**Contrats OpenZeppelin -** **_Bibliothèque pour développer des contrats intelligents de façon sécurisée_**
+**Contrats OpenZeppelin -** **_Bibliothèque pour le développement sécurisé de contrats intelligents._**
 
 - [openzeppelin.com/contracts/](https://openzeppelin.com/contracts/)
 - [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts)
-- [Forum communautaire](https://forum.openzeppelin.com/c/general/16)
+- [Forum de la communauté](https://forum.openzeppelin.com/c/general/16)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Coinbase : Qu'est-ce qu'un contrat intelligent ?](https://www.coinbase.com/learn/crypto-basics/what-is-a-smart-contract)
-- [Chainlink : Qu'est-ce qu'un contrat intelligent ?](https://chain.link/education/smart-contracts)
-- [Vidéo : Expliqués Simplement - Les Contrats Intelligents](https://youtu.be/ZE2HxTmxfrI)
-- [Cyfrin Updraft : plateforme d'apprentissage et d'audit Web3](https://updraft.cyfrin.io)
+- [Coinbase : Qu'est-ce qu'un contrat intelligent ?](https://www.coinbase.com/learn/crypto-basics/what-is-a-smart-contract)
+- [Chainlink : Qu'est-ce qu'un contrat intelligent ?](https://chain.link/education/smart-contracts)
+- [Vidéo : Simply Explained - Smart Contracts](https://youtu.be/ZE2HxTmxfrI)
+- [Cyfrin Updraft : Plateforme d'apprentissage et d'audit Web3](https://updraft.cyfrin.io)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/languages/index.md b/public/content/translations/fr/developers/docs/smart-contracts/languages/index.md
index b31a6b37082..0bcc501c15d 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/languages/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/languages/index.md
@@ -1,25 +1,25 @@
 ---
 title: Les langages des contrats intelligents
-description: 'Présentation et comparaison des deux principaux langages de contrat intelligent : Solidity et Vyper'
+description: "Présentation et comparaison des deux principaux langages de contrat intelligent : Solidity et Vyper"
 lang: fr
 ---
 
-Un aspect important d'Ethereum est que les contrats intelligents peuvent être programmés en utilisant des langages relativement conviviaux pour les développeurs. Si vous maitrisez Python ou n'importe quel [langage d'accolades](https://wikipedia.org/wiki/List_of_programming_languages_by_type#Curly-bracket_languages), vous pouvez trouver un langage avec une syntaxe qui vous sera familière.
+Un aspect important d'Ethereum est que les contrats intelligents peuvent être programmés en utilisant des langages relativement conviviaux pour les développeurs. Si vous avez de l'expérience avec Python ou tout [langage à accolades](https://wikipedia.org/wiki/List_of_programming_languages_by_type#Curly-bracket_languages), vous pouvez trouver un langage avec une syntaxe familière.
 
 Les deux langages les plus actifs et les plus suivis sont :
 
-- Solidity
+- solidity
 - Vyper
 
 L'IDE Remix fournit un environnement de développement complet pour créer et tester des contrats dans Solidity et Vyper. [Essayez l'IDE Remix dans le navigateur](https://remix.ethereum.org) pour commencer à coder.
 
-Des développeurs plus expérimentés peuvent choisir d'utiliser Yul, un langage intermédiaire pour la [machine virtuelle Ethereum (EVM)](/developers/docs/evm/), ou Yul+, une extension de Yul.
+Les développeurs plus expérimentés peuvent également utiliser Yul, un langage intermédiaire pour la [machine virtuelle Ethereum](/developers/docs/evm/), ou Yul+, une extension de Yul.
 
 Si vous êtes curieux et que vous aimez aider à tester de nouveaux langages encore en cours de développement, vous pouvez essayer Fe, un nouveau langage pour contrat intelligent qui en est encore à ses balbutiements.
 
 ## Prérequis {#prerequisites}
 
-La connaissance de langages de programmation comme JavaScript ou Python peut vous aider à comprendre les différences entre les langages de contrats intelligents. Nous vous conseillons également d'avoir compris le concept des contrats intelligents avant de vous plonger dans les comparaisons entre les différents langages. Lire la page [Introduction aux contrats intelligents](/developers/docs/smart-contracts/)
+La connaissance de langages de programmation comme JavaScript ou Python peut vous aider à comprendre les différences entre les langages de contrats intelligents. Nous vous conseillons également d'avoir compris le concept des contrats intelligents avant de vous plonger dans les comparaisons entre les différents langages. [Introduction aux contrats intelligents](/developers/docs/smart-contracts/).
 
 ## Solidity {#solidity}
 
@@ -34,13 +34,13 @@ La connaissance de langages de programmation comme JavaScript ou Python peut vou
 ### Liens importants {#important-links}
 
 - [Documentation](https://docs.soliditylang.org/en/latest/)
-- [Portail Solidity](https://soliditylang.org/)
+- [Portail du langage Solidity](https://soliditylang.org/)
 - [Solidity by Example](https://docs.soliditylang.org/en/latest/solidity-by-example.html)
 - [GitHub](https://github.com/ethereum/solidity/)
-- [Salle de chat Gitter Solidity](https://gitter.im/ethereum/solidity) reliée à [Salle de chat Matrix Solidity](https://matrix.to/#/#ethereum_solidity:gitter.im)
-- [Cheat Sheet](https://reference.auditless.com/cheatsheet)
+- [Salon de discussion Gitter de Solidity](https://gitter.im/ethereum/solidity) ponté vers le [salon de discussion Matrix de Solidity](https://matrix.to/#/#ethereum_solidity:gitter.im)
+- [Aide-mémoire](https://reference.auditless.com/cheatsheet)
 - [Blog Solidity](https://blog.soliditylang.org/)
-- [Twitter Solidity](https://twitter.com/solidity_lang)
+- [Twitter de Solidity](https://twitter.com/solidity_lang)
 
 ### Exemple de contrat {#example-contract}
 
@@ -49,33 +49,33 @@ La connaissance de langages de programmation comme JavaScript ou Python peut vou
 pragma solidity >= 0.7.0;
 
 contract Coin {
-    // The keyword "public" makes variables
-    // accessible from other contracts
+    // Le mot-clé « public » rend les variables
+    // accessibles depuis d'autres contrats
     address public minter;
     mapping (address => uint) public balances;
 
-    // Events allow clients to react to specific
-    // contract changes you declare
+    // Les événements permettent aux clients de réagir aux modifications spécifiques
+    // du contrat que vous déclarez
     event Sent(address from, address to, uint amount);
 
-    // Constructor code is only run when the contract
-    // is created
+    // Le code du constructeur n'est exécuté que lors de la création
+    // du contrat
     constructor() {
         minter = msg.sender;
     }
 
-    // Sends an amount of newly created coins to an address
-    // Can only be called by the contract creator
+    // Envoie un montant de pièces nouvellement créées à une adresse
+    // Ne peut être appelé que par le créateur du contrat
     function mint(address receiver, uint amount) public {
         require(msg.sender == minter);
         require(amount < 1e60);
         balances[receiver] += amount;
     }
 
-    // Sends an amount of existing coins
-    // from any caller to an address
+    // Envoie un montant de pièces existantes
+    // depuis n'importe quel appelant vers une adresse
     function send(address receiver, uint amount) public {
-        require(amount <= balances[msg.sender], "Insufficient balance.");
+        require(amount <= balances[msg.sender], "Solde insuffisant.");
         balances[msg.sender] -= amount;
         balances[receiver] += amount;
         emit Sent(msg.sender, receiver, amount);
@@ -101,103 +101,121 @@ Cet exemple devrait vous donner une idée de la syntaxe d'un contrat Solidity. P
   - Boucles infinies
   - Points fixes binaires
 
-Pour plus d'informations, [lisez cette page Vyper](https://vyper.readthedocs.io/en/latest/index.html).
+Pour plus d'informations, [lisez la raison d'être de Vyper](https://vyper.readthedocs.io/en/latest/index.html).
 
 ### Liens importants {#important-links-1}
 
 - [Documentation](https://vyper.readthedocs.io)
-- [Vyper par exemple](https://vyper.readthedocs.io/en/latest/vyper-by-example.html)
-- [Plus de Vyper par exemple](https://vyper-by-example.org/)
+- [Vyper by Example](https://vyper.readthedocs.io/en/latest/vyper-by-example.html)
+- [More Vyper by Example](https://vyper-by-example.org/)
 - [GitHub](https://github.com/vyperlang/vyper)
-- [Discussion Discord pour la Communauté Vyper](https://discord.gg/SdvKC79cJk)
-- [Cheat Sheet](https://reference.auditless.com/cheatsheet)
-- [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)
+- [Chat Discord de la communauté Vyper](https://discord.gg/SdvKC79cJk)
+- [Aide-mémoire](https://reference.auditless.com/cheatsheet)
+- [Cadres de développement et outils pour les contrats intelligents pour Vyper](/developers/docs/programming-languages/python/)
+- [VyperPunk – apprenez à sécuriser et à pirater les contrats intelligents Vyper](https://github.com/SupremacyTeam/VyperPunk)
 - [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)
+- [Exemples de contrats intelligents Vyper greatest hits](https://github.com/pynchmeister/vyper-greatest-hits/tree/main/contracts)
+- [Awesome Vyper – ressources sélectionnées](https://github.com/spadebuilders/awesome-vyper)
 
 ### Exemple {#example}
 
 ```python
-# Open Auction
+# Enchère ouverte
+
+# Paramètres de l'enchère
+
+# Le bénéficiaire reçoit l'argent du plus offrant
 
-# Auction params
-# Beneficiary receives money from the highest bidder
 beneficiary: public(address)
 auctionStart: public(uint256)
 auctionEnd: public(uint256)
 
-# Current state of auction
+# État actuel de l'enchère
+
 highestBidder: public(address)
 highestBid: public(uint256)
 
-# Set to true at the end, disallows any change
+# Mis à « true » à la fin, interdit toute modification
+
 ended: public(bool)
 
-# Keep track of refunded bids so we can follow the withdraw pattern
+# Suivi des enchères remboursées afin que nous puissions suivre le modèle de retrait
+
 pendingReturns: public(HashMap[address, uint256])
 
-# Create a simple auction with `_bidding_time`
-# seconds bidding time on behalf of the
-# beneficiary address `_beneficiary`.
+# Crée une enchère simple avec un temps d'enchère de `_bidding_time`
+
+# secondes pour le compte de
+
+# l'adresse du bénéficiaire `_beneficiary`.
+
 @external
 def __init__(_beneficiary: address, _bidding_time: uint256):
     self.beneficiary = _beneficiary
     self.auctionStart = block.timestamp
     self.auctionEnd = self.auctionStart + _bidding_time
 
-# Bid on the auction with the value sent
-# together with this transaction.
-# The value will only be refunded if the
-# auction is not won.
+# Enchérir sur l'enchère avec la valeur envoyée
+
+# avec cette transaction.
+
+# La valeur ne sera remboursée que si
+
+# l'enchère n'est pas remportée.
+
 @external
 @payable
 def bid():
-    # Check if bidding period is over.
+    # Vérifie si la période d'enchères est terminée.
     assert block.timestamp < self.auctionEnd
-    # Check if bid is high enough
+    # Vérifie si l'enchère est suffisamment élevée
     assert msg.value > self.highestBid
-    # Track the refund for the previous high bidder
+    # Suivi du remboursement de l'enchérisseur le plus élevé précédent
     self.pendingReturns[self.highestBidder] += self.highestBid
-    # Track new high bid
+    # Suivi de la nouvelle enchère la plus élevée
     self.highestBidder = msg.sender
     self.highestBid = msg.value
 
-# Withdraw a previously refunded bid. The withdraw pattern is
-# used here to avoid a security issue. If refunds were directly
-# sent as part of bid(), a malicious bidding contract could block
-# those refunds and thus block new higher bids from coming in.
+# Retirer une enchère précédemment remboursée. Le modèle de retrait est
+
+# utilisé ici pour éviter un problème de sécurité. Si les remboursements étaient directement
+
+# envoyés dans le cadre de bid(), un contrat d'enchères malveillant pourrait bloquer
+
+# ces remboursements et ainsi empêcher l'arrivée de nouvelles enchères plus élevées.
+
 @external
 def withdraw():
     pending_amount: uint256 = self.pendingReturns[msg.sender]
     self.pendingReturns[msg.sender] = 0
     send(msg.sender, pending_amount)
 
-# End the auction and send the highest bid
-# to the beneficiary.
+# Met fin à l'enchère et envoie l'enchère la plus élevée
+
+# au bénéficiaire.
+
 @external
 def endAuction():
-    # It is a good guideline to structure functions that interact
-    # with other contracts (i.e., they call functions or send ether)
-    # into three phases:
-    # 1. checking conditions
-    # 2. performing actions (potentially changing conditions)
-    # 3. interacting with other contracts
-    # If these phases are mixed up, the other contract could call
-    # back into the current contract and modify the state or cause
-    # effects (ether payout) to be performed multiple times.
-    # If functions called internally include interaction with external
-    # contracts, they also have to be considered interaction with
-    # external contracts.
+    # Il est recommandé de structurer les fonctions qui interagissent
+    # avec d'autres contrats (c'est-à-dire qu'elles appellent des fonctions ou envoient de l'ether)
+    # en trois phases :
+    # 1. vérification des conditions
+    # 2. exécution d'actions (pouvant modifier les conditions)
+    # 3. interaction avec d'autres contrats
+    # Si ces phases sont mélangées, l'autre contrat pourrait rappeler
+    # le contrat actuel et modifier l'état ou provoquer
+    # des effets (paiement d'ether) à effectuer plusieurs fois.
+    # Si les fonctions appelées en interne incluent une interaction avec des contrats
+    # externes, elles doivent également être considérées comme une interaction avec des
+    # contrats externes.
 
     # 1. Conditions
-    # Check if auction endtime has been reached
+    # Vérifie si l'heure de fin de l'enchère a été atteinte
     assert block.timestamp >= self.auctionEnd
-    # Check if this function has already been called
+    # Vérifie si cette fonction a déjà été appelée
     assert not self.ended
 
-    # 2. Effects
+    # 2. Effets
     self.ended = True
 
     # 3. Interaction
@@ -213,24 +231,24 @@ Si vous débutez avec Ethereum et que vous n'avez pas encore jamais codé avec d
 **Yul**
 
 - 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.
+- Prend en charge l'[EVM](/developers/docs/evm) et l'[Ewasm](https://github.com/ewasm), un WebAssembly aux couleurs d'Ethereum, et est conçu pour être un dénominateur commun utilisable des deux plateformes.
+- Bonne cible pour les étapes d'optimisation de haut niveau qui peuvent bénéficier de la même manière aux plateformes EVM et Ewasm.
 
 **Yul+**
 
 - Extension de Yul de bas niveau très efficace
-- Initialement conçue pour un contrat de [rollup optimiste](/developers/docs/scaling/optimistic-rollups/).
+- Initialement conçu pour un contrat de [rollup optimiste](/developers/docs/scaling/optimistic-rollups/).
 - Yul+ peut être considéré comme une proposition de mise à niveau expérimentale de Yul, qui y ajoute de nouvelles fonctionnalités
 
 ### Liens importants {#important-links-2}
 
-- [Documentation Yul](https://docs.soliditylang.org/en/latest/yul.html)
-- [Documentation Yul+](https://github.com/fuellabs/yulp)
+- [Documentation de Yul](https://docs.soliditylang.org/en/latest/yul.html)
+- [Documentation de Yul+](https://github.com/fuellabs/yulp)
 - [Article d'introduction à Yul+](https://medium.com/@fuellabs/introducing-yul-a-new-low-level-language-for-ethereum-aa64ce89512f)
 
 ### Exemple de contrat {#example-contract-2}
 
-Cet exemple simple implémente une fonction puissance. Il peut être compilé en utilisant `solc --strict-assembly --bin input.yul` et devrait être stocké dans le fichier input.yul.
+Cet exemple simple implémente une fonction puissance. Il peut être compilé en utilisant `solc --strict-assembly --bin input.yul`. et devrait être stocké dans le fichier input.yul.
 
 ```
 {
@@ -251,7 +269,7 @@ Cet exemple simple implémente une fonction puissance. Il peut être compilé en
 }
 ```
 
-Si vous avez déjà une bonne expérience en développement de contrats intelligents, vous trouverez ici une [implémentation complète ERC20 dans Yul](https://solidity.readthedocs.io/en/latest/yul.html#complete-erc20-example).
+Si vous avez déjà une bonne expérience des contrats intelligents, une implémentation complète d'ERC20 dans Yul peut être trouvée [ici](https://solidity.readthedocs.io/en/latest/yul.html#complete-erc20-example).
 
 ## Fe {#fe}
 
@@ -264,9 +282,9 @@ Si vous avez déjà une bonne expérience en développement de contrats intellig
 
 - [GitHub](https://github.com/ethereum/fe)
 - [Annonce de Fe](https://snakecharmers.ethereum.org/fe-a-new-language-for-the-ethereum-ecosystem/)
-- [Feuille de route 2021 pour Fe](https://notes.ethereum.org/LVhaTF30SJOpkbG1iVw1jg)
-- [Chat de discussion Fe](https://discord.com/invite/ywpkAXFjZH)
-- [Twitter Fe](https://twitter.com/official_fe)
+- [Feuille de route 2021 de Fe](https://notes.ethereum.org/LVhaTF30SJOpkbG1iVw1jg)
+- [Chat Discord de Fe](https://discord.com/invite/ywpkAXFjZH)
+- [Twitter de Fe](https://twitter.com/official_fe)
 
 ### Exemple de contrat {#example-contract-3}
 
@@ -297,28 +315,28 @@ Comme pour tout autre langage de programmation, il s'agit surtout de choisir le
 
 Voici quelques éléments à considérer si vous n'en avez encore essayé :
 
-### Quels sont les avantages de Solidity ? {#solidity-advantages}
+### Quels sont les avantages de Solidity ? Avantages de Solidity {#solidity-advantages}
 
-- Si vous débutez, il existe de nombreux tutoriels et outils d'apprentissage. Pour plus d'infos, consultez la page [Apprendre en codant](/developers/learning-tools/).
+- Si vous débutez, il existe de nombreux tutoriels et outils d'apprentissage. Pour en savoir plus, consultez la section [Apprendre en codant](/developers/learning-tools/).
 - De bons outils de développement sont disponibles.
 - Solidity dispose d'une importante communauté de développeurs, ce qui signifie que vous obtiendrez probablement des réponses à vos questions très rapidement.
 
-### Quels sont les avantages de Vyper ? {#vyper-advatages}
+### Quels sont les avantages de Vyper ? Avantages de Vyper {#vyper-advatages}
 
 - Excellent moyen de commencer pour les développeurs Python qui veulent rédiger des contrats intelligents.
 - Vyper dispose d'un nombre plus restreint de fonctionnalités, ce qui en fait un langage idéal pour un prototypage rapide des idées.
 - Il est conçu de façon à être facile à contrôler et extrêmement lisible pour l'être humain.
 
-### Quels sont les avantages de Yul et Yul+ ? {#yul-advantages}
+### Quels sont les avantages de Yul et Yul+ ? Avantages de Yul {#yul-advantages}
 
 - Language simple et fonctionnel de bas niveau.
 - Permet de se rapprocher au plus près de l'EVM brute, ce qui peut aider à optimiser l'utilisation du gaz de vos contrats.
 
-## Comparaison des langages {#language-comparisons}
+## Comparaisons des langages {#language-comparisons}
 
-Pour des comparaisons de la syntaxe de base, du cycle de vie des contrats, des interfaces, des opérateurs, des structures de données, des fonctions, du flux de contrôle, et plus encore, consultez la page Auditless [ Solidity & Vyper Cheat Sheet](https://reference.auditless.com/cheatsheet/)
+Pour des comparaisons de la syntaxe de base, du cycle de vie du contrat, des interfaces, des opérateurs, des structures de données, des fonctions, du flux de contrôle et plus encore, consultez cet [aide-mémoire d'Auditless](https://reference.auditless.com/cheatsheet/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [Bibliothèque de contrats Solidity par OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/)
 - [Solidity by Example](https://solidity-by-example.org)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/libraries/index.md b/public/content/translations/fr/developers/docs/smart-contracts/libraries/index.md
index 52c9cd3084d..7e955c9e131 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/libraries/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/libraries/index.md
@@ -1,6 +1,6 @@
 ---
-title: Bibliothèques de contrats intelligents
-description:
+title: "Bibliothèques de contrats intelligents"
+description: Discover reusable smart contract libraries and building blocks to accelerate your Ethereum development projects.
 lang: fr
 ---
 
@@ -8,19 +8,19 @@ Vous n'avez pas besoin de rédiger tous les contrats intelligents de votre proje
 
 ## Prérequis {#prerequisites}
 
-Avant de vous intéresser aux bibliothèques de contrats intelligents, nous vous conseillons d'avoir bien compris en quoi consiste la structure d'un contrat intelligent. Lisez la page [Anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/) si vous ne l'avez pas déjà fait.
+Avant de vous intéresser aux bibliothèques de contrats intelligents, nous vous conseillons d'avoir bien compris en quoi consiste la structure d'un contrat intelligent. Consultez la page sur [l'anatomie d'un contrat intelligent](/developers/docs/smart-contracts/anatomy/) si vous ne l'avez pas encore fait.
 
-## En quoi consiste une bibliothèque ? {#whats-in-a-library}
+## Que contient une bibliothèque {#whats-in-a-library}
 
 Vous pouvez généralement trouver deux types de blocs de construction dans les bibliothèques de contrats intelligents : des comportements réutilisables que vous pouvez ajouter à vos contrats, et des implémentations de diverses normes.
 
 ### Comportements {#behaviors}
 
-Lorsque vous rédigez des contrats intelligents, il y a de grandes chances que vous vous retrouviez à réécrire indéfiniment des modèles similaires, comme assigner une adresse _admin_ pour effectuer des opérations protégées, ou ajouter un bouton d'urgence _pause_ pour répondre aux problèmes inattendus.
+Lorsque vous écrivez des contrats intelligents, il y a de fortes chances que vous vous retrouviez à écrire des modèles similaires à plusieurs reprises, comme l'attribution d'une adresse _admin_ pour effectuer des opérations protégées dans un contrat, ou l'ajout d'un bouton de _pause_ d'urgence en cas de problème inattendu.
 
 Les bibliothèques de contrats intelligents fournissent généralement des implémentations réutilisables de ces comportements sous forme de [bibliothèques](https://solidity.readthedocs.io/en/v0.7.2/contracts.html#libraries) ou via l'[héritage](https://solidity.readthedocs.io/en/v0.7.2/contracts.html#inheritance) dans Solidity.
 
-À titre d'exemple, vous trouverez ci-dessous une version simplifiée du contrat [`Ownable`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.2.0/contracts/access/Ownable.sol) de la [bibliothèque de contrats OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts), qui conçoit une adresse en tant que propriétaire d'un contrat, et fournit un modificateur pour restreindre l'accès à une méthode uniquement à ce propriétaire.
+À titre d'exemple, voici une version simplifiée du contrat [`Ownable`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.2.0/contracts/access/Ownable.sol) de la [bibliothèque de contrats OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts), qui désigne une adresse comme propriétaire d'un contrat, et fournit un modificateur pour restreindre l'accès à une méthode uniquement à ce propriétaire.
 
 ```solidity
 contract Ownable {
@@ -37,7 +37,7 @@ contract Ownable {
 }
 ```
 
-Pour utiliser un bloc de construction comme celui-ci dans votre contrat, vous devrez d'abord l'importer, puis l'étendre dans vos propres contrats. Cela vous permettra d'utiliser le modificateur fourni par le contrat `Ownable` de base pour sécuriser vos propres fonctions.
+Pour utiliser un bloc de construction comme celui-ci dans votre contrat, vous devrez d'abord l'importer, puis l'étendre dans vos propres contrats. Cela vous permettra d'utiliser le modificateur fourni par le contrat de base `Ownable` pour sécuriser vos propres fonctions.
 
 ```solidity
 import ".../Ownable.sol"; // Path to the imported library
@@ -50,19 +50,19 @@ contract MyContract is Ownable {
 }
 ```
 
-Autres exemples populaires : [SafeMath](https://docs.openzeppelin.com/contracts/3.x/utilities#math) ou [DsMath](https://dappsys.readthedocs.io/en/latest/ds_math.html). Ce sont des bibliothèques (par opposition aux contrats de base) qui fournissent des fonctions arithmétiques avec des vérifications de dépassement qui ne sont pas fournies par le langage. Une bonne pratique consiste à utiliser l'une de ces bibliothèques au lieu d'opérations arithmétiques natives pour protéger votre contrat contre les dépassements, qui peuvent avoir des conséquences désastreuses !
+Un autre exemple populaire est [SafeMath](https://docs.openzeppelin.com/contracts/3.x/utilities#math) ou [DsMath](https://dappsys.readthedocs.io/en/latest/ds_math.html). Ce sont des bibliothèques (par opposition aux contrats de base) qui fournissent des fonctions arithmétiques avec des vérifications de dépassement qui ne sont pas fournies par le langage. Une bonne pratique consiste à utiliser l'une de ces bibliothèques au lieu d'opérations arithmétiques natives pour protéger votre contrat contre les dépassements, qui peuvent avoir des conséquences désastreuses !
 
 ### Normes {#standards}
 
-Pour faciliter la [composabilité et l'interopérabilité](/developers/docs/smart-contracts/composability/), la communauté Ethereum a défini plusieurs normes sous la forme de demandes de commentaires (**ERC**). Pour plus d'informations, lisez la page [Normes de développement Ethereum](/developers/docs/standards/).
+Pour faciliter [la composabilité et l'interopérabilité](/developers/docs/smart-contracts/composability/), la communauté Ethereum a défini plusieurs normes sous la forme d'**ERC**. Vous pouvez en apprendre plus à leur sujet dans la section [normes](/developers/docs/standards/).
 
-Quand vous incluez une ERC dans vos contrats, il est préférable de chercher des implémentations standards plutôt que d'essayer de déployer la vôtre. De nombreuses bibliothèques de contrats intelligents incluent des implémentations pour les ERC les plus populaires. Par exemple, la [norme de jeton fongible ERC20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) est disponible dans [HQ20](https://github.com/HQ20/contracts/blob/master/contracts/token/README.md), [DappSys](https://github.com/dapphub/ds-token/) et [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc20). De plus, certaines ERC intègrent elles-mêmes également des implémentations canoniques.
+Quand vous incluez une ERC dans vos contrats, il est préférable de chercher des implémentations standards plutôt que d'essayer de déployer la vôtre. De nombreuses bibliothèques de contrats intelligents incluent des implémentations pour les ERC les plus populaires. Par exemple, l'omniprésente [norme de jeton fongible ERC20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) se trouve dans [HQ20](https://github.com/HQ20/contracts/blob/master/contracts/token/README.md), [DappSys](https://github.com/dapphub/ds-token/) et [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc20). De plus, certaines ERC intègrent elles-mêmes également des implémentations canoniques.
 
-Il convient de mentionner que certaines ERC ne sont pas autonomes, mais sont des ajouts à d'autres ERC. Par exemple, [ERC2612](https://eips.ethereum.org/EIPS/eip-2612) ajoute une extension à ERC20 pour améliorer son opérabilité.
+Il convient de mentionner que certaines ERC ne sont pas autonomes, mais sont des ajouts à d'autres ERC. Par exemple, [ERC2612](https://eips.ethereum.org/EIPS/eip-2612) ajoute une extension à l'ERC20 pour améliorer son utilisabilité.
 
-## Comment ajouter une bibliothèque ? {#how-to}
+## Comment ajouter une bibliothèque {#how-to}
 
-Pour obtenir des instructions spécifiques, consultez toujours la documentation de la bibliothèque que vous voulez inclure à votre projet. Plusieurs bibliothèques de contrats Solidity sont compilées en utilisant `npm`, il vous suffit donc d'utiliser `nmp install`. La plupart des outils utilisés pour la [compilation](/developers/docs/smart-contracts/compiling/) de contrats examineront vos `node_modules` pour les bibliothèques de contrats intelligents, vous pouvez donc faire ce qui suit :
+Pour obtenir des instructions spécifiques, consultez toujours la documentation de la bibliothèque que vous voulez inclure à votre projet. Plusieurs bibliothèques de contrats Solidity sont empaquetées à l'aide de `npm`, vous pouvez donc simplement les installer avec `npm install`. La plupart des outils pour [compiler](/developers/docs/smart-contracts/compiling/) des contrats chercheront dans votre répertoire `node_modules` des bibliothèques de contrats intelligents. Vous pouvez donc procéder comme suit :
 
 ```solidity
 // This will load the @openzeppelin/contracts library from your node_modules
@@ -75,11 +75,11 @@ contract MyNFT is ERC721 {
 
 Quelle que soit la méthode que vous utilisez, lorsque vous incluez une bibliothèque, gardez toujours un œil sur la version du [langage](/developers/docs/smart-contracts/languages/). Par exemple, vous ne pouvez pas utiliser une bibliothèque pour Solidity 0.6 si vous rédigez vos contrats en Solidity 0.5.
 
-## Quand les utiliser ? {#when-to-use}
+## Quand les utiliser {#when-to-use}
 
 L'utilisation d'une bibliothèque de contrats intelligents pour votre projet présente plusieurs avantages. D'abord, elle vous fait gagner du temps en vous fournissant des blocs de construction prêts à l'emploi que vous pouvez inclure dans votre système, plutôt que d'avoir à les coder vous-même.
 
-La sécurité est également un atout majeur. Les bibliothèques de contrats intelligents open source sont aussi souvent soumises à un examen approfondi. De nombreux projets dépendant d'elles, la communauté est fortement incitée à les réviser en permanence. Il est beaucoup plus courant de trouver des erreurs dans du code d'application que dans les bibliothèques de contrats réutilisables. Certaines bibliothèques sont également soumises à des [audits externes](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/audits) pour plus de sécurité.
+La sécurité est également un atout majeur. Les bibliothèques de contrats intelligents open source sont aussi souvent soumises à un examen approfondi. De nombreux projets dépendant d'elles, la communauté est fortement incitée à les réviser en permanence. Il est beaucoup plus courant de trouver des erreurs dans du code d'application que dans les bibliothèques de contrats réutilisables. Certaines bibliothèques subissent également des [audits externes](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/audits) pour une sécurité supplémentaire.
 
 Cependant, l'utilisation de bibliothèques de contrats intelligents comporte le risque d'inclure du code que vous ne connaissez pas dans votre projet. Il est tentant d'importer un contrat et de l'inclure directement, mais sans une bonne compréhension de ce que fait ce contrat, vous risquez d'introduire par mégarde un problème dans votre système en raison d'un comportement inattendu. Assurez-vous toujours de lire la documentation du code que vous importez, puis vérifiez le code lui-même avant de l'intégrer à votre projet !
 
@@ -87,31 +87,31 @@ Enfin, au moment où vous décidez s'inclure une bibliothèque, considérez son
 
 ## Outils connexes {#related-tools}
 
-**Contrats OpenZeppelin -** **_Bibliothèque la plus populaire pour développer des contrats intelligents de façon sécurisée_**
+**Contrats OpenZeppelin -** **_Bibliothèque la plus populaire pour le développement sécurisé de contrats intelligents._**
 
 - [Documentation](https://docs.openzeppelin.com/contracts/)
 - [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts)
-- [Forum communautaire](https://forum.openzeppelin.com/c/general/16)
+- [Forum de la communauté](https://forum.openzeppelin.com/c/general/16)
 
-**DappSys -** **_Blocs de construction sûrs, simples et flexibles pour les contrats intelligents_**
+**DappSys -** **_Des briques de construction sûres, simples et flexibles pour les contrats intelligents._**
 
 - [Documentation](https://dappsys.readthedocs.io/)
 - [GitHub](https://github.com/dapphub/dappsys)
 
-**HQ20 -** **_Projet Solidity avec des contrats, des bibliothèques et des exemples pour vous aider à construire des applications distribuées complètes pour le monde réel_**
+**HQ20 -** **_Un projet Solidity avec des contrats, des bibliothèques et des exemples pour vous aider à créer des applications distribuées complètes pour le monde réel._**
 
 - [GitHub](https://github.com/HQ20/contracts)
 
-**SDK Solidity thirdweb -** **_Fournit les outils nécessaires pour construire efficacement des contrats intelligents personnalisés_**
+**thirdweb Solidity SDK -** **_Fournit les outils nécessaires pour créer efficacement des contrats intelligents personnalisés_**
 
 - [Documentation](https://portal.thirdweb.com/contracts/build/overview)
 - [GitHub](https://github.com/thirdweb-dev/contracts)
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Considérations de sécurité pour les développeurs Ethereum](/developers/docs/smart-contracts/security/) _- Tutoriel sur les considérations de sécurité lors de la construction de contrats intelligents, y compris l'utilisation de la bibliothèque_
-- [Comprendre le contrat intelligent de jeton ERC-20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _- Tutoriel sur la norme ERC20, fournie par de multiples bibliothèques_
+- [Considérations de sécurité pour les développeurs Ethereum](/developers/docs/smart-contracts/security/) _– Un tutoriel sur les considérations de sécurité lors de la création de contrats intelligents, y compris l'utilisation de bibliothèques._
+- [Comprendre le contrat intelligent de jeton ERC-20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _- Tutoriel sur la norme ERC20, fournie par plusieurs bibliothèques._
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/naming/index.md b/public/content/translations/fr/developers/docs/smart-contracts/naming/index.md
new file mode 100644
index 00000000000..01a5f3fe674
--- /dev/null
+++ b/public/content/translations/fr/developers/docs/smart-contracts/naming/index.md
@@ -0,0 +1,101 @@
+---
+title: Nommer les contrats intelligents
+description: Meilleures pratiques pour nommer les contrats intelligents Ethereum avec ENS
+lang: fr
+---
+
+Les contrats intelligents sont une pierre angulaire de l'infrastructure décentralisée d'Ethereum, permettant des applications et des protocoles autonomes. Mais même si les capacités des contrats évoluent, les utilisateurs et les développeurs continuent de se fier à des adresses hexadécimales brutes pour identifier et référencer ces contrats.
+
+Nommer les contrats intelligents avec [l'Ethereum Name Service (ENS)](https://ens.domains/) améliore l'expérience utilisateur en éliminant les adresses de contrat hexadécimales et réduit les risques d'attaques telles que l'empoisonnement d'adresse et les attaques par usurpation. Ce guide explique pourquoi il est important de nommer les contrats intelligents, comment mettre en œuvre ce nommage et quels outils sont disponibles, tels que [Enscribe](https://www.enscribe.xyz), pour simplifier le processus et aider les développeurs à adopter cette pratique.
+
+## Pourquoi nommer les contrats intelligents ? {#why-name-contracts}
+
+### Identifiants lisibles par l'homme {#human-readable-identifiers}
+
+Au lieu d'interagir avec des adresses de contrat opaques comme `0x8f8e...f9e3`, les développeurs et les utilisateurs peuvent utiliser des noms lisibles par l'homme comme `v2.myapp.eth`. Cela simplifie les interactions avec les contrats intelligents.
+
+Ceci est rendu possible par le [Service de Noms Ethereum (ENS)](https://ens.domains/) qui fournit un service de nommage décentralisé pour les adresses Ethereum. Ceci est analogue à la façon dont le service de noms de domaine (DNS) permet aux utilisateurs d'Internet d'accéder aux adresses réseau en utilisant un nom tel que ethereum.org au lieu d'une adresse IP telle que `104.18.176.152`.
+
+### Sécurité et confiance améliorées {#improved-security-and-trust}
+
+Les contrats nommés aident à réduire les transactions accidentelles vers la mauvaise adresse. Ils aident également les utilisateurs à identifier les contrats liés à des applications ou à des marques spécifiques. Cela ajoute une couche de confiance basée sur la réputation, surtout lorsque les noms sont attachés à des domaines parents bien connus comme `uniswap.eth`.
+
+En raison de la longueur de 42 caractères des adresses Ethereum, il est très difficile pour les utilisateurs d'identifier de petits changements dans les adresses, où quelques caractères ont été modifiés. Par exemple, une adresse telle que `0x58068646C148E313CB414E85d2Fe89dDc3426870` serait normalement tronquée en `0x580...870` par des applications destinées aux utilisateurs telles que les portefeuilles. Il est peu probable qu'un utilisateur remarque une adresse malveillante où quelques caractères ont été modifiés.
+
+Ce type de technique est utilisé dans les attaques par usurpation et empoisonnement d'adresse où les utilisateurs sont amenés à croire qu'ils interagissent avec ou envoient des fonds à la bonne adresse, alors qu'en fait l'adresse ressemble simplement à la bonne adresse, mais n'est pas la même.
+
+Les noms ENS pour les portefeuilles et les contrats protègent contre ce type d'attaques. Comme les attaques d'usurpation de DNS, les attaques d'usurpation d'ENS peuvent également se produire, cependant, un utilisateur est plus susceptible de remarquer une faute d'orthographe dans un nom ENS qu'une petite modification dans une adresse hexadécimale.
+
+### Meilleure expérience utilisateur pour les portefeuilles et les explorateurs {#better-ux}
+
+Lorsqu'un contrat intelligent a été configuré avec un nom ENS, il est possible pour des applications telles que des portefeuilles et des explorateurs de blockchain d'afficher des noms ENS pour les contrats intelligents, au lieu d'adresses hexadécimales. Cela apporte une amélioration significative de l'expérience utilisateur (UX) pour les utilisateurs.
+
+Par exemple, en interagissant avec une application telle qu'Uniswap, les utilisateurs verront généralement que l'application avec laquelle ils interagissent est hébergée sur le site web `uniswap.org`, mais une adresse de contrat hexadécimale leur serait présentée si Uniswap n'avait pas nommé ses contrats intelligents avec ENS. Si le contrat est nommé, ils pourraient voir à la place `v4.contracts.uniswap.eth`, ce qui est beaucoup plus utile.
+
+## Nommage lors du déploiement ou après le déploiement {#when-to-name}
+
+Il y a deux moments où les contrats intelligents peuvent être nommés :
+
+- **Au moment du déploiement** : attribuer un nom ENS au contrat au fur et à mesure de son déploiement.
+- **Après le déploiement** : associer une adresse de contrat existante à un nouveau nom ENS.
+
+Les deux approches reposent sur le fait d'avoir un accès de propriétaire ou de gestionnaire à un domaine ENS afin de pouvoir créer et définir des enregistrements ENS.
+
+## Comment fonctionne le nommage ENS pour les contrats {#how-ens-naming-works}
+
+Les noms ENS sont stockés en chaîne et se résolvent en adresses Ethereum via des résolveurs ENS. Pour nommer un contrat intelligent :
+
+1. Enregistrer ou contrôler un domaine ENS parent (par ex. `myapp.eth`)
+2. Créer un sous-domaine (par ex. `v1.myapp.eth`)
+3. Définir l'enregistrement d'`adresse` du sous-domaine sur l'adresse du contrat
+4. Définir l'enregistrement inversé du contrat sur l'ENS pour permettre de trouver le nom via son adresse
+
+Les noms ENS sont hiérarchiques et prennent en charge un nombre illimité de sous-noms. La définition de ces enregistrements implique généralement une interaction avec le registre ENS et les contrats de résolveur publics.
+
+## Outils pour nommer les contrats {#tools}
+
+Il existe deux approches pour nommer les contrats intelligents. Soit en utilisant l'[application ENS](https://app.ens.domains) avec quelques étapes manuelles, soit en utilisant [Enscribe](https://www.enscribe.xyz). Celles-ci sont décrites ci-dessous.
+
+### Configuration manuelle de l'ENS {#manual-ens-setup}
+
+En utilisant l'[application ENS](https://app.ens.domains), les développeurs peuvent créer manuellement des sous-noms et définir des enregistrements d'adresse directs. Cependant, ils ne peuvent pas définir un nom principal pour un contrat intelligent en définissant l'enregistrement inversé pour le nom via l'application ENS. Des étapes manuelles, qui sont expliquées dans la [documentation ENS](https://docs.ens.domains/web/naming-contracts/), doivent être suivies.
+
+### Enscribe {#enscribe}
+
+[Enscribe](https://www.enscribe.xyz) simplifie le nommage des contrats intelligents avec ENS et renforce la confiance des utilisateurs dans les contrats intelligents. Il fournit :
+
+- **Déploiement et nommage atomiques** : attribuer un nom ENS lors du déploiement d'un nouveau contrat
+- **Nommage post-déploiement** : associer des noms à des contrats déjà déployés
+- **Prise en charge multichaîne** : fonctionne sur Ethereum et les réseaux de couche 2 où ENS est pris en charge
+- **Données de vérification des contrats** : inclut des données de vérification de contrat extraites de plusieurs sources pour accroître la confiance des utilisateurs
+
+Enscribe prend en charge les noms ENS fournis par les utilisateurs, ou ses propres domaines si l'utilisateur n'a pas de nom ENS.
+
+Vous pouvez accéder à l'[application Enscribe](https://app.enscribe.xyz) pour commencer à nommer et à visualiser les contrats intelligents.
+
+## Bonnes pratiques {#best-practices}
+
+- **Utilisez des noms clairs et versionnés** comme `v1.myapp.eth` pour rendre les mises à niveau de contrat transparentes
+- **Définissez les enregistrements inversés** pour lier les contrats aux noms ENS pour une meilleure visibilité dans les applications telles que les portefeuilles et les explorateurs de blockchain.
+- **Surveillez attentivement les expirations** si vous voulez éviter les changements de propriété accidentels
+- **Vérifiez la source du contrat** afin que les utilisateurs puissent être sûrs que le contrat nommé se comporte comme prévu
+
+## Risques {#risks}
+
+Le nommage des contrats intelligents offre des avantages significatifs aux utilisateurs d'Ethereum, cependant, les propriétaires de domaines ENS doivent être vigilants quant à leur gestion. Les risques notables incluent :
+
+- **Expiration** : tout comme les noms DNS, les enregistrements de noms ENS ont une durée limitée. Il est donc essentiel que les propriétaires surveillent les dates d'expiration de leurs domaines et les renouvellent bien avant leur expiration. L'application ENS et Enscribe fournissent toutes deux des indicateurs visuels aux propriétaires de domaines lorsque l'expiration approche.
+- **Changement de propriétaire** : les enregistrements ENS sont représentés sous forme de NFT sur Ethereum, où le propriétaire d'un domaine `.eth` spécifique possède le NFT associé. Par conséquent, si un autre compte prend possession de ce NFT, le nouveau propriétaire peut modifier n'importe quel enregistrement ENS comme il l'entend.
+
+Pour atténuer ces risques, le compte propriétaire des domaines de deuxième niveau (2LD) `.eth` devrait être sécurisé via un portefeuille multisignature, avec des sous-domaines créés pour gérer le nommage des contrats. De cette façon, en cas de changement de propriété accidentel ou malveillant au niveau du sous-domaine, ils peuvent être annulés par le propriétaire du 2LD.
+
+## L'avenir du nommage de contrats {#future}
+
+Le nommage des contrats devient une bonne pratique pour le développement de dapps, de la même manière que les noms de domaine ont remplacé les adresses IP sur le Web. À mesure que de plus en plus d'infrastructures telles que les portefeuilles, les explorateurs et les tableaux de bord intègrent la résolution ENS pour les contrats, les contrats nommés amélioreront la sécurité et réduiront les erreurs dans l'ensemble de l'écosystème.
+
+En rendant les contrats intelligents plus faciles à reconnaître et à comprendre, le nommage aide à combler le fossé entre les utilisateurs et les applications sur Ethereum, améliorant à la fois la sécurité et l'expérience utilisateur (UX) pour les utilisateurs.
+
+## En savoir plus {#further-reading}
+
+- [Nommer les contrats intelligents avec l'ENS](https://docs.ens.domains/web/naming-contracts/)
+- [Nommer les contrats intelligents avec Enscribe](https://www.enscribe.xyz/docs).
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/security/index.md b/public/content/translations/fr/developers/docs/smart-contracts/security/index.md
index 78e7ff690b5..aa0723071c0 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/security/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/security/index.md
@@ -1,54 +1,54 @@
 ---
-title: Sécurité des contrats intelligents
-description: Un aperçu des lignes directrices pour la construction de contrats intelligents sécurisés Ethereum
+title: "Sécurité de contrat intelligent"
+description: "Un aperçu des lignes directrices pour la construction de contrats intelligents sécurisés Ethereum"
 lang: fr
 ---
 
 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.
 
-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é.
+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 failles de sécurité, tandis que 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/markets/2017/07/19/30-million-ether-reported-stolen-due-to-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).
+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 très médiatisés, tels que le [piratage de la DAO](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) (3,6M d'ETH volés, d'une valeur de plus de 1 milliard de dollars aux prix d'aujourd'hui), le [piratage du portefeuille multi-signatures Parity](https://www.coindesk.com/markets/2017/07/19/30-million-ether-reported-stolen-due-to-parity-wallet-breach) (30M de dollars perdus au profit des pirates), et le [problème du portefeuille gelé de Parity](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether) (plus de 300M de dollars en ETH bloqués à jamais).
 
 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}
 
-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é.
+Assurez-vous de bien connaître les [principes fondamentaux du développement de contrats intelligents](/developers/docs/smart-contracts/) avant de vous attaquer à la sécurité.
 
-## Lignes directrices pour la construction de contrats intelligents sécurisés Ethereum {#smart-contract-security-guidelines}
+## Lignes directrices pour la création de contrats intelligents Ethereum sécurisés {#smart-contract-security-guidelines}
 
 ### 1. Concevoir des contrôles d'accès appropriés {#design-proper-access-controls}
 
-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).
+Dans les contrats intelligents, les fonctions marquées `public` ou `external` 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. En revanche, les fonctions marquées `private` ne peuvent ê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).
 
-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 :
+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 basé sur les rôles** sont deux modèles utiles pour mettre en œuvre le contrôle d'accès dans les contrats intelligents :
 
-#### Modèle Ownable {#ownable-pattern}
+#### Modèle « Ownable » {#ownable-pattern}
 
-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é.
+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 se voient attribuer un modificateur `OnlyOwner`, qui garantit que le contrat authentifie l'identité de l'adresse appelante 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é.
 
 #### Contrôle d'accès basé sur les rôles {#role-based-access-control}
 
-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.
+L'enregistrement d'une seule adresse en tant que `Owner` dans un contrat intelligent introduit le 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.
 
 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.
 
 ##### Utilisation de portefeuilles multi-signature
 
-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.
+Une autre approche pour la mise en place d'un contrôle d'accès sécurisé consiste à utiliser un [compte multi-signatures](/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.
 
 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.
 
-### 2. Utiliser les commandes require(), assert() et revert() pour protéger les opérations de contrat {#use-require-assert-revert}
+### 2. Utiliser les instructions require(), assert() et revert() pour protéger les opérations de contrat {#use-require-assert-revert}
 
-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.
+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 instructions `require()`, `assert()` et `revert()` pour déclencher des exceptions et annuler les changements d'état si l'exécution ne satisfait pas à certaines exigences.
 
-**`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.
+**`require()`** : `require` est défini au début des fonctions et garantit que les 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 de l'utilisateur, vérifier les variables d'état ou authentifier l'identité du compte appelant avant de poursuivre avec une fonction.
 
-**`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.
+**`assert()`** : `assert()` est utilisé 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 `assert()` garantit que votre contrat n'atteint jamais un état vulnérable, et si c'est le cas, 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 :
+**`revert()`** : `revert()` peut être utilisé dans une instruction if-else qui déclenche une exception si la condition requise n'est pas satisfaite. L'exemple de contrat ci-dessous utilise `revert()` pour protéger l'exécution des fonctions :
 
 ```
 pragma solidity ^0.8.4;
@@ -58,8 +58,8 @@ contract VendingMachine {
     error Unauthorized();
     function buy(uint amount) public payable {
         if (amount > msg.value / 2 ether)
-            revert("Not enough Ether provided.");
-        // Perform the purchase.
+            revert("Pas assez d'Ether fournis.");
+        // Effectuer l'achat.
     }
     function withdraw() public {
         if (msg.sender != owner)
@@ -70,19 +70,19 @@ contract VendingMachine {
 }
 ```
 
-### 3. Tester les contrats intelligents et vérifier la justesse du code {#test-smart-contracts-and-verify-code-correctness}
+### 3. Tester les contrats intelligents et vérifier l'exactitude 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.
+L'immuabilité du code s'exécutant dans la [machine virtulle Ethereum ](/developers/docs/evm/) signifie que les contrats intelligents exigent un niveau d'évaluation de la qualité plus élevé 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.
+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 utile pour tester la fonctionnalité de certaines fonctions et 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 de contrat intelligent](https://www.cyfrin.io/blog/smart-contract-fuzzing-and-invariants-testing-foundry), 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é.
+Une meilleure approche consiste à combiner les tests unitaires avec des tests basés sur les propriétés effectués à l'aide de [l'analyse statique et dynamique](/developers/docs/smart-contracts/testing/#static-dynamic-analysis). L'analyse statique s'appuie sur des représentations de bas niveau, telles que des [graphes 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. Pendant ce temps, les techniques d'analyse dynamique, telles que le [fuzzing de contrats intelligents](https://www.cyfrin.io/blog/smart-contract-fuzzing-and-invariants-testing-foundry), exécutent le code du contrat avec des valeurs d'entrée 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.
+La [vérification formelle](/developers/docs/smart-contracts/formal-verification) est une autre technique pour vérifier les 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}
+### 4. Demander une révision 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.
 
@@ -92,18 +92,18 @@ Demander un audit des contrats intelligents est une façon de procéder à un ex
 
 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. Vous devez également suivre les bonnes pratiques pour travailler avec les auditeurs, comme documenter le code correctement et ajouter des commentaires en ligne, pour maximiser les avantages d'un audit de contrats intelligents.
 
-- [Trucs & astuces d'audit de contrat intelligent](https://twitter.com/tinchoabbate/status/1400170232904400897) - _tinchoabbate_
-- [Tirer le meilleur de votre audit](https://inference.ag/blog/2023-08-14-tips/) - _Inference_
+- [Conseils et astuces pour l'audit de contrats intelligents](https://twitter.com/tinchoabbate/status/1400170232904400897) - _@tinchoabbate_
+- [Tirez le meilleur parti de votre audit](https://inference.ag/blog/2023-08-14-tips/) - _Inference_
 
-#### Chasse à la prime {#bug-bounties}
+#### Primes de bogues {#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 de [Couche 2](/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/).
+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 concret est le « bogue de l'argent infini » qui aurait permis à un attaquant de créer une quantité illimitée d'ether sur [Optimism](https://www.optimism.io/), un protocole de [couche 2](/layer-2/) fonctionnant sur Ethereum. Heureusement, un hacker éthique [a découvert la faille](https://www.saurik.com/optimism.html) et a prévenu l'équipe, [empochant au passage une récompense importante](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.
+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écrite comme la « [prime de bogue à l'échelle](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7) », cette approche offre des incitations financières aux individus pour qu'ils divulguent les vulnérabilités de manière responsable au lieu de les exploiter.
 
-### 5. Suivre les bonnes pratiques lors du développement de contrats intelligents {#follow-smart-contract-development-best-practices}
+### 5. Suivre les meilleures 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 :
 
@@ -113,25 +113,25 @@ L’existence d’audits et de primes de bogue n'exclut pas votre responsabilit
 
 - 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
+- Utiliser un [environnement de développement](/developers/docs/frameworks/) pour tester, compiler et déployer des contrats intelligents
 
-- Exécutez votre code sur des outils d'analyse de code basiques, tels que [Cyfrin Aaderyn](https://github.com/Cyfrin/aderyn), Mythril et Slither. Idéalement, vous devriez le faire avant de fusionner chaque pull request et comparer les différences de sortie
+- Exécutez votre code via des outils d'analyse de code de base, tels que [Cyfrin Aderyn](https://github.com/Cyfrin/aderyn), 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.
+- Documentez correctement votre code (en utilisant [NatSpec](https://solidity.readthedocs.io/en/develop/natspec-format.html)) et décrivez les détails de 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}
+### 6. Mettre en œuvre des plans de reprise après sinistre robustes {#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}
+#### Mises à niveau de contrats {#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.
 
-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](https://www.cyfrin.io/blog/upgradeable-proxy-smart-contract-pattern) 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.
+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](https://www.cyfrin.io/blog/upgradeable-proxy-smart-contract-pattern) répartissent 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.
 
-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.
+Les comptes interagissent avec le contrat proxy, qui délègue 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 classique, `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 que les valeurs originales de `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.
 
@@ -143,16 +143,16 @@ Comme nous l'avons mentionné, les audits et les tests approfondis ne peuvent pa
 
 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é.
+1. Une variable booléenne globale indiquant si le contrat intelligent est dans un état arrêté ou non. Cette variable est initialisée à `false` lors de la configuration du contrat, mais reviendra à `true` 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 :
+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. Vous trouverez ci-dessous [un exemple](https://github.com/fravoll/solidity-patterns/blob/master/EmergencyStop/EmergencyStop.sol) décrivant une mise en œuvre de ce modèle dans les contrats :
 
 ```solidity
-// 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.
+// Ce code n'a pas été audité par des professionnels et ne fait aucune promesse quant à sa sécurité ou son exactitude. Utilisez-le à vos propres risques.
 
 contract EmergencyStop {
 
@@ -169,7 +169,7 @@ contract EmergencyStop {
     }
 
     modifier onlyAuthorized {
-        // Check for authorization of msg.sender here
+        // Vérifier l'autorisation de msg.sender ici
         _;
     }
 
@@ -182,28 +182,28 @@ contract EmergencyStop {
     }
 
     function deposit() public payable stoppedInEmergency {
-        // Deposit logic happening here
+        // La logique de dépôt s'exécute ici
     }
 
     function emergencyWithdraw() public onlyWhenStopped {
-        // Emergency withdraw happening here
+        // Le retrait d'urgence s'exécute ici
     }
 }
 ```
 
 Cet exemple montre les caractéristiques de base des arrêts d'urgence :
 
-- `isStopped` est un booléen qui évalue à `false` en début et à `true` lorsque le contrat entre en mode d'urgence.
+- `isStopped` est un booléen qui s'évalue à `false` au début et à `true` lorsque le contrat entre en mode d'urgence.
 
-- 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.
+- Les modificateurs de fonction `onlyWhenStopped` et `stoppedInEmergency` vérifient la variable `isStopped`. `stoppedInEmergency` est utilisé pour contrôler les fonctions qui devraient être inaccessibles lorsque le contrat est vulnérable (par ex., `deposit()`). Les appels à ces fonctions seront tout simplement annulés.
 
-`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 ».
+`onlyWhenStopped` est utilisé pour les fonctions qui doivent pouvoir être appelées en cas d'urgence (par ex., `emergencyWithdraw()`). De telles fonctions peuvent aider à résoudre la situation, d’où leur exclusion de la liste des « fonctions restreintes ».
 
 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, il est possible de décentraliser le contrôle de l'arrêt d'urgence en le soumettant à un mécanisme de vote sur la chaîne, à un timelock, ou à l'approbation d'un portefeuille multisig.
 
-#### Suivi des événements {#event-monitoring}
+#### Surveillance 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).
+Les [événements](https://docs.soliditylang.org/en/v0.8.15/contracts.html#events) vous permettent de suivre les appels aux fonctions des contrats intelligents et de surveiller les changements des 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).
 
 L'enregistrement des événements et leur surveillance hors chaîne permettent de mieux comprendre les opérations contractuelles et de découvrir plus rapidement les 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.
 
@@ -213,32 +213,32 @@ Vous pouvez également opter pour un outil de surveillance en vente libre qui tr
 
 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, à savoir 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 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 serait celui où un attaquant acquiert un pouvoir de vote énorme (mesuré en nombre de jetons détenus) en contractant un [prêt flash](/defi/#flash-loans) et en faisant passer une proposition malveillante.
 
-Le fait d'utiliser [un timelock](https://blog.openzeppelin.com/protect-your-users-with-smart-contract-timelocks/) est une façon de prévenir les problèmes liés à la gouvernance sur la chaîne. 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é de récupérer rapidement le pouvoir de vote pour faire basculer des votes sur la chaîne.
+Une façon de prévenir les problèmes liés à la gouvernance en chaîne est d'[utiliser un verrouillage temporel](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é de récupérer rapidement le pouvoir de vote pour faire basculer des votes sur la chaîne.
 
-Vous trouverez plus d'informations sur [la conception de systèmes de gouvernance sécurisés](https://blog.openzeppelin.com/smart-contract-security-guidelines-4-strategies-for-safer-governance-systems/), [les différents mécanismes de vote dans les DAO](https://hackernoon.com/governance-is-the-holy-grail-for-daos), et [les vecteurs d'attaque courants des DAO utilisant la DeFi](https://dacian.me/dao-governance-defi-attacks) dans les liens partagés.
+Pour en savoir plus sur la [conception de systèmes de gouvernance sécurisés](https://blog.openzeppelin.com/smart-contract-security-guidelines-4-strategies-for-safer-governance-systems/), les [différents mécanismes de vote dans les DAO](https://hackernoon.com/governance-is-the-holy-grail-for-daos), et [les vecteurs d'attaque courants des DAO qui tirent parti de la DeFi](https://dacian.me/dao-governance-defi-attacks), consultez les liens partagés.
 
-### 8. Réduire la complexité du code à un minimum {#reduce-code-complexity}
+### 8. Réduire la complexité du code au 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.
 
-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/5.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.
+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 les bibliothèques existantes, telles que les [Contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/5.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}
+### 9. Se défendre contre les vulnérabilités courantes 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.
+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 formellement décrit 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
-// This contract is vulnerable. Do not use in production
+// Ce contrat est vulnérable. Ne pas utiliser en production
 
 contract Victim {
     mapping (address => uint256) public balances;
@@ -256,15 +256,15 @@ contract Victim {
 }
 ```
 
-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 :
+Ce contrat expose une fonction `withdraw()` pour permettre aux utilisateurs de retirer des ETH précédemment déposés dans le contrat. Lors du traitement d'un retrait, le contrat effectue les opérations suivantes :
 
 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).
+La fonction `withdraw()` dans le contrat `Victim` suit un modèle « vérifications-interactions-effets ». Il _vérifie_ si les conditions nécessaires à l'exécution sont satisfaites (c.-à-d. que l'utilisateur a un solde d'ETH positif) et effectue l'_interaction_ en envoyant des ETH à l'adresse de l'appelant, avant d'appliquer les _effets_ de la transaction (c.-à-d. en 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.
+Si `withdraw()` est appelé depuis un compte externe (EOA), la fonction s'exécute comme prévu : `msg.sender.call.value()` envoie des ETH à l'appelant. Cependant, si `msg.sender` est un compte de contrat intelligent qui appelle `withdraw()`, l'envoi de fonds via `msg.sender.call.value()` déclenchera également l'exécution du code stocké à cette adresse.
 
 Imaginez qu'il s'agisse du code déployé à l'adresse du contrat:
 
@@ -289,7 +289,7 @@ Ce contrat est conçu pour faire trois choses :
 2. Dépose 1 ETH dans le contrat Victim
 3. Retirer 1 ETH stocké dans le contrat intelligent
 
-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:
+Il n'y a rien de mal ici, si ce n'est que `Attacker` a une autre fonction qui appelle à nouveau `withdraw()` dans `Victim` si le gaz restant de l'appel entrant `msg.sender.call.value` est supérieur à 40 000. Cela donne à `Attacker` la possibilité de ré-entrer dans `Victim` et de retirer plus de fonds _avant_ la fin de la première invocation de `withdraw`. Le cycle ressemble à ceci:
 
 ```solidity
 - L'EOA de l'attaquant appelle `Attacker.beginAttack()` avec 1 ETH
@@ -304,13 +304,13 @@ Il n'y a rien de mal ici, excepté que l'`Attacker` a une autre fonction qui app
 - `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
 ```
 
-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/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).
+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 vider les fonds d'un contrat intelligent, comme ce qui s'est passé lors du [piratage de la DAO en 2016](https://www.coindesk.com/learn/understanding-the-dao-attack). Les attaques par réentrance restent aujourd'hui un problème critique pour les contrats intelligents, comme le montrent les [listes publiques d'exploits de réentrance](https://github.com/pcaversaccio/reentrancy-attacks).
 
 ##### Comment empêcher les attaques par réentrance
 
-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.
+Une approche pour gérer la réentrance consiste à suivre le [modèle 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.
 
-Le modèle de vérifications-effets-interactions est utilisé dans une version révisée du contrat `Victim` affichée ci-dessous :
+Le modèle vérifications-effets-interactions est utilisé dans une version révisée du contrat `Victim` présentée ci-dessous :
 
 ```solidity
 contract NoLongerAVictim {
@@ -323,9 +323,9 @@ contract NoLongerAVictim {
 }
 ```
 
-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.
+Ce contrat effectue une _vérification_ du solde de l'utilisateur, applique les _effets_ de la fonction `withdraw()` (en réinitialisant le solde de l'utilisateur à 0), et procède à l'_interaction_ (envoi d'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 rappeler `NoLongerAVictim`, mais comme `balances[msg.sender]` a été mis à 0, les retraits supplémentaires lèveront une erreur.
 
-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.
+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 mis en œuvre à l'aide d'une variable booléenne qui est définie sur `true` avant l'exécution de la fonction et revient à `false` une fois l'invocation terminée. 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.
 
 ```solidity
 pragma solidity ^0.7.0;
@@ -335,15 +335,15 @@ contract MutexPattern {
     mapping(address => uint256) public balances;
 
     modifier noReentrancy() {
-        require(!locked, "Blocked from reentrancy.");
+        require(!locked, "Bloqué par la réentrance.");
         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
+    // Cette fonction est protégée par un mutex, donc les appels réentrants depuis `msg.sender.call` ne peuvent plus appeler `withdraw`.
+    //  L'instruction `return` s'évalue à `true` mais évalue quand même l'instruction `locked = false` dans le modificateur
     function withdraw(uint _amount) public payable noReentrancy returns(bool) {
-        require(balances[msg.sender] >= _amount, "No balance to withdraw.");
+        require(balances[msg.sender] >= _amount, "Pas de solde à retirer.");
 
         balances[msg.sender] -= _amount;
         (bool success, ) = msg.sender.call{value: _amount}("");
@@ -354,31 +354,31 @@ contract MutexPattern {
 }
 ```
 
-Vous pouvez également utiliser un système de [« pull payments »](https://docs.openzeppelin.com/contracts/5.x/api/utils#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).
+Vous pouvez également utiliser un système de [paiements pull](https://docs.openzeppelin.com/contracts/5.x/api/utils#security#PullPayment) qui exige que les utilisateurs retirent des fonds des contrats intelligents, au lieu d'un système de « paiements push » qui envoie des fonds aux 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).
 
-#### Soupassements et dépassements d'entier {#integer-underflows-and-overflows}
+#### Dépassements négatifs et positifs d'entiers {#integer-underflows-and-overflows}
 
-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).
+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` provoqueront un dépassement positif et réinitialiseront `uint` à `0`, de la même manière que l'odomètre d'une voiture se remet à 0 lorsqu'il atteint son kilométrage maximum (999999).
 
-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`).
+Les dépassements négatifs d'entiers se produisent pour des raisons similaires : les résultats d'une opération arithmétique tombent en dessous de la plage acceptable. Si vous essayiez de décrémenter `0` dans un `uint8`, le résultat reviendrait simplement à la valeur maximale représentable (`255`).
 
 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 :
 
 ```
 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.
+// Ce contrat est conçu pour agir comme un coffre-fort temporel.
+// L'utilisateur peut déposer dans ce contrat, mais ne peut pas retirer pendant au moins une semaine.
+// L'utilisateur peut également prolonger le temps d'attente au-delà de la période d'attente d'une semaine.
 
 /*
 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.
+2. Déployer Attack avec l'adresse de TimeLock
+3. Appeler Attack.attack en envoyant 1 ether. Vous pourrez immédiatement retirer
+   votre ether.
 
 Que s'est-il passé ?
-L'attaque a causé un dépassement de TimeLock.lockTime et a pu entraîner un retrait
+Attack a provoqué le dépassement de TimeLock.lockTime et a permis un retrait
 avant la période d'attente d'une semaine.
 */
 
@@ -396,14 +396,14 @@ contract TimeLock {
     }
 
     function withdraw() public {
-        require(balances[msg.sender] > 0, "Insufficient funds");
-        require(block.timestamp > lockTime[msg.sender], "Lock time not expired");
+        require(balances[msg.sender] > 0, "Fonds insuffisants");
+        require(block.timestamp > lockTime[msg.sender], "Le temps de verrouillage n'est pas expiré");
 
         uint amount = balances[msg.sender];
         balances[msg.sender] = 0;
 
         (bool sent, ) = msg.sender.call{value: amount}("");
-        require(sent, "Failed to send Ether");
+        require(sent, "Échec de l'envoi d'Ether");
     }
 }
 
@@ -419,11 +419,11 @@ contract Attack {
     function attack() public payable {
         timeLock.deposit{value: msg.value}();
         /*
-        if t = current lock time then we need to find x such that
+        si t = temps de verrouillage actuel, nous devons trouver x tel que
         x + t = 2**256 = 0
-        so x = -t
+        donc x = -t
         2**256 = type(uint).max + 1
-        so x = type(uint).max + 1 - t
+        donc x = type(uint).max + 1 - t
         */
         timeLock.increaseLockTime(
             type(uint).max + 1 - timeLock.lockTime(address(this))
@@ -435,15 +435,15 @@ contract Attack {
 
 ##### Comment éviter les soupassements et dépassements d'entier
 
-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.
+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 plus ancienne du compilateur doivent soit effectuer des vérifications sur les 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 les dépassements négatifs/positifs.
 
-#### Manipulation Oracle {#oracle-manipulation}
+#### Manipulation d'oracle {#oracle-manipulation}
 
-Les [oracles](/developers/docs/oracles/) utilisent des informations hors chaîne et les envoient sur la chaîne pour que les contrats intelligents puissent les 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, élargissant ainsi considérablement leur application.
+Les [oracles](/developers/docs/oracles/) collectent des informations hors chaîne et les envoient sur la chaîne pour que les contrats intelligents puissent les 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, élargissant ainsi considérablement leur application.
 
 Mais si l'oracle est corrompu et envoie des informations incorrectes sur la 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.
 
-L'utilisation d'un oracle sur la chaîne, tel qu'un échange décentralisé, pour obtenir le prix comptant d'un actif, pose un problème de sécurité connexe. 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.
+L'utilisation d'un oracle sur la chaîne, tel qu'un échange décentralisé, pour obtenir le prix comptant d'un actif, pose un problème de sécurité connexe. Les plateformes de prêt dans le secteur de la [finance décentralisée (DeFi)](/defi/) le font souvent pour déterminer la valeur de la garantie d'un utilisateur afin de déterminer combien il peut emprunter.
 
 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).
 
@@ -451,126 +451,126 @@ Par exemple, un attaquant pourrait artificiellement pomper le prix au comptant d
 
 ##### Comment éviter la manipulation d'oracle
 
-Le minimum requis pour [éviter la manipulation d'oracle](https://www.cyfrin.io/blog/price-oracle-manipultion-attacks-with-examples) est d'utiliser un réseau oracle décentralisé qui interroge des informations provenant de sources multiples pour éviter les 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.
+L'exigence minimale pour [éviter la manipulation d'oracle](https://www.cyfrin.io/blog/price-oracle-manipultion-attacks-with-examples) est d'utiliser un réseau d'oracles décentralisé qui interroge des informations provenant de plusieurs sources pour éviter les 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.
 
-Si vous comptez interroger un oracle sur la chaîne sur le prix des actifs, pensez à utiliser un mécanisme qui implémente un prix moyen pondéré (« Time Weighted Average Price », ou 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.
+Si vous comptez interroger un oracle sur la chaîne sur le prix des actifs, pensez à utiliser un mécanisme qui implémente un prix moyen pondéré (« Time Weighted Average Price », ou TWAP). Un [oracle TWAP](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) interroge le prix d'un actif à deux moments différents (que vous pouvez modifier) et calcule le prix au comptant sur la base 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.
 
-## Ressources de sécurité de contrats intelligents pour les développeurs {#smart-contract-security-resources-for-developers}
+## Ressources sur la sécurité des contrats intelligents pour les développeurs {#smart-contract-security-resources-for-developers}
 
-### Outils pour analyser les contrats intelligents et vérifier la justesse du code {#code-analysis-tools}
+### Outils pour analyser les contrats intelligents et vérifier l'exactitude du code {#code-analysis-tools}
 
-- **[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._
+- **[Outils et bibliothèques de test](/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 dynamiques sur les contrats intelligents._
 
-- **[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._
+- **[Outils de vérification formelle](/developers/docs/smart-contracts/formal-verification/#formal-verification-tools)** - _Outils pour vérifier l'exactitude fonctionnelle des contrats intelligents et contrôler les invariants._
 
-- **[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._
+- **[Services d'audit de contrats intelligents](/developers/docs/smart-contracts/testing/#smart-contract-auditing-services)** - _Liste d'organisations fournissant des services d'audit de contrats intelligents pour les projets de développement Ethereum._
 
-- **[Plateformes de récompenses de bugs](/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._
+- **[Plateformes de primes de bogues](/developers/docs/smart-contracts/testing/#bug-bounty-platforms)** - _Plateformes pour coordonner les primes de bogues et récompenser la divulgation responsable de vulnérabilités critiques dans les contrats intelligents._
 
-- **[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._
+- **[Fork Checker](https://forkchecker.hashex.org/)** - _Un outil en ligne gratuit pour vérifier toutes les informations disponibles concernant un contrat forké._
 
-- **[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._
+- **[ABI Encoder](https://abi.hashex.org/)** - _Un service en ligne gratuit pour encoder les fonctions de votre contrat Solidity et les arguments du constructeur._
 
-- **[Aderyn](https://github.com/Cyfrin/aderyn)** - _Analyseur statique de Solidity, parcourant les arbres de syntaxe abstraite (AST) pour repérer les vulnérabilités suspectes et imprimant les problèmes dans un format markdown facile à utiliser._
+- **[Aderyn](https://github.com/Cyfrin/aderyn)** - _Analyseur statique de Solidity, qui parcourt les arbres de syntaxe abstraite (AST) pour identifier les vulnérabilités suspectes et afficher les problèmes dans un format Markdown facile à consulter._
 
 ### Outils de surveillance des contrats intelligents {#smart-contract-monitoring-tools}
 
-- **[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._
+- **[Tenderly Real-Time Alerting](https://tenderly.co/monitoring)** - _Un outil pour recevoir des notifications en temps réel lorsque des événements inhabituels ou inattendus se produisent sur vos contrats intelligents ou vos portefeuilles._
 
-### Outils pour une administration sécurisée des contrats intelligents {#smart-contract-administration-tools}
+### Outils pour l'administration sécurisée des contrats intelligents {#smart-contract-administration-tools}
 
-- **[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)._
+- **[Safe](https://safe.global/)** - _Portefeuille de contrat intelligent fonctionnant sur Ethereum qui nécessite qu'un nombre minimum de personnes approuvent une transaction avant qu'elle ne puisse avoir lieu (M sur N)._
 
-- **[Contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/5.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._
+- **[Contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/)** - _Bibliothèques de contrats pour la mise en œuvre de fonctionnalités administratives, y compris la propriété des contrats, les mises à niveau, les contrôles d'accès, la gouvernance, la mise en pause, et plus encore._
 
-### Services d'audit pour contrat intelligent {#smart-contract-auditing-services}
+### Services d'audit de contrats intelligents {#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._
+- **[ConsenSys Diligence](https://diligence.consensys.io/)** - _Service d'audit de contrats intelligents aidant les projets de l'écosystème blockchain à s'assurer que leurs protocoles sont prêts à être lancés et conçus 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._
+- **[CertiK](https://www.certik.com/)** - _Entreprise de sécurité blockchain pionnière dans l'utilisation de la 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._
+- **[Trail of Bits](https://www.trailofbits.com/)** - _Entreprise de cybersécurité qui combine la recherche en sécurité avec une mentalité d'attaquant pour réduire les risques et renforcer 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._
+- **[PeckShield](https://peckshield.com/)** - _Société de sécurité blockchain proposant des produits et 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._
+- **[QuantStamp](https://quantstamp.com/)** - _Service d'audit facilitant l'adoption généralisée de la technologie blockchain par le biais de 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._
+- **[OpenZeppelin](https://www.openzeppelin.com/security-audits)** - _Société de sécurité de contrats intelligents 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._
+- **[Runtime Verification](https://runtimeverification.com/)** - _Société 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._
+- **[Hacken](https://hacken.io)** - _Auditeur en cybersécurité Web3 apportant une approche à 360 degrés à la sécurité de la blockchain._
 
-- **[Nethermind](https://www.nethermind.io/smart-contract-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._
+- **[Nethermind](https://www.nethermind.io/smart-contract-audits)** - _Services d'audit Solidity et Cairo, garantissant l'intégrité des contrats intelligents et la sécurité des utilisateurs sur 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._
+- **[HashEx](https://hashex.org/)** - _HashEx se concentre sur l'audit de la blockchain et des contrats intelligents pour garantir la sécurité des cryptomonnaies, en fournissant des services tels que le développement de contrats intelligents, les tests de pénétration, le conseil en blockchain._
 
-- **[Code4rena](https://code4rena.com/)** - _Une plateforme concurrentielle, réputée pour ses audits de sécurité, qui prête main forte aux experts garantissant la sécurité des smart-contracts, dans l'objectif commun d'œuvrer à la sécurisation du Web3. _
+- **[Code4rena](https://code4rena.com/)** - _Plateforme d'audit compétitive qui incite les experts en sécurité des contrats intelligents à trouver des vulnérabilités et à contribuer à rendre le web3 plus sécurisé._
 
 - **[CodeHawks](https://codehawks.com/)** - _Plateforme d'audits compétitifs hébergeant des concours d'audit de contrats intelligents pour les chercheurs en sécurité._
 
-- **[Cyfrin](https://cyfrin.io)** - _Puissante centrale de sécurité du Web3, veillant sur la sécurité cryptographique avec des produits et des services d'audit de contrats intelligents._
+- **[Cyfrin](https://cyfrin.io)** - _Référence en matière de sécurité Web3, incubant la sécurité crypto par le biais de produits et de services d'audit de contrats intelligents._
 
-- **[ImmuneBytes](https://immunebytes.com/smart-contract-audit/)** - _Entreprise de sécurité Web3 qui propose des audits de sécurité pour les systèmes de blockchain grâce à une équipe d'auditeurs expérimentés et des outils de premier plan._
+- **[ImmuneBytes](https://immunebytes.com/smart-contract-audit/)** - _Société de sécurité Web3 proposant des audits de sécurité pour les systèmes blockchain par le biais d'une équipe d'auditeurs expérimentés et d'outils de premier ordre._
 
-- **[Oxorio](https://oxor.io/)** - _Audits de contrats intelligents et services de sécurité blockchain avec expertise concernant l'EVM, Solidity, le ZK, la technologie inter-chaînes pour les entreprises de crypto et les projets de DeFi._
+- **[Oxorio](https://oxor.io/)** - _Audits de contrats intelligents et services de sécurité blockchain avec une expertise en EVM, Solidity, ZK, et technologie inter-chaînes pour les entreprises crypto et les projets DeFi._
 
-- **[Inference](https://inference.ag/)** - _Entreprise d'audit de sécurité spécialisée dans l'audit de contrats intelligents pour les blockchains basées sur l'EVM. Grâce à ces auditeurs experts, elle identifie les problèmes potentiels et suggèrent des solutions opérationnelles pour les régler avant leur déploiement. _
+- **[Inference](https://inference.ag/)** - _Société d'audit de sécurité, spécialisée dans l'audit de contrats intelligents pour les blockchains basées sur l'EVM. _Grâce à ses auditeurs experts, elle identifie les problèmes potentiels et suggère des solutions concrètes pour les corriger avant le déploiement._
 
-### Plateformes de récompense de bug {#bug-bounty-platforms}
+### Plateformes de primes de bogues {#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._
+- **[Immunefi](https://immunefi.com/)** - _Plateforme de primes de bogues pour les contrats intelligents et les projets DeFi, où les chercheurs en sécurité examinent le code, divulguent les vulnérabilités, sont payés et rendent la crypto plus sûre._
 
-- **[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é._
+- **[HackerOne](https://www.hackerone.com/)** - _Plateforme de coordination des vulnérabilités et de primes de bogues qui met en relation des entreprises avec des testeurs d'intrusion et des 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._
+- **[HackenProof](https://hackenproof.com/)** - _Plateforme de primes de bogues experte pour les projets crypto (DeFi, Contrats Intelligents, Portefeuilles, CEX et plus), où des professionnels de la sécurité fournissent des services de triage et où les chercheurs sont payés pour des rapports de bogues pertinents et vérifiés._
 
--  **[Sherlock](https://www.sherlock.xyz/)** - _Souscripteur en Web3 pour la sécurité des contrats intelligents, offrant des paiements pour les auditeurs gérés via des contrats intelligents pour garantir que les bugs pertinents soient payés équitablement._
+- **[Sherlock](https://www.sherlock.xyz/)** - _Souscripteur en Web3 pour la sécurité des contrats intelligents, avec des paiements pour les auditeurs gérés via des contrats intelligents pour garantir que les bogues pertinents sont payés équitablement._
 
--  **[CodeHawks](https://www.codehawks.com/)** - _Plateforme de primes de bugs compétitive où les auditeurs participent à des concours et défis de sécurité, et (bientôt) à leurs propres audits privés._
+- **[CodeHawks](https://www.codehawks.com/)** - _Plateforme compétitive de primes aux bogues où les auditeurs participent à des concours et à des défis de sécurité, et (bientôt) à leurs propres audits privés._
 
-### Publications de vulnérabilités connues de contrats intelligents et d'exploitations {#common-smart-contract-vulnerabilities-and-exploits}
+### Publications sur les vulnérabilités et exploits connus des contrats intelligents {#common-smart-contract-vulnerabilities-and-exploits}
 
-- **[ConsenSys : Attaques connues sur les contrats intelligents](https://consensysdiligence.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._
+- **[ConsenSys : Attaques connues sur les contrats intelligents](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/)** - _Explication conviviale pour les débutants des vulnérabilités de contrat les plus importantes, avec des exemples de code 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._
+- **[Registre SWC](https://swcregistry.io/)** - _Liste organisée d'éléments de l'énumération des faiblesses communes (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._
+- **[Rekt](https://rekt.news/)** - _Publication régulièrement mise à jour des piratages et exploits de crypto de premier plan, avec des rapports post-mortem détaillés._
 
 ### 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._
+- **[Awesome BlockSec CTF](https://github.com/blockthreat/blocksec-ctfs)** - _Liste organisée de wargames, de défis et de compétitions de [Capture du drapeau](https://www.webopedia.com/definitions/ctf-event/amp/) sur la sécurité de la blockchain, ainsi que des 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é »._
+- **[Ethernaut](https://ethernaut.openzeppelin.com/)** - _Wargame basé sur Web3/Solidity où chaque niveau est un contrat intelligent qui doit être « piraté »._
 
-- **[HackenProof x HackTheBox](https://app.hackthebox.com/tracks/HackenProof-Track)** - _Défi de piratage de contrats intelligents, situé dans le cadre d'une aventure fantastique. La résolution du défi donne également accès à un programme privé de primes de bugs._
+- **[HackenProof x HackTheBox](https://app.hackthebox.com/tracks/HackenProof-Track)** - _Défi de piratage de contrats intelligents, situé dans une aventure fantastique. La résolution du défi donne également accès à un programme privé de primes de bugs._
 
-### Meilleures pratiques pour sécuriser les contrats intelligents {#smart-contract-security-best-practices}
+### Meilleures pratiques pour la sécurisation des 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._
+- **[ConsenSys : Meilleures pratiques en matière de sécurité des 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._
+- **[Modèles Solidity](https://fravoll.github.io/solidity-patterns/)** - _Compilation utile de modèles sécurisés et de meilleures pratiques pour Solidity, le langage de programmation de contrats intelligents._
 
-- **[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._
+- **[Documents Solidity : Considérations de sécurité](https://docs.soliditylang.org/en/v0.8.16/security-considerations.html)** - _Lignes directrices 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._
+- **[Norme de vérification de la sécurité des contrats intelligents](https://github.com/securing/SCSVS)** - _Liste de contrôle en quatorze parties créée pour normaliser la sécurité des contrats intelligents pour les développeurs, les architectes, les auditeurs de sécurité et les fournisseurs._
 
-- **[Apprendre la sécurité et l'audit des contrats intelligents](https://updraft.cyfrin.io/courses/security)**- _Le cours ultime sur la sécurité et l'audit des contrats intelligents, conçu pour les développeurs de contrats intelligents souhaitant améliorer leurs pratiques en matière de sécurité et devenir des chercheurs en sécurité._
+- **[Apprendre la sécurité et l'audit des contrats intelligents](https://updraft.cyfrin.io/courses/security)** - _Le cours ultime sur la sécurité et l'audit des contrats intelligents, créé pour les développeurs de contrats intelligents qui cherchent à améliorer leurs meilleures pratiques en matière de sécurité et à devenir des chercheurs en sécurité._
 
 ### 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/)
+- [Comment utiliser Slither pour trouver des 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/)
+- [Comment utiliser Manticore pour trouver des bogues dans les contrats intelligents](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
 
-- [Directives de sécurité pour les contrats intelligents](/developers/tutorials/smart-contract-security-guidelines/)
+- [Lignes directrices sur la sécurité des 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/)
+- [Comment intégrer en toute sécurité votre contrat de jeton avec des jetons arbitraires](/developers/tutorials/token-integration-checklist/)
 
 - [Cyfrin Updraft - Cours complet sur la sécurité et l'audit des contrats intelligents](https://updraft.cyfrin.io/courses/security)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/testing/index.md b/public/content/translations/fr/developers/docs/smart-contracts/testing/index.md
index d680bc03559..fc88bb23db2 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/testing/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/testing/index.md
@@ -1,40 +1,41 @@
 ---
 title: Tester les contrats intelligents
-description: Un aperçu des techniques et des considérations à prendre en compte pour tester les contrats intelligents Ethereum.
+description: "Un aperçu des techniques et des considérations à prendre en compte pour tester les contrats intelligents Ethereum."
 lang: fr
 ---
 
-Les blockchains publiques comme Ethereum sont immuables, ce qui rend difficile le changement de code des contrats intelligents après le déploiement. [Les modèles de mise à niveau du contrat](/developers/docs/smart-contracts/upgrading/) pour effectuer des « mises à niveau virtuelles » existent, or celles-ci sont difficiles à mettre en œuvre et nécessitent un consensus social. De plus, une mise à jour ne peut corriger une erreur _qu'après_ sa découverte. Si un attaquant découvre la vulnérabilité en premier, votre contrat intelligent risque d'être exploité.
+Les blockchains publiques comme Ethereum sont immuables, ce qui rend difficile le changement de code des contrats intelligents après le déploiement. [Les modèles de mise à niveau des contrats](/developers/docs/smart-contracts/upgrading/) pour effectuer des « mises à niveau virtuelles » existent, mais ils sont difficiles à mettre en œuvre et nécessitent un consensus social. De plus, une mise à niveau ne peut corriger une erreur qu'_après_ sa découverte — si un attaquant découvre la vulnérabilité en premier, votre contrat intelligent risque d'être exploité.
 
-Pour ces raisons, tester les contrats intelligents avant [le déploiement](/developers/docs/smart-contracts/deploying/) sur le réseau principal est une exigence minimale pour la [sécurité](/developers/docs/smart-contracts/security/). Il existe de nombreuses techniques pour tester les contrats et évaluer la justesse du code ; ce que vous choisissez dépend de vos besoins. Néanmoins, une suite de tests composée d'outils et d'approches différents est idéale pour attraper des défauts de sécurité mineurs et majeurs dans le code contractuel.
+Pour ces raisons, le test des contrats intelligents avant leur [déploiement](/developers/docs/smart-contracts/deploying/) sur le Mainnet est une exigence minimale pour la [sécurité](/developers/docs/smart-contracts/security/). Il existe de nombreuses techniques pour tester les contrats et évaluer la justesse du code ; ce que vous choisissez dépend de vos besoins. Néanmoins, une suite de tests composée d'outils et d'approches différents est idéale pour attraper des défauts de sécurité mineurs et majeurs dans le code contractuel.
 
 ## Prérequis {#prerequisites}
 
-Cette page explique comment tester les contrats intelligents avant le déploiement sur le réseau Ethereum. Cela suppose que vous êtes familier avec les [contrats intelligents](/developers/docs/smart-contracts/).
+Cette page explique comment tester les contrats intelligents avant le déploiement sur le réseau Ethereum. Ce document suppose que vous êtes familier avec les [contrats intelligents](/developers/docs/smart-contracts/).
 
 ## Qu'est-ce que le test de contrats intelligents ? {#what-is-smart-contract-testing}
 
 Les tests de contrats intelligents sont le processus de vérification que le code d'un contrat intelligent fonctionne comme prévu. Les tests sont utiles pour vérifier si un contrat intelligent particulier satisfait aux exigences de fiabilité, d'utilisabilité et de sécurité.
 
-Bien que les méthodes de test soient différentes, la plupart des méthodes de test nécessitent l'exécution d'un contrat intelligent avec un petit échantillon de données qu'il est censé gérer. Si le contrat produit des résultats corrects pour les données d'échantillonnage, il est supposé fonctionner correctement. La plupart des outils de test fournissent des ressources pour écrire et exécuter des [cas de test](https://en.m.wikipedia.org/wiki/Test_case) pour vérifier si une exécution de contrats correspond aux résultats attendus.
+Bien que les méthodes de test soient différentes, la plupart des méthodes de test nécessitent l'exécution d'un contrat intelligent avec un petit échantillon de données qu'il est censé gérer. Si le contrat produit des résultats corrects pour les données d'échantillonnage, il est supposé fonctionner correctement. La plupart des outils de test fournissent des ressources pour l'écriture et l'exécution de [cas de test](https://en.m.wikipedia.org/wiki/Test_case) afin de vérifier si l'exécution d'un contrat correspond aux résultats attendus.
 
-### Pourquoi est-il important de tester les contrats intelligents ? {#importance-of-testing-smart-contracts}
+### Pourquoi est-il important de tester les contrats intelligents ? Importance des tests de contrats intelligents {#importance-of-testing-smart-contracts}
 
-Comme les contrats intelligents gèrent souvent les actifs financiers de grande valeur, des erreurs de programmation mineures peuvent entraîner et entraînent souvent des [pertes massives pour les utilisateurs](https://rekt.news/leaderboard/). Des tests rigoureux peuvent toutefois vous aider à découvrir rapidement les défauts d'un code de contrats intelligents et à les corriger avant de se lancer sur le réseau principal.
+Comme les contrats intelligents gèrent souvent des actifs financiers de grande valeur, des erreurs de programmation mineures peuvent entraîner, et entraînent souvent, des [pertes massives pour les utilisateurs](https://rekt.news/leaderboard/). Des tests rigoureux peuvent toutefois vous aider à découvrir rapidement les défauts d'un code de contrats intelligents et à les corriger avant de se lancer sur le réseau principal.
 
-Tant qu'il est possible de mettre à jour un contrat si un bogue est découvert, les mises à jour sont complexes et peuvent [entraîner des erreurs](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) si elles sont mal gérées. La mise à niveau d'un contrat annule encore le principe de l'immutabilité et charge les utilisateurs avec des hypothèses de confiance supplémentaires. Inversement, un plan complet de test de votre contrat atténue les risques de sécurité des contrats intelligents et réduit le besoin d'effectuer des mises à niveau logiques complexes après le déploiement.
+Même s'il est possible de mettre à niveau un contrat si un bug est découvert, les mises à niveau sont complexes et peuvent [entraîner des erreurs](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) si elles sont mal gérées. La mise à niveau d'un contrat annule encore le principe de l'immutabilité et charge les utilisateurs avec des hypothèses de confiance supplémentaires. Inversement, un plan complet de test de votre contrat atténue les risques de sécurité des contrats intelligents et réduit le besoin d'effectuer des mises à niveau logiques complexes après le déploiement.
 
-## Méthodes pour tester les contrats intelligents {#methods-for-testing-smart-contracts}
+## Méthodes de test des contrats intelligents {#methods-for-testing-smart-contracts}
 
-Les méthodes de test des contrats intelligents sur Ethereum se distinguent en deux grandes catégories : **les tests automatisés** et les **tests manuels**. Les tests automatisés et les tests manuels offrent des avantages et des compromis uniques, mais vous pouvez combiner les deux pour créer un plan solide pour l'analyse de vos contrats.
+Les méthodes de test des contrats intelligents Ethereum se divisent en deux grandes catégories : les **tests automatisés** et les **tests manuels**. Les tests automatisés et les tests manuels offrent des avantages et des compromis uniques, mais vous pouvez combiner les deux pour créer un plan solide pour l'analyse de vos contrats.
 
-### Les tests automatisés {#automated-testing}
+### Test automatisé {#automated-testing}
 
-Les tests automatisés utilisent des outils qui vérifient automatiquement un code de contrats intelligents pour détecter des erreurs dans l'exécution. L'avantage des tests automatisés vient de l'utilisation de [scripts](https://www.techtarget.com/whatis/definition/script?amp=1) pour guider l'évaluation des fonctionnalités contractuelles. Les tests scriptés peuvent être programmés aux fins d'une exécution répétée avec une intervention humaine minimale, rendant les tests automatisés plus efficaces que les approches manuelles de test.
+Les tests automatisés utilisent des outils qui vérifient automatiquement un code de contrats intelligents pour détecter des erreurs dans l'exécution. L'avantage des tests automatisés vient de l'utilisation de [scripts](https://www.techtarget.com/whatis/definition/script?amp=1) pour guider l'évaluation des fonctionnalités du contrat. Les tests scriptés peuvent être programmés aux fins d'une exécution répétée avec une intervention humaine minimale, rendant les tests automatisés plus efficaces que les approches manuelles de test.
 
-Les tests automatisés sont particulièrement utiles lorsque les tests sont répétitifs et prennent du temps ; difficile à exécuter manuellement ; sensible aux erreurs humaines ; ou nécessitant une évaluation des fonctions critiques du contrat. Mais les outils de test automatisés peuvent avoir des inconvénients : ils peuvent manquer certains bogues et produire beaucoup de [faux positifs](https://www.contrastsecurity.com/glossary/false-positive). Par conséquent, l'association des tests automatisés avec des tests manuels pour les contrats intelligents est idéale.
+Les tests automatisés sont particulièrement utiles lorsque les tests sont répétitifs et prennent du temps ; difficile à exécuter manuellement ; sensible aux erreurs humaines ; ou nécessitant une évaluation des fonctions critiques du contrat.
+Mais les outils de test automatisé peuvent avoir des inconvénients — ils peuvent manquer certains bugs et produire de nombreux [faux positifs](https://www.contrastsecurity.com/glossary/false-positive). Par conséquent, l'association des tests automatisés avec des tests manuels pour les contrats intelligents est idéale.
 
-### Les tests manuels {#manual-testing}
+### Test manuel {#manual-testing}
 
 Les tests manuels sont aidés par l'homme et impliquent l'exécution de chaque cas de test dans votre suite de tests l'un après l'autre lors de l'analyse de la justesse des contrats intelligents. Ceci est différent des tests automatisés, où vous pouvez exécuter simultanément plusieurs tests isolés sur un contrat et obtenir un rapport montrant tous les échecs et réussissant les tests.
 
@@ -42,21 +43,21 @@ Les tests manuels peuvent être effectués par un seul individu, suivant un plan
 
 Des tests manuels efficaces requièrent des ressources considérables (compétences, temps, argent et efforts), et il est possible, en raison d'erreurs humaines, de manquer certaines erreurs lors de l'exécution des tests. Mais les tests manuels peuvent aussi être bénéfiques — par exemple, un test humain (p. ex. un vérificateur) peut utiliser l'intuition pour détecter les cas où un outil de test automatique manquerait.
 
-## Les méthodes de test automatiques pour les contrats intelligents {#automated-testing-for-smart-contracts}
+## Tests automatisés pour les contrats intelligents {#automated-testing-for-smart-contracts}
 
-### Tests unitaires {#unit-testing-for-smart-contracts}
+### Test unitaire {#unit-testing-for-smart-contracts}
 
 Les tests unitaires évaluent séparément les fonctions contractuelles et vérifient que chaque composant fonctionne correctement. Un test unitaire est simple, rapide à exécuter et donne une idée précise de ce qui s'est mal passé si le test échoue.
 
 Les tests unitaires sont utiles pour vérifier que les fonctions retournent les valeurs attendues et que le stockage du contrat est correctement mis à jour après l'exécution de la fonction. En outre, l'exécution de tests unitaires après avoir apporté des modifications à une base de code de contrats garantit que l'ajout de nouvelles logiques n'introduit pas d'erreurs. Voici quelques directives pour exécuter des tests unitaires efficaces :
 
-#### Lignes directrices pour le test unitaire des contrats intelligents {#unit-testing-guidelines}
+#### Lignes directrices pour les tests unitaires de contrats intelligents {#unit-testing-guidelines}
 
 ##### 1. Comprendre la logique et le flux de travail de vos contrats
 
-Avant d'écrire des tests unitaires, il aide à savoir quelles fonctionnalités un contrat intelligent offre et comment les utilisateurs accèderont et utiliseront ces fonctions. Ceci est particulièrement utile pour exécuter des [tests de chemin heureux](https://en.m.wikipedia.org/wiki/Happy_path) qui déterminent si les fonctions dans un contrat retournent la sortie correcte pour les entrées utilisateur valides. Nous allons expliquer ce concept en utilisant cet exemple (abrégé) d'[un contrat de vente aux enchères](https://docs.soliditylang.org/en/v0.8.17/solidity-by-example.html?highlight=Auction%20contract#simple-open-auction)
+Avant d'écrire des tests unitaires, il aide à savoir quelles fonctionnalités un contrat intelligent offre et comment les utilisateurs accèderont et utiliseront ces fonctions. Ceci est particulièrement utile pour exécuter des [tests de chemin nominal](https://en.m.wikipedia.org/wiki/Happy_path) qui déterminent si les fonctions d'un contrat renvoient le résultat correct pour des entrées utilisateur valides. Nous allons expliquer ce concept à l'aide de cet exemple (abrégé) d'[un contrat de vente aux enchères](https://docs.soliditylang.org/en/v0.8.17/solidity-by-example.html?highlight=Auction%20contract#simple-open-auction)
 
-```
+```solidity
 constructor(
         uint biddingTime,
         address payable beneficiaryAddress
@@ -108,11 +109,11 @@ function auctionEnd() external {
 }
 ```
 
-Il s'agit d'un simple contrat de vente aux enchères conçu pour recevoir des offres pendant la période d'enchère. Si le `highestBid` augmente, le précédent plus offrant reçoit son argent ; une fois la période d'enchères terminée, le `beneficiary` appelle le contrat pour récupérer son argent.
+Il s'agit d'un simple contrat de vente aux enchères conçu pour recevoir des offres pendant la période d'enchère. Si le `highestBid` augmente, l'enchérisseur le plus offrant précédent reçoit son argent ; une fois la période d'enchères terminée, le `beneficiary` appelle le contrat pour récupérer son argent.
 
-Les tests unitaires pour un contrat comme celui-ci couvriraient différentes fonctions qu'un utilisateur peut appeler lorsqu'il interagit avec le contrat. Il peut s'agir, par exemple, d'un test unitaire qui vérifie si un utilisateur peut placer une enchère pendant que l'enchère est en cours (c'est-à-dire que les appels à `bid()` réussissent) ou d'un test qui vérifie si un utilisateur peut placer une enchère plus élevée que le `highestBid` actuel.
+Les tests unitaires pour un contrat comme celui-ci couvriraient différentes fonctions qu'un utilisateur peut appeler lorsqu'il interagit avec le contrat. Un exemple serait un test unitaire qui vérifie si un utilisateur peut placer une enchère pendant que la vente aux enchères est en cours (c'est-à-dire que les appels à `bid()` réussissent) ou un test qui vérifie si un utilisateur peut placer une enchère plus élevée que le `highestBid` actuel.
 
-Comprendre le flux de travail opérationnel d'un contrat facilite également la rédaction de tests unitaires qui vérifient si l'exécution répond aux exigences. Par exemple, le contrat d'enchère spécifie que les utilisateurs ne peuvent pas placer d'enchères une fois l'enchère terminée (c'est-à-dire lorsque `auctionEndTime` est inférieur à `block.timestamp`). Ainsi, un développeur peut exécuter un test unitaire qui vérifie si les appels à la fonction `bid()` réussissent ou échouent lorsque la vente aux enchères est terminée (à savoir, quand `auctionEndTime` > `block.timestamp`).
+Comprendre le flux de travail opérationnel d'un contrat facilite également la rédaction de tests unitaires qui vérifient si l'exécution répond aux exigences. Par exemple, le contrat de vente aux enchères spécifie que les utilisateurs ne peuvent pas placer d'offres lorsque la vente aux enchères est terminée (c'est-à-dire lorsque `auctionEndTime` est inférieur à `block.timestamp`). Ainsi, un développeur peut exécuter un test unitaire qui vérifie si les appels à la fonction `bid()` réussissent ou échouent lorsque la vente aux enchères est terminée (c'est-à-dire lorsque `auctionEndTime` > `block.timestamp`).
 
 ##### 2. Évaluer toutes les hypothèses liées à l'exécution du contrat
 
@@ -126,11 +127,11 @@ De nombreux frameworks de tests unitaires vous permettent de créer des assertio
 
 - Les utilisateurs qui ne gagnent pas l'enchère sont crédités de leurs fonds
 
-**Remarque** : Une autre façon de tester les hypothèses consiste à écrire des tests qui déclenchent des [modificateurs de fonction](https://docs.soliditylang.org/en/v0.8.16/contracts.html#function-modifiers) dans un contrat, en particulier les instructions `require`, `assert` et `if…else`.
+**Remarque** : une autre façon de tester les hypothèses est d'écrire des tests qui déclenchent des [modificateurs de fonction](https://docs.soliditylang.org/en/v0.8.16/contracts.html#function-modifiers) dans un contrat, en particulier les instructions `require`, `assert`, et `if…else`.
 
 ##### 3. Mesurer la couverture du code
 
-[La couverture de code](https://en.m.wikipedia.org/wiki/Code_coverage) est une métrique de test qui suit le nombre de branches, de lignes et d'instructions dans votre code exécuté lors des tests. Les tests devraient avoir une bonne couverture de code pour minimiser le risque de vulnérabilités non testées. Sans une couverture suffisante, vous pourriez à tort supposer que votre contrat est sécurisé parce que tous les tests réussissent, alors que des vulnérabilités existent encore dans des chemins de code non testés. L'enregistrement d'une couverture de code élevée donne toutefois l'assurance que toutes les déclarations/fonctions d'un contrat intelligent ont été suffisamment testées pour être correctes.
+La [couverture du code](https://en.m.wikipedia.org/wiki/Code_coverage) est une métrique de test qui suit le nombre de branches, de lignes et d'instructions de votre code exécutées pendant les tests. Les tests devraient avoir une bonne couverture de code pour minimiser le risque de vulnérabilités non testées. Sans une couverture suffisante, vous pourriez à tort supposer que votre contrat est sécurisé parce que tous les tests réussissent, alors que des vulnérabilités existent encore dans des chemins de code non testés. L'enregistrement d'une couverture de code élevée donne toutefois l'assurance que toutes les déclarations/fonctions d'un contrat intelligent ont été suffisamment testées pour être correctes.
 
 ##### 4. Utiliser des frameworks de test bien développés
 
@@ -139,8 +140,8 @@ La qualité des outils utilisés pour exécuter des tests unitaires pour vos con
 Les frameworks de test unitaires pour les contrats intelligents Solidity sont disponibles en différents langages (principalement JavaScript, Python et Rust). Voir certains des guides ci-dessous pour plus d'informations sur la façon de commencer à exécuter des tests unitaires avec différents frameworks de test :
 
 - **[Exécution de tests unitaires avec Brownie](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)**
-- **[Exécution des tests unitaires avec Foundry](https://book.getfoundry.sh/forge/writing-tests)**
-- **[Exécution de tests unitaires avec Truffe](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)**
+- **[Exécution de tests unitaires avec Foundry](https://book.getfoundry.sh/forge/writing-tests)**
+- **[Exécution de tests unitaires avec Waffle](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)**
 - **[Exécution de tests unitaires avec Remix](https://remix-ide.readthedocs.io/en/latest/unittesting.html#write-tests)**
 - **[Exécution de tests unitaires avec Ape](https://docs.apeworx.io/ape/stable/userguides/testing.html)**
 - **[Exécution de tests unitaires avec Hardhat](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)**
@@ -148,56 +149,56 @@ Les frameworks de test unitaires pour les contrats intelligents Solidity sont di
 
 ### Tests d'intégration {#integration-testing-for-smart-contracts}
 
-Alors que les tests unitaires déboguent les fonctions du contrat de manière isolée, les tests d'intégration évaluent les composants d'un contrat intelligent dans son ensemble. Les tests d'intégration peuvent détecter les problèmes liés aux appels intercontractuels ou aux interactions entre différentes fonctions dans le même contrat intelligent. Par exemple, les tests d'intégration peuvent aider à vérifier si des choses comme [l'héritage](https://docs.soliditylang.org/en/v0.8.12/contracts.html#inheritance) et l'injection de dépendance fonctionnent correctement.
+Alors que les tests unitaires déboguent les fonctions du contrat de manière isolée, les tests d'intégration évaluent les composants d'un contrat intelligent dans son ensemble. Les tests d'intégration peuvent détecter les problèmes liés aux appels intercontractuels ou aux interactions entre différentes fonctions dans le même contrat intelligent. Par exemple, les tests d'intégration peuvent aider à vérifier si des éléments comme l'[héritage](https://docs.soliditylang.org/en/v0.8.12/contracts.html#inheritance) et l'injection de dépendances fonctionnent correctement.
 
-Les tests d'intégration sont utiles si votre contrat adopte une architecture modulaire ou des interfaces avec d'autres contrats en chaîne pendant l'exécution. Une façon d'exécuter des tests d'intégration consiste à [fourcher la blockchain](/glossary/#fork) à une hauteur spécifique (en utilisant un outil tel que [Forge](https://book.getfoundry.sh/forge/fork-testing) ou [Hardhat](https://hardhat.org/hardhat-network/docs/guides/forking-other-networks)) et simuler les interactions entre votre contrat et les contrats déployés.
+Les tests d'intégration sont utiles si votre contrat adopte une architecture modulaire ou des interfaces avec d'autres contrats en chaîne pendant l'exécution. Une façon de lancer des tests d'intégration est de [créer une fourche de la blockchain](/glossary/#fork) à une hauteur spécifique (en utilisant un outil comme [Forge](https://book.getfoundry.sh/forge/fork-testing) ou [Hardhat](https://hardhat.org/hardhat-network/docs/guides/forking-other-networks)) et de simuler les interactions entre votre contrat et les contrats déployés.
 
 La blockchain forkée se comportera de la même manière que le réseau principal et aura des comptes avec des états et des soldes associés. Mais cela ne fonctionne que comme un environnement de développement local en bac à sable, ce qui signifie que vous n'aurez pas besoin d'un véritable ETH pour les transactions, par exemple, vos changements n'affecteront pas non plus le véritable protocole Ethereum.
 
-### Fuzzing orienté propriétés {#property-based-testing-for-smart-contracts}
+### Tests basés sur les propriétés {#property-based-testing-for-smart-contracts}
 
 Les tests basés sur les propriétés sont le processus permettant de vérifier qu'un contrat intelligent satisfait à une propriété définie. Les propriétés affirment des faits sur le comportement d'un contrat qui devraient rester vrais dans différents scénarios. Un exemple de propriété de contrat intelligent pourrait être « Les opérations arithmétiques dans le contrat ne soupassent ou ne dépassent jamais ».
 
-**L'analyse statique** et **l'analyse dynamique** sont deux techniques communes pour exécuter des tests basés sur la propriété, et les deux peuvent vérifier que le code d'un programme (un contrat intelligent dans ce cas) satisfait certaines propriétés prédéfinies. Certains outils de test fondés sur la propriété sont fournis avec des règles prédéfinies sur les propriétés de contrat attendues et vérifient le code par rapport à ces règles, tandis que d'autres vous permettent de créer des propriétés personnalisées pour un contrat intelligent.
+L'**analyse statique** et l'**analyse dynamique** sont deux techniques courantes pour l'exécution des tests basés sur les propriétés, et toutes deux peuvent vérifier que le code d'un programme (un contrat intelligent dans ce cas) satisfait une propriété prédéfinie. Certains outils de test fondés sur la propriété sont fournis avec des règles prédéfinies sur les propriétés de contrat attendues et vérifient le code par rapport à ces règles, tandis que d'autres vous permettent de créer des propriétés personnalisées pour un contrat intelligent.
 
 #### Analyse statique {#static-analysis}
 
 Un analyseur statique prend comme intrants le code source d'un contrat intelligent et les résultats indiquant si un contrat satisfait ou non une propriété. Contrairement à l’analyse dynamique, l’analyse statique n’implique pas d’exécuter un contrat pour l’analyser à des fins d'exactitude. L'analyse statique explique plutôt tous les chemins possibles qu'un contrat intelligent pourrait prendre pendant l'exécution (c'est-à-dire en examinant la structure du code source pour déterminer ce que cela signifierait pour l'opération des contrats à l'exécution).
 
-[Linting](https://www.perforce.com/blog/qac/what-lint-code-and-why-linting-important) et [tests statiques](https://www.techtarget.com/whatis/definition/static-analysis-static-code-analysis) sont des méthodes courantes pour exécuter des analyses statiques sur des contrats. Les deux nécessitent l'analyse de représentations de bas niveau d'une exécution de contrats telles que [les arbres de syntaxe abstraits](https://en.m.wikipedia.org/wiki/Abstract_syntax_tree) et [les courbes de flux de contrôle](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/amp/) sorties par le compilateur.
+Le [linting](https://www.perforce.com/blog/qac/what-is-linting) et les [tests statiques](https://www.techtarget.com/whatis/definition/static-analysis-static-code-analysis) sont des méthodes courantes pour effectuer une analyse statique des contrats. Les deux nécessitent l'analyse des représentations de bas niveau de l'exécution d'un contrat, telles que les [arbres de syntaxe abstraite](https://en.m.wikipedia.org/wiki/Abstract_syntax_tree) et les [graphes de contrôle de flux](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/amp/) produits par le compilateur.
 
 Dans la plupart des cas, l'analyse statique est utile pour détecter les problèmes de sécurité tels que l'utilisation de constructions non sûres, les erreurs de syntaxe, ou les violations des normes de codage dans un code de contrats. Cependant, les analyseurs statiques sont généralement peu sains lorsqu'ils détectent des vulnérabilités plus profondes et peuvent produire des faux positifs excessifs.
 
 #### Analyse dynamique {#dynamic-analysis}
 
-L'analyse dynamique génère des entrées symboliques (par exemple, en [exécution symbolique](https://en.m.wikipedia.org/wiki/Symbolic_execution)) ou des entrées concrètes (par ex. dans [fuzzing](https://owasp.org/www-community/Fuzzing)) vers les fonctions d'un contrat intelligent pour voir si une trace d'exécution enfreint des propriétés spécifiques. Cette forme de tests fondés sur des propriétés diffère des tests unitaires dans ces cas de tests couvrant plusieurs scénarios et un programme gère la génération de cas de test.
+L'analyse dynamique génère des entrées symboliques (par exemple, en [exécution symbolique](https://en.m.wikipedia.org/wiki/Symbolic_execution)) ou des entrées concrètes (par exemple, en [fuzzing](https://owasp.org/www-community/Fuzzing)) pour les fonctions d'un contrat intelligent afin de voir si une ou plusieurs traces d'exécution violent des propriétés spécifiques. Cette forme de tests fondés sur des propriétés diffère des tests unitaires dans ces cas de tests couvrant plusieurs scénarios et un programme gère la génération de cas de test.
 
-[Fuzzing](https://halborn.com/what-is-fuzz-testing-fuzzing/) est un exemple de technique d'analyse dynamique pour vérifier des propriétés arbitraires dans des contrats intelligents. Un fuzzer invoque des fonctions dans un contrat cible avec des variations aléatoires ou malformées d'une valeur d'input définie. Si le contrat intelligent entre un état d'erreur (par ex. où une assertion échoue), le problème est marqué et les entrées qui conduisent l'exécution vers le chemin vulnérable sont produites dans un rapport.
+Le [fuzzing](https://www.halborn.com/blog/post/what-is-fuzz-testing-fuzzing) est un exemple de technique d'analyse dynamique pour vérifier des propriétés arbitraires dans les contrats intelligents. Un fuzzer invoque des fonctions dans un contrat cible avec des variations aléatoires ou malformées d'une valeur d'input définie. Si le contrat intelligent entre un état d'erreur (par ex. où une assertion échoue), le problème est marqué et les entrées qui conduisent l'exécution vers le chemin vulnérable sont produites dans un rapport.
 
 Le fuzzing est utile pour évaluer un mécanisme de validation des entrées des contrats intelligents car la mauvaise gestion des entrées inattendues peut entraîner une exécution imprévue et produire des effets dangereux. Cette forme de tests fondés sur les propriétés peut être idéale pour de nombreuses raisons :
 
-1. **L'écriture de cas de test pour couvrir de nombreux scénarios est difficile.** Un test de propriété nécessite seulement que vous définissiez un comportement et une plage de données pour tester le comportement — le programme génère automatiquement des cas de test basés sur la propriété définie.
+1. **Il est difficile de rédiger des cas de test pour couvrir de nombreux scénarios.** Un test basé sur les propriétés exige uniquement que vous définissiez un comportement et un éventail de données avec lesquelles tester ce comportement — le programme génère automatiquement des cas de test basés sur la propriété définie.
 
-2. **Votre suite de tests ne peut pas couvrir suffisamment tous les chemins possibles dans le programme.** Même avec une couverture de 100 %, il est possible de passer à côté de cas extrêmes.
+2. **Votre suite de tests peut ne pas couvrir suffisamment tous les chemins possibles dans le programme.** Même avec une couverture à 100 %, il est possible de manquer des cas limites.
 
-3. **Les tests unitaires prouvent qu'un contrat s'exécute correctement pour des données d'échantillon, mais si le contrat s'exécute correctement pour des entrées en dehors de l'échantillon reste inconnu.** Les tests de propriété exécutent un contrat cible avec de multiples variations d'une valeur d'entrée donnée pour trouver des traces d'exécution qui causent des défaillances d'assertion. Ainsi, un test de propriété fournit plus de garanties qu'un contrat s'exécute correctement pour une vaste classe de données d'intrants.
+3. **Les tests unitaires prouvent qu'un contrat s'exécute correctement pour un échantillon de données, mais l'on ne sait pas si le contrat s'exécute correctement pour des entrées en dehors de cet échantillon.** Les tests basés sur les propriétés exécutent un contrat cible avec de multiples variations d'une valeur d'entrée donnée pour trouver des traces d'exécution qui provoquent des échecs d'assertion. Ainsi, un test de propriété fournit plus de garanties qu'un contrat s'exécute correctement pour une vaste classe de données d'intrants.
 
-### Lignes directrices pour l'exécution de tests fondés sur les propriétés pour les contrats intelligents {#running-property-based-tests}
+### Lignes directrices pour l'exécution de tests basés sur les propriétés pour les contrats intelligents {#running-property-based-tests}
 
-L'exécution de tests basés sur les propriétés commence généralement par la définition d'une propriété (par ex. absence de [dépassements d'entier](https://github.com/ConsenSys/mythril/wiki/Integer-Overflow)) ou de collections de propriétés que vous voulez vérifier dans un contrat intelligent. Vous pouvez également avoir besoin de définir une plage de valeurs dans laquelle le programme peut générer des données pour les entrées de transaction lors de l'écriture de tests de propriété.
+L'exécution de tests basés sur les propriétés commence généralement par la définition d'une propriété (par exemple, l'absence de [dépassements d'entiers](https://github.com/ConsenSys/mythril/wiki/Integer-Overflow)) ou d'un ensemble de propriétés que vous voulez vérifier dans un contrat intelligent. Vous pouvez également avoir besoin de définir une plage de valeurs dans laquelle le programme peut générer des données pour les entrées de transaction lors de l'écriture de tests de propriété.
 
 Une fois configuré correctement, l'outil de test de propriété exécutera vos fonctions de contrats intelligents avec des entrées générées aléatoirement. S'il y a des violations d'assertion, vous devriez obtenir un rapport avec des données d'entrée concrètes qui enfreint la propriété en cours d'évaluation. Consultez certains des guides ci-dessous pour commencer avec des tests basés sur les propriétés en cours d'exécution avec différents outils :
 
-- **[Analyse statique des contrats intelligents avec Slither](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/slither#slither)**
+- **[Analyse statique des contrats intelligents avec Slither](https://github.com/crytic/slither)**
 - **[Analyse statique des contrats intelligents avec Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)**
-- **[Tests fondés sur les propriétés avec Brownie](https://eth-brownie.readthedocs.io/en/stable/tests-hypothesis-property.html)**
-- **[Fuzzing des contrats avec Foundry](https://book.getfoundry.sh/forge/fuzz-testing)**
-- **[Fuzzing des contrats avec Echidna](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial)**
-- **[Contrats de fuzzing avec Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/fuzzing/)**
+- **[Tests basés sur les propriétés avec Brownie](https://eth-brownie.readthedocs.io/en/stable/tests-hypothesis-property.html)**
+- **[Fuzzing de contrats avec Foundry](https://book.getfoundry.sh/forge/fuzz-testing)**
+- **[Fuzzing de contrats avec Echidna](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial)**
+- **[Fuzzing de contrats avec Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/fuzzing/)**
 - **[Exécution symbolique de contrats intelligents avec Manticore](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore#manticore-tutorial)**
 - **[Exécution symbolique de contrats intelligents avec Mythril](https://mythril-classic.readthedocs.io/en/master/tutorial.html)**
 
-## Test manuel pour les contrats intelligents {#manual-testing-for-smart-contracts}
+## Tests manuels pour les contrats intelligents {#manual-testing-for-smart-contracts}
 
 Les tests manuels des contrats intelligents arrivent souvent plus tard dans le cycle de développement après avoir exécuté des tests automatisés. Un système évalue le contrat intelligent comme un produit totalement intégré pour voir s'il se déroule comme spécifié dans les exigences techniques.
 
@@ -207,13 +208,13 @@ Alors que les tests automatisés effectués dans un environnement de développem
 
 Tester votre contrat sur une blockchain locale (également connue sous le nom de [réseau de développement](/developers/docs/development-networks/)) est une alternative recommandée aux tests sur le réseau principal. Une blockchain locale est une copie de la blockchain Ethereum fonctionnant localement sur votre ordinateur qui simule le comportement de la couche d'exécution d'Ethereum. À ce titre, vous pouvez programmer des transactions pour interagir avec un contrat sans encourir de frais généraux importants.
 
-Exécuter des contrats sur une blockchain locale pourrait être utile comme une forme de test d’intégration manuelle. [Les contrats intelligents sont hautement composables](/developers/docs/smart-contracts/composability/), vous permettant de vous intégrer aux protocoles existants. Vous devrez quand même vous assurer que ces interactions complexes sur la chaîne produisent les bons résultats.
+Exécuter des contrats sur une blockchain locale pourrait être utile comme une forme de test d’intégration manuelle. [Les contrats intelligents sont hautement composables](/developers/docs/smart-contracts/composability/), vous permettant de vous intégrer aux protocoles existants, mais vous devrez tout de même vous assurer que de telles interactions complexes en chaîne produisent les bons résultats.
 
 [En savoir plus sur les réseaux de développement.](/developers/docs/development-networks/)
 
-### Tests de contrats sur les réseaux de test {#testing-contracts-on-testnets}
+### Tester les contrats sur les réseaux de test {#testing-contracts-on-testnets}
 
-Un réseau de test fonctionne exactement comme le réseau principal d'Ethereum, sauf qu'il utilise de l'Ether (ETH) sans valeur dans le monde réel. Déployer votre contrat sur un [réseau de test](/developers/docs/networks/#ethereum-testnets) signifie que n'importe qui peut interagir avec lui (par exemple, via le frontend de la DAPP) sans mettre en péril les fonds.
+Un réseau de test fonctionne exactement comme le réseau principal d'Ethereum, sauf qu'il utilise de l'Ether (ETH) sans valeur dans le monde réel. Déployer votre contrat sur un [réseau de test](/developers/docs/networks/#ethereum-testnets) signifie que n'importe qui peut interagir avec lui (par exemple, via le frontend de la dapp) sans mettre de fonds en danger.
 
 Cette forme de test manuel est utile pour évaluer le flux de bout en bout de votre application du point de vue de l'utilisateur. Ici, les utilisateurs finaux peuvent exécuter des essais et rapporter tous les problèmes avec la logique commerciale du contrat et les fonctionnalités générales.
 
@@ -221,88 +222,90 @@ Déployer sur un réseau de test après avoir testé sur une blockchain locale e
 
 [En savoir plus sur les réseaux de test Ethereum.](/developers/docs/development-networks/#public-beacon-testchains)
 
-## Test contre vérification formelle {#testing-vs-formal-verification}
+## Tests vs vérification formelle {#testing-vs-formal-verification}
 
-Bien que les tests permettent de confirmer qu'un contrat renvoie les résultats attendus pour certaines entrées de données, ils ne peuvent pas prouver de manière concluante la même chose pour les entrées non utilisées lors des tests. Tester un contrat intelligent ne peut donc pas garantir « l'exactitude fonctionnelle » (c'est-à-dire qu'il ne peut pas montrer qu'un programme se comporte comme requis pour _tous_ les ensembles de valeurs d'entrée).
+Bien que les tests permettent de confirmer qu'un contrat renvoie les résultats attendus pour certaines entrées de données, ils ne peuvent pas prouver de manière concluante la même chose pour les entrées non utilisées lors des tests. Tester un contrat intelligent ne peut donc pas garantir l'« exactitude fonctionnelle » (c'est-à-dire qu'il ne peut pas montrer qu'un programme se comporte comme requis pour _tous_ les ensembles de valeurs d'entrée).
 
 La vérification formelle est une approche permettant d'évaluer la justesse des logiciels en vérifiant si un modèle formel du programme correspond à la spécification formelle. Un modèle formel est une représentation mathématique abstraite d'un programme, tandis qu'une spécification formelle définit les propriétés d'un programme (c'est-à-dire des assertions logiques à propos de l'exécution du programme).
 
 Parce que les propriétés sont écrites en termes mathématiques, il devient possible de vérifier qu'un modèle formel (mathématique) du système satisfait une spécification en utilisant des règles d'inférence logiques. Ainsi, on dit que les outils de vérification formels produisent des « preuves mathématiques » de l’exactitude d’un système.
 
-Contrairement aux tests, la vérification formelle peut être utilisée pour vérifier qu'une exécution de contrats intelligents satisfait une spécification formelle pour _toutes les_ exécutions (c'est-à-dire qu'il n'a pas de bogues) sans avoir besoin de l'exécuter avec des exemples de données. Non seulement cela réduit le temps passé à exécuter des dizaines de tests unitaires, mais il est aussi plus efficace pour attraper des vulnérabilités cachées. Cela dit, les techniques de vérification formelle reposent sur un spectre en fonction de leur difficulté de mise en œuvre et de leur utilité.
+Contrairement aux tests, la vérification formelle peut être utilisée pour vérifier que l'exécution d'un contrat intelligent satisfait une spécification formelle pour _toutes_ les exécutions (c'est-à-dire qu'il ne contient aucun bug) sans avoir besoin de l'exécuter avec des données d'échantillon. Non seulement cela réduit le temps passé à exécuter des dizaines de tests unitaires, mais il est aussi plus efficace pour attraper des vulnérabilités cachées. Cela dit, les techniques de vérification formelle reposent sur un spectre en fonction de leur difficulté de mise en œuvre et de leur utilité.
 
 [En savoir plus sur la vérification formelle des contrats intelligents.](/developers/docs/smart-contracts/formal-verification)
 
-## Tester vs audits et récompenses de bugs {#testing-vs-audits-bug-bounties}
+## Tests vs audits et primes de bug {#testing-vs-audits-bug-bounties}
 
 Comme mentionné, des tests rigoureux peuvent rarement garantir l'absence de bogues dans un contrat ; les approches de vérification formelle peuvent fournir des garanties plus fortes d'exactitude, mais elles sont actuellement difficiles à utiliser et entraînent des coûts considérables.
 
-Néanmoins, vous pouvez encore augmenter la possibilité de capturer des vulnérabilités de contrat en obtenant une révision de code indépendante. [Les audits de contrats intelligents](https://www.immunebytes.com/blog/what-is-a-smart-contract-audit/) et [les récompenses de bugs](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7) sont deux façons d'amener d'autres personnes à analyser vos contrats.
+Néanmoins, vous pouvez encore augmenter la possibilité de capturer des vulnérabilités de contrat en obtenant une révision de code indépendante. Les [audits de contrats intelligents](https://www.immunebytes.com/blog/what-is-a-smart-contract-audit/) et les [primes de bug](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7) sont deux façons d'amener d'autres personnes à analyser vos contrats.
 
 Les vérifications sont effectuées par des vérificateurs expérimentés dans la recherche de cas de défauts de sécurité et de mauvaises pratiques de développement dans les contrats intelligents. Un audit comprendra généralement des tests (et éventuellement une vérification officielle) ainsi qu'une révision manuelle de l'ensemble du codebase.
 
-Inversement, un programme de prime aux bogues implique généralement d'offrir une récompense financière à une personne (communément décrite comme [hackers whitehat](https://en.wikipedia.org/wiki/White_hat_(computer_security))) qui découvre une vulnérabilité dans un contrat intelligent et la divulgue aux développeurs. Ces chasses à la prime ont des points communs avec les audits étant donné que les deux méthodes impliquent le recours à l'expertise de tierces personnes pour découvrir des vulnérabilités dans les contrats intelligents.
+Inversement, un programme de prime de bug implique généralement d'offrir une récompense financière à un individu (communément décrit comme des [hackers white-hat](https://en.wikipedia.org/wiki/White_hat_\(computer_security\))) qui découvre une vulnérabilité dans un contrat intelligent et la divulgue aux développeurs. Ces chasses à la prime ont des points communs avec les audits étant donné que les deux méthodes impliquent le recours à l'expertise de tierces personnes pour découvrir des vulnérabilités dans les contrats intelligents.
 
 La principale différence est que les programmes de primes aux bogues sont ouverts à la communauté plus large des développeurs et des hackers et attirent une large classe de hackers éthiques et de professionnels de la sécurité indépendants possédant des compétences et une expérience uniques. Cela peut être un avantage par rapport aux audits de contrats intelligents qui reposent principalement sur des équipes qui peuvent posséder une expertise plus limitée ou étroite.
 
-## Outils de test et bibliothèques {#testing-tools-and-libraries}
+## Outils et bibliothèques de test {#testing-tools-and-libraries}
 
-### Outils pour tests unitaires {#unit-testing-tools}
+### Outils de test unitaire {#unit-testing-tools}
 
-- **[couverture Solidity](https://github.com/sc-forks/solidity-coverage)** - _Outil de couverture de code pour les contrats intelligents écrits en Solidity._
+- **[solidity-coverage](https://github.com/sc-forks/solidity-coverage)** - _Outil de couverture de code pour les contrats intelligents écrits en Solidity._
 
 - **[Waffle](https://ethereum-waffle.readthedocs.io/en/latest/)** - _Framework pour le développement et le test de contrats intelligents avancés (basé sur ethers.js)_.
 
-- **[Tests de remix](https://github.com/ethereum/remix-project/tree/master/libs/remix-tests)** - _Outil pour tester les contrats intelligents Solidity. Fonctionne sous le plugin Remix IDE « Solidity Unit Testing » qui est utilisé pour écrire et exécuter des cas de test pour un contrat._
+- **[Remix Tests](https://github.com/ethereum/remix-project/tree/master/libs/remix-tests)** - _Outil pour tester les contrats intelligents Solidity. Fonctionne sous le plugin Remix IDE « Solidity Unit Testing » qui est utilisé pour écrire et exécuter des cas de test pour un contrat._
 
-- **[Aide aux tests OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-test-helpers)** - _Bibliothèque d'assertions pour les tests de contrats intelligents Ethereum. Assurez-vous que vos contrats se comportent comme prévu !_
+- **[OpenZeppelin Test Helpers](https://github.com/OpenZeppelin/openzeppelin-test-helpers)** - _Bibliothèque d'assertions pour les tests de contrats intelligents Ethereum. Assurez-vous que vos contrats se comportent comme prévu !_
 
-- **Cadre de test unitaire Brownie** - _Brownie utilise Pytest, un cadre de test riche en fonctionnalités qui vous permet d'écrire de petits tests avec un code minimal, qui s'adapte bien aux grands projets et qui est hautement extensible._
+- **[Framework de test unitaire Brownie](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)** - _Brownie utilise Pytest, un framework de test riche en fonctionnalités qui vous permet d'écrire de petits tests avec un minimum de code, s'adapte bien aux grands projets et est très extensible._
 
-- **[Tests Foundy](https://github.com/foundry-rs/foundry/tree/master/crates/forge)** - _Foundry propose Forge, un cadre de test Ethereum rapide et flexible capable d'exécuter des tests unitaires simples, des contrôles d'optimisation du gaz et du fuzzing de contrats._
+- **[Foundry Tests](https://github.com/foundry-rs/foundry/tree/master/crates/forge)** - _Foundry propose Forge, un framework de test Ethereum rapide et flexible capable d'exécuter de simples tests unitaires, des vérifications d'optimisation de gaz et du fuzzing de contrats._
 
-- **[Hardhat Tests](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)** - _Framework pour tester des contrats intelligents basés sur ethers.js, Mocha et Chai._
+- **[Hardhat Tests](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)** - _Framework pour tester les contrats intelligents basé sur ethers.js, Mocha, et Chai._
 
-- **[ApeWorx](https://docs.apeworx.io/ape/stable/userguides/testing.html)** - _framework de développement et de test basé sur Python pour les contrats intelligents ciblant la Machine virtuelle Ethereum._
+- **[ApeWorx](https://docs.apeworx.io/ape/stable/userguides/testing.html)** - _Framework de développement et de test basé sur Python pour les contrats intelligents ciblant la machine virtuelle Ethereum._
 
-- **[Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)** - _Cadre basé sur Python pour les tests unitaires et le fuzzing avec de fortes capacités de débogage et la prise en charge des tests inter-chaînes, utilisant pytest et Anvil pour une meilleure expérience utilisateur et de meilleures performances._
+- **[Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)** - _Framework basé sur Python pour les tests unitaires et le fuzzing avec de fortes capacités de débogage et un support pour les tests inter-chaînes, utilisant pytest et Anvil pour une meilleure expérience utilisateur et de meilleures performances._
 
-### Outils de test fondés sur les propriétés {#property-based-testing-tools}
+### Outils de test basés sur les propriétés {#property-based-testing-tools}
 
 #### Outils d'analyse statique {#static-analysis-tools}
 
-- **[Slither](https://github.com/crytic/slither)** - _Python- Cadre d'analyse statique basé sur Solidity pour rechercher des vulnérabilités, améliorer la compréhension du code et rédiger des analyses personnalisées pour les contrats intelligents._
+- **[Slither](https://github.com/crytic/slither)** - _Framework d'analyse statique de Solidity basé sur Python pour trouver des vulnérabilités, améliorer la compréhension du code et écrire des analyses personnalisées pour les contrats intelligents._
+
+- **[Ethlint](https://ethlint.readthedocs.io/en/latest/)** - _Linter pour l'application du style et des meilleures pratiques de sécurité pour le langage de programmation de contrats intelligents Solidity._
 
-- **[Ethlint](https://ethlint.readthedocs.io/en/latest/)** - _Linter pour l'application du style et des meilleures pratiques de sécurité pour le langage de programmation du contrat intelligent Solidity._
+- **[Cyfrin Aderyn](https://cyfrin.io/tools/aderyn)** - _Analyseur statique basé sur Rust spécialement conçu pour la sécurité et le développement de contrats intelligents Web3._
 
-- **[Cyfrin Aderyn](https://cyfrin.io/tools/aderyn)** - _Analyseur statique basé sur Rust spécifiquement conçu pour la sécurité et le développement de contrats intelligents Web3._
+- **[Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)** - _Framework d'analyse statique basé sur Python avec des détecteurs de vulnérabilité et de qualité du code, des outils d'impression pour extraire des informations utiles du code et un support pour l'écriture de sous-modules personnalisés._
 
-- **[Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)** - *Cadre d'analyse statique basé sur Python comprenant des détecteurs de vulnérabilité et de qualité du code, des imprimeurs permettant d'extraire des informations utiles du code et un support pour l'écriture de sous-modules personnalisés.*
+- **[Slippy](https://github.com/fvictorio/slippy)** - _Un linter simple et puissant pour Solidity._
 
 #### Outils d'analyse dynamique {#dynamic-analysis-tools}
 
-- **[Echidna](https://github.com/crytic/echidna/)** - _Fuzzer de contrat rapide pour détecter les vulnérabilités des contrats intelligents grâce à des tests basés sur les propriétés._
+- **[Echidna](https://github.com/crytic/echidna/)** - _Fuzzer de contrat rapide pour détecter les vulnérabilités dans les contrats intelligents grâce à des tests basés sur les propriétés._
 
-- **[Diligence Fuzzing](https://consensys.net/diligence/fuzzing/)** - _ Outil de fuzzing automatisé utile pour détecter les violations de propriété dans le code des contrats intelligents._
+- **[Diligence Fuzzing](https://consensys.net/diligence/fuzzing/)** - _Outil de fuzzing automatisé utile pour détecter les violations de propriété dans le code des contrats intelligents._
 
-- **[Manticore](https://manticore.readthedocs.io/en/latest/index.html)** - _Cadre d'exécution symbolique dynamique pour l'analyse du bytecode EVM._
+- **[Manticore](https://manticore.readthedocs.io/en/latest/index.html)** - _Framework d'exécution symbolique dynamique pour l'analyse du bytecode EVM._
 
-- **[Mythril](https://github.com/ConsenSys/mythril-classic)** - _Outil d'évaluation de bytecode EVM pour détecter les vulnérabilités des contrats à l'aide de l'analyse des souillures, de l'analyse concolique et de la vérification du flux de contrôle._
+- **[Mythril](https://github.com/ConsenSys/mythril-classic)** - _Outil d'évaluation du bytecode EVM pour détecter les vulnérabilités de contrat en utilisant l'analyse de taint, l'analyse concolique et la vérification du flux de contrôle._
 
-- **[Diligence Scribble](https://consensys.net/diligence/scribble/)** - _Scribble est un outil de vérification du langage de spécification et du temps d'exécution qui vous permet d'annoter des contrats intelligents avec des propriétés qui vous permettent de tester automatiquement les contrats avec des outils tels que Diligence Fuzzing ou MythX._
+- **[Diligence Scribble](https://consensys.net/diligence/scribble/)** - _Scribble est un langage de spécification et un outil de vérification à l'exécution qui vous permet d'annoter des contrats intelligents avec des propriétés vous permettant de tester automatiquement les contrats avec des outils tels que Diligence Fuzzing ou MythX._
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Une vue d'ensemble et une comparaison de produits de test différents](/developers/tutorials/guide-to-smart-contract-security-tools/) \_
+- [Un aperçu et une comparaison de différents produits de test](/developers/tutorials/guide-to-smart-contract-security-tools/) \_
 - [Comment utiliser Echidna pour tester les contrats intelligents](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/)
-- [Comment utiliser Manticore pour trouver les bogues dans les contrats intelligents](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
-- [Comment utiliser Slither pour trouver des bugs de contrat intelligent](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
+- [Comment utiliser Manticore pour trouver des bogues dans les contrats intelligents](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
+- [Comment utiliser Slither pour trouver des bogues dans les contrats intelligents](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
 - [Comment simuler des contrats Solidity pour les tests](/developers/tutorials/how-to-mock-solidity-contracts-for-testing/)
-- [Comment exécuter des tests unitaires dans Solidity en utilisant Foundry](https://www.rareskills.io/post/foundry-testing-solidity)
+- [Comment exécuter des tests unitaires en Solidity avec Foundry](https://www.rareskills.io/post/foundry-testing-solidity)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Un guide détaillé pour tester les contrats intelligents Ethereum](https://iamdefinitelyahuman.medium.com/an-in-depth-guide-to-testing-ethereum-smart-contracts-2e41b2770297)
-- [Comment tester les contrats intelligents ethereum](https://betterprogramming.pub/how-to-test-ethereum-smart-contracts-35abc8fa199d)
+- [Un guide approfondi pour tester les contrats intelligents Ethereum](https://iamdefinitelyahuman.medium.com/an-in-depth-guide-to-testing-ethereum-smart-contracts-2e41b2770297)
+- [Comment tester les contrats intelligents Ethereum](https://betterprogramming.pub/how-to-test-ethereum-smart-contracts-35abc8fa199d)
 - [Guide de test unitaire de MolochDAO pour les développeurs](https://github.com/MolochVentures/moloch/tree/4e786db8a4aa3158287e0935dcbc7b1e43416e38/test#moloch-testing-guide)
-- [Comment tester des contrats intelligents comme une rockstar](https://forum.openzeppelin.com/t/test-smart-contracts-like-a-rockstar/1001)
+- [Comment tester les contrats intelligents comme une rockstar](https://forum.openzeppelin.com/t/test-smart-contracts-like-a-rockstar/1001)
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/upgrading/index.md b/public/content/translations/fr/developers/docs/smart-contracts/upgrading/index.md
index dccd56c0485..05d2095a2ab 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/upgrading/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/upgrading/index.md
@@ -1,6 +1,6 @@
 ---
-title: Mise à jour des contrats intelligents
-description: Un aperçu des méthodes de mise à jour des contrats intelligents Ethereum
+title: "Mise à jour des contrats intelligents"
+description: "Un aperçu des méthodes de mise à jour des contrats intelligents Ethereum"
 lang: fr
 ---
 
@@ -12,9 +12,9 @@ Cependant, l'intensification des recherches visant à améliorer les contrats in
 
 ## Prérequis {#prerequisites}
 
-Vous devriez avoir une bonne connaissance des [contrats intelligents](/developers/docs/smart-contracts/), de l'[anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/) et de la [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Ce guide suppose également que les lecteurs maîtrisent la programmation de contrats intelligents.
+Vous devez avoir une bonne compréhension des [contrats intelligents](/developers/docs/smart-contracts/), de [l'anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/), et de la [machine virtuelle Ethereum (EVM)](/developers/docs/evm/). Ce guide suppose également que les lecteurs maîtrisent la programmation de contrats intelligents.
 
-## Qu'est-ce qu'une mise à jour de contrat intelligent ? {#what-is-a-smart-contract-upgrade}
+## Qu'est-ce qu'une mise à jour de contrat intelligent ? Qu'est-ce qu'une mise à niveau de contrat intelligent ? {#what-is-a-smart-contract-upgrade}
 
 La mise à jour d'un contrat intelligent consiste à modifier la logique d'un contrat intelligent tout en préservant l'état du contrat. Il est important de préciser que l'évolutivité et la mutabilité sont deux notions différentes, en particulier dans le contexte des contrats intelligents.
 
@@ -32,7 +32,7 @@ Cela peut se faire par les méthodes suivantes :
 
 5. Utiliser le modèle de diamant pour déléguer des appels de fonction d'un contrat proxy à des contrats logiques.
 
-### Mécanisme de mise à jour n° 1 : migration des contrats {#contract-migration}
+### Mécanisme de mise à niveau n° 1 : Migration des contrats {#contract-migration}
 
 La migration des contrats repose sur le principe du versionnage, c'est-à-dire la création et la gestion d'états uniques d'un même logiciel. La migration de contrat implique le déploiement d'une nouvelle instance d'un contrat intelligent existant et le transfert du stockage et des soldes vers le nouveau contrat.
 
@@ -42,9 +42,9 @@ La dernière étape de la migration des contrats consiste à convaincre les util
 
 La migration des contrats est une mesure relativement simple et sûre pour mettre à jour les contrats intelligents sans interrompre les interactions avec les utilisateurs. Cependant, la migration manuelle du stockage et des soldes des utilisateurs vers le nouveau contrat prend beaucoup de temps et peut entraîner des coûts de gaz élevés.
 
-[En savoir plus sur la migration de contrats.](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/)
+[En savoir plus sur la migration des contrats.](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/)
 
-### Mécanisme de mise à jour n°2 : séparation des données {#data-separation}
+### Mécanisme de mise à niveau n° 2 : Séparation des données {#data-separation}
 
 Une autre méthode pour améliorer les contrats intelligents consiste à séparer la logique et le stockage des données dans des contrats distincts. Cela signifie que les utilisateurs interagissent avec le contrat de logique, tandis que les données sont stockées dans le contrat de stockage.
 
@@ -58,7 +58,7 @@ L'utilisation de cette méthode de mise à niveau nécessite la mise à jour de
 
 La méthode de séparation des données est sans doute plus facile à mettre en œuvre par rapport à la migration de contrat. Cependant, vous devrez gérer plusieurs contrats et mettre en œuvre des systèmes d'autorisation complexes pour protéger les contrats intelligents contre les mises à jour malveillantes.
 
-### Mécanisme de mise à jour n°3 : méthodes Proxy {#proxy-patterns}
+### Mécanisme de mise à niveau n° 3 : Modèles de proxy {#proxy-patterns}
 
 La méthode proxy utilise également la séparation des données pour conserver la logique de travail et les données dans des contrats distincts. Cependant, avec la méthode proxy, le contrat de stockage (appelé proxy) appelle le contrat logique pendant l'exécution du code. C'est l'inverse de la méthode de séparation des données, où le contrat de logique appelle le contrat de stockage.
 
@@ -66,17 +66,17 @@ Voici ce qui se passe avec le modèle proxy :
 
 1. Les utilisateurs interagissent avec le contrat proxy, qui stocke les données, mais ne détient pas la logique de travail.
 
-2. Le contrat proxy stocke l'adresse du contrat logique et délègue tous les appels de fonction au contrat logique (qui détient la logique de travail) en utilisant la fonction `delegatecall`.
+2. Le contrat proxy stocke l'adresse du contrat logique et délègue tous les appels de fonction au contrat logique (qui contient la logique métier) en utilisant la fonction `delegatecall`.
 
 3. Après le transfert de l'appel au contrat logique, les données renvoyées par le contrat logique sont récupérées et renvoyées à l'utilisateur.
 
-Utiliser les méthodes de proxy nécessite une compréhension de la fonction **delegatecall**. Essentiellement, `delegatecall` est un opcode qui permet à un contrat d'appeler un autre contrat, tandis que l'exécution réelle du code se produit dans le contexte du contrat appelant. Une implication de l'utilisation de `delegatecall` dans les modèles de proxy est que le contrat proxy lit et écrit dans son stockage et exécute la logique stockée dans le contrat de logique comme s'il appelait une fonction interne.
+L'utilisation des modèles de proxy nécessite de comprendre la fonction **delegatecall**. Fondamentalement, `delegatecall` est un opcode qui permet à un contrat d'en appeler un autre, tandis que l'exécution réelle du code se déroule dans le contexte du contrat appelant. Une implication de l'utilisation de `delegatecall` dans les modèles de proxy est que le contrat proxy lit et écrit dans son stockage et exécute la logique stockée dans le contrat logique comme s'il appelait une fonction interne.
 
-Selon la [documentation Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#delegatecall-callcode-and-libraries) :
+Extrait de la [documentation de Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#delegatecall-callcode-and-libraries) :
 
-> _Il existe une variante spéciale de l'appel de message, nommée **delegatecall** qui est identique à un appel de message à part le fait que le code à l'adresse cible est exécuté dans le contexte (c'est-à-dire à l'adresse) du contrat appelant et `msg.sender` et `msg.value` ne changent pas leurs valeurs. __Cela signifie qu'un contrat peut charger dynamiquement du code depuis une adresse différente à l'exécution. Le stockage, l'adresse actuelle et le solde font toujours référence au contrat appelant, seul le code est pris à partir de l'adresse appelée._
+> _Il existe une variante spéciale d'un appel de message, nommée **delegatecall**, qui est identique à un appel de message, à l'exception du fait que le code à l'adresse cible est exécuté dans le contexte (c'est-à-dire à l'adresse) du contrat appelant et que les valeurs de `msg.sender` et `msg.value` ne changent pas._ _Cela signifie qu'un contrat peut charger dynamiquement du code à partir d'une adresse différente lors de l'exécution. Le stockage, l'adresse actuelle et le solde font toujours référence au contrat appelant, seul le code est pris à partir de l'adresse appelée._
 
-Le contrat proxy sait invoquer `delegatecall` chaque fois qu'un utilisateur appelle une fonction car il dispose d'une fonction `fallback` intégrée. En programmation Solidity, la [fonction fallback](https://docs.soliditylang.org/en/latest/contracts.html#fallback-function) est exécutée lorsqu'un appel de fonction ne correspond pas aux fonctions spécifiées dans un contrat.
+Le contrat proxy sait qu'il doit invoquer `delegatecall` chaque fois qu'un utilisateur appelle une fonction, car une fonction `fallback` y est intégrée. En programmation Solidity, la [fonction de secours](https://docs.soliditylang.org/en/latest/contracts.html#fallback-function) est exécutée lorsqu'un appel de fonction ne correspond à aucune des fonctions spécifiées dans un contrat.
 
 Pour faire fonctionner le modèle proxy, il est nécessaire d'écrire une fonction de défaut personnalisée qui spécifie comment le contrat proxy doit gérer les appels de fonctions qu'il ne prend pas en charge. Dans ce cas, la fonction par défaut du proxy est programmée pour initier un delegatecall et réacheminer la demande de l'utilisateur vers l'implémentation actuelle du contrat logique.
 
@@ -84,27 +84,27 @@ Le contrat proxy est immuable par défaut, mais de nouveaux contrats logiques av
 
 En orientant le contrat proxy vers un nouveau contrat logique, le code exécuté lorsque les utilisateurs appellent la fonction du contrat proxy change. Cela nous permet de mettre à jour la logique d'un contrat sans demander aux utilisateurs d'interagir avec un nouveau contrat.
 
-Les méthodes de proxy sont une méthode populaire pour mettre à jour les contrats intelligents car ils éliminent les difficultés associées à la migration des contrats. Cependant, les méthodes de proxy sont plus compliqués à utiliser et peuvent introduire des failles critiques, comme les [conflits de sélecteurs de fonctions](https://medium.com/nomic-foundation-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357), s'ils sont utilisés de manière incorrecte.
+Les méthodes de proxy sont une méthode populaire pour mettre à jour les contrats intelligents car ils éliminent les difficultés associées à la migration des contrats. Cependant, les modèles de proxy sont plus compliqués à utiliser et peuvent introduire des failles critiques, telles que des [conflits de sélecteurs de fonctions](https://medium.com/nomic-foundation-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357), s'ils sont utilisés de manière inappropriée.
 
-[En savoir plus sur la méthode Proxy](https://blog.openzeppelin.com/proxy-patterns/).
+[En savoir plus sur les modèles de proxy](https://blog.openzeppelin.com/proxy-patterns/).
 
-### Mécanisme de mise à jour n°4 : méthode Stratégique {#strategy-pattern}
+### Mécanisme de mise à niveau n° 4 : Modèle de stratégie {#strategy-pattern}
 
-Cette technique est influencée par la [stratégie](https://en.wikipedia.org/wiki/Strategy_pattern), qui encourage à créer des programmes logiciels qui interagissent avec d'autres programmes pour implémenter des fonctionnalités spécifiques. Appliquer le modèle de stratégie au développement d'Ethereum signifierait construire un contrat intelligent qui appelle des fonctions d'autres contrats.
+Cette technique est influencée par le [modèle de stratégie](https://en.wikipedia.org/wiki/Strategy_pattern), qui encourage la création de programmes logiciels qui s'interfacent avec d'autres programmes pour implémenter des fonctionnalités spécifiques. Appliquer le modèle de stratégie au développement d'Ethereum signifierait construire un contrat intelligent qui appelle des fonctions d'autres contrats.
 
 Dans ce cas, le contrat principal contient la logique de base, mais interagit avec d'autres contrats intelligents (« contrats satellites ») pour exécuter certaines fonctions. Ce contrat principal stocke également l'adresse de chaque contrat satellite et peut permuter entre différentes implémentations du contrat satellite.
 
-Vous pouvez créer un nouveau contrat satellite et configurer le contrat principal avec la nouvelle adresse. Cela vous permet de modifier les _stratégies_ (c'est-à-dire de mettre en œuvre une nouvelle logique) d'un contrat intelligent.
+Vous pouvez créer un nouveau contrat satellite et configurer le contrat principal avec la nouvelle adresse. Cela vous permet de changer de _stratégies_ (c'est-à-dire de mettre en œuvre une nouvelle logique) pour un contrat intelligent.
 
 Bien qu'il soit similaire au modèle de proxy évoqué précédemment, le modèle de stratégie est différent car le contrat principal, avec lequel les utilisateurs interagissent, contient la logique. L'utilisation de ce modèle vous permet d'introduire des changements limités dans un contrat intelligent sans affecter l'infrastructure de base.
 
 Le principal inconvénient de ce modèle est qu'il n'est utile que pour le déploiement de mises à jour mineures. De plus, si le contrat principal est compromis (par exemple, par un piratage), vous ne pouvez pas utiliser cette méthode de mise à jour.
 
-### Mécanisme de mise à jour n°5 : méthode diamant {#diamond-pattern}
+### Mécanisme de mise à niveau n° 5 : Modèle diamant {#diamond-pattern}
 
 Le modèle de diamant peut être considéré comme une amélioration du modèle de proxy. Le modèle de diamant diffère des modèles de proxy car le contrat proxy de diamant peut déléguer des appels de fonction à plus d'un contrat logique.
 
-Les contrats logiques dans le modèle de diamant sont appelés _facettes_. Pour faire fonctionner le modèle de diamant, vous devez créer une correspondance dans le contrat proxy qui associe les [sélecteurs de fonction](https://docs.soliditylang.org/en/latest/abi-spec.html#function-selector) à différentes adresses de facettes.
+Les contrats logiques dans le modèle diamant sont appelés des _facettes_. Pour faire fonctionner le modèle diamant, vous devez créer une correspondance dans le contrat proxy qui associe les [sélecteurs de fonctions](https://docs.soliditylang.org/en/latest/abi-spec.html#function-selector) à différentes adresses de facettes.
 
 Lorsqu'un utilisateur effectue un appel de fonction, le contrat proxy vérifie la correspondance pour trouver la facette responsable de l'exécution de cette fonction. Ensuite, il invoque `delegatecall` (en utilisant la fonction de secours) et redirige l'appel vers le contrat logique approprié.
 
@@ -114,52 +114,52 @@ Le modèle de mise à jour en diamant présente plusieurs avantages par rapport
 
 2. Tous les contrats intelligents (y compris les contrats logiques utilisés dans les modèles proxy) ont une limite de taille de 24 Ko, ce qui peut être une limitation, en particulier pour les contrats complexes nécessitant plus de fonctions. Le modèle diamant facilite la résolution de ce problème en répartissant les fonctions sur plusieurs contrats logiques.
 
-3. Les modèles proxy adoptent une approche universelle pour les contrôles d'accès. Une entité ayant accès aux fonctions de mise à niveau peut modifier l'_ensemble_ du contrat. Mais le modèle de diamant permet une approche modulaire des permissions, où vous pouvez restreindre les entités à la mise à niveau de certaines fonctions au sein d'un contrat intelligent.
+3. Les modèles proxy adoptent une approche universelle pour les contrôles d'accès. Une entité ayant accès aux fonctions de mise à niveau peut modifier l'ensemble du contrat. Mais le modèle de diamant permet une approche modulaire des permissions, où vous pouvez restreindre les entités à la mise à niveau de certaines fonctions au sein d'un contrat intelligent.
 
-[En savoir plus sur la méthode diamant](https://eip2535diamonds.substack.com/p/introduction-to-the-diamond-standard?s=w).
+[En savoir plus sur le modèle diamant](https://eip2535diamonds.substack.com/p/introduction-to-the-diamond-standard?s=w).
 
-## Avantages et inconvénients de la mise à jour des contrats intelligents {#pros-and-cons-of-upgrading-smart-contracts}
+## Avantages et inconvénients de la mise à niveau des contrats intelligents {#pros-and-cons-of-upgrading-smart-contracts}
 
-| Avantages                                                                                                                                                                      | Inconvénients                                                                                                                                                                                   |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Avantages                                                                                                                                                                                      | Inconvénients                                                                                                                                                                                                   |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Une mise à jour de contrat intelligent peut faciliter la correction des vulnérabilités découvertes lors de la phase de post-déploiement.                                       | La mise à jour des contrats intelligents annule le principe de l'immutabilité du code, ce qui a des répercussions sur la décentralisation et la sécurité.                                       |
 | Les développeurs peuvent utiliser les mises à jour logiques pour ajouter de nouvelles fonctionnalités aux applications décentralisées.                                         | Les utilisateurs doivent faire confiance aux développeurs pour ne pas modifier arbitrairement les contrats intelligents.                                                                        |
 | Les mises à jour des contrats intelligents peuvent améliorer la sécurité des utilisateurs finaux, car les bogues peuvent être corrigés rapidement.                             | La programmation d'une fonctionnalité de mise à jour dans les contrats intelligents ajoute une couche supplémentaire de complexité et augmente la possibilité de failles critiques.             |
 | Les mises à jour des contrats donnent aux développeurs une plus grande marge de manœuvre pour expérimenter différentes fonctionnalités et améliorer les DApps au fil du temps. | La possibilité d'améliorer les contrats intelligents peut encourager les développeurs à lancer des projets plus rapidement sans faire preuve de diligence durant la phase de développement.     |
-|                                                                                                                                                                                | Un contrôle d'accès non sécurisé ou une centralisation dans les contrats intelligents peuvent permettre à des acteurs malveillants d'effectuer plus facilement des mises à jour non autorisées. |
+|                                                                                                                                                                                                | Un contrôle d'accès non sécurisé ou une centralisation dans les contrats intelligents peuvent permettre à des acteurs malveillants d'effectuer plus facilement des mises à jour non autorisées. |
 
-## Considérations pour la mise à jour des contrats intelligents {#considerations-for-upgrading-smart-contracts}
+## Éléments à prendre en compte pour la mise à niveau des contrats intelligents {#considerations-for-upgrading-smart-contracts}
 
 1. Utilisez des mécanismes de contrôle d'accès/autorisation sécurisés pour empêcher les mises à niveau non autorisées de contrats intelligents, en particulier si vous utilisez des modèles proxy, des modèles stratégiques ou une séparation des données. Un exemple est de restreindre l'accès à la fonction de mise à niveau, de sorte que seul le propriétaire du contrat puisse l'appeler.
 
 2. La mise à jour des contrats intelligents est une activité complexe qui nécessite un niveau élevé de diligence pour éviter l'introduction de vulnérabilités.
 
-3. Réduisez les hypothèses de confiance en décentralisant le processus de mise à jour. Des stratégies possibles incluent l'utilisation d'un [contrat de portefeuille multi-signature](/developers/docs/smart-contracts/#multisig) pour contrôler les mises à niveau, ou l'exigence que les [membres d'une DAO](/dao/) votent pour approuver la mise à niveau.
+3. Réduisez les hypothèses de confiance en décentralisant le processus de mise à jour. Les stratégies possibles incluent l'utilisation d'un [contrat de portefeuille multi-signatures](/developers/docs/smart-contracts/#multisig) pour contrôler les mises à niveau, ou le fait d'exiger que les [membres d'une DAO](/dao/) votent pour approuver la mise à niveau.
 
 4. Soyez conscient des coûts liés à la mise à jour des contrats. Par exemple, la copie d'un état (p. ex. les soldes des utilisateurs) d'un ancien contrat vers un nouveau contrat lors d'une migration de contrat peut nécessiter plus d'une transaction, ce qui signifie plus de frais de gaz.
 
-5. Pensez à mettre en place des **timelocks** pour protéger les utilisateurs. Un timelock est un délai imposé aux modifications apportées à un système. Les timelocks peuvent être combinés à un système de gouvernance à multi-sig pour contrôler les mises à jour : si une action proposée atteint le seuil d'approbation requis, elle n'est pas exécutée tant que le délai prédéfini ne s'est pas écoulé.
+5. Envisagez d'implémenter des **timelocks** pour protéger les utilisateurs. Un timelock est un délai imposé aux modifications apportées à un système. Les timelocks peuvent être combinés à un système de gouvernance à multi-sig pour contrôler les mises à jour : si une action proposée atteint le seuil d'approbation requis, elle n'est pas exécutée tant que le délai prédéfini ne s'est pas écoulé.
 
 Les timelocks donnent aux utilisateurs un certain temps pour quitter le système s'ils sont en désaccord avec un changement proposé (par exemple, une mise à jour de la logique ou de nouveaux barèmes tarifaires). Sans timelocks, les utilisateurs doivent faire confiance aux développeurs pour ne pas mettre en œuvre des changements arbitraires dans un contrat intelligent sans préavis. L'inconvénient est que les timelocks limitent la capacité à corriger rapidement les vulnérabilités.
 
 ## Ressources {#resources}
 
-**OpenZeppelin Upgrades Plugins - _Une suite d'outils pour déployer et sécuriser des contrats intelligents évolutifs._**
+**Plug-ins de mises à niveau OpenZeppelin - _Une suite d'outils pour déployer et sécuriser des contrats intelligents évolutifs._**
 
 - [GitHub](https://github.com/OpenZeppelin/openzeppelin-upgrades)
 - [Documentation](https://docs.openzeppelin.com/upgrades)
 
 ## Tutoriels {#tutorials}
 
-- [Mettre à jour vos contrats intelligents | Tutoriel YouTube Tutorial](https://www.youtube.com/watch?v=bdXJmWajZRY) Par Patrick Collins
-- [Tutoriel de migration des contrats intelligents Ethereum](https://medium.com/coinmonks/ethereum-smart-contract-migration-13f6f12539bd) par Austin Griffith
-- [Utilisation du modèle proxy UUPS pour mettre à jour les contrats intelligents](https://blog.logrocket.com/author/praneshas/) par Pranesh A.S
-- [Tutoriel Web3 : Écrire un contrat intelligent évolutif (proxy) en utilisant OpenZeppelin](https://dev.to/yakult/tutorial-write-upgradeable-smart-contract-proxy-contract-with-openzeppelin-1916) par fangjun.eth
+- [Mise à niveau de vos contrats intelligents | Tutoriel YouTube](https://www.youtube.com/watch?v=bdXJmWajZRY) par Patrick Collins
+- [Tutoriel sur la migration de contrats intelligents Ethereum](https://medium.com/coinmonks/ethereum-smart-contract-migration-13f6f12539bd) par Austin Griffith
+- [Utiliser le modèle de proxy UUPS pour mettre à niveau les contrats intelligents](https://blog.logrocket.com/author/praneshas/) par Pranesh A.S
+- [Tutoriel Web3 : Écrire un contrat intelligent évolutif (proxy) à l'aide d'OpenZeppelin](https://dev.to/yakult/tutorial-write-upgradeable-smart-contract-proxy-contract-with-openzeppelin-1916) par fangjun.eth
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [L'état des mises à jour des contrats intelligents](https://blog.openzeppelin.com/the-state-of-smart-contract-upgrades/) par Santiago Palladino
-- [Plusieurs façons de mettre à jour un contrat intelligent Solidity](https://cryptomarketpool.com/multiple-ways-to-upgrade-a-solidity-smart-contract/) - Blog Crypto Market Pool
-- [Apprendre à mettre à jour un contrat intelligent](https://docs.openzeppelin.com/learn/upgrading-smart-contracts) - OpenZeppelin Docs
-- [La méthode proxy pour mettre à jour les contrats en Solidity : Proxy Transparent vs UUPS](https://mirror.xyz/0xB38709B8198d147cc9Ff9C133838a044d78B064B/M7oTptQkBGXxox-tk9VJjL66E1V8BUF0GF79MMK4YG0) par Naveen Samu
-- [Comment les mises à jour en diamant fonctionnent ?](https://dev.to/mudgen/how-diamond-upgrades-work-417j) par Nick Mudge
+- [L'état des mises à niveau de contrats intelligents](https://blog.openzeppelin.com/the-state-of-smart-contract-upgrades/) par Santiago Palladino
+- [Plusieurs façons de mettre à niveau un contrat intelligent Solidity](https://cryptomarketpool.com/multiple-ways-to-upgrade-a-solidity-smart-contract/) - blog de Crypto Market Pool
+- [Apprendre : Mettre à niveau les contrats intelligents](https://docs.openzeppelin.com/learn/upgrading-smart-contracts) - Documentation d'OpenZeppelin
+- [Modèles de proxy pour la possibilité de mise à niveau des contrats Solidity : Proxys transparents et UUPS](https://mirror.xyz/0xB38709B8198d147cc9Ff9C133838a044d78B064B/M7oTptQkBGXxox-tk9VJjL66E1V8BUF0GF79MMK4YG0) par Naveen Sahu
+- [Fonctionnement des mises à niveau Diamond](https://dev.to/mudgen/how-diamond-upgrades-work-417j) par Nick Mudge
diff --git a/public/content/translations/fr/developers/docs/smart-contracts/verifying/index.md b/public/content/translations/fr/developers/docs/smart-contracts/verifying/index.md
index 40bc7130989..25516a47873 100644
--- a/public/content/translations/fr/developers/docs/smart-contracts/verifying/index.md
+++ b/public/content/translations/fr/developers/docs/smart-contracts/verifying/index.md
@@ -1,16 +1,16 @@
 ---
-title: Vérification des contrats intelligents
-description: Un aperçu de la vérification du code source des contrats intelligents d'Ethereum
+title: "Vérification des contrats intelligents"
+description: "Un aperçu de la vérification du code source des contrats intelligents d'Ethereum"
 lang: fr
 ---
 
 [Les contrats intelligents](/developers/docs/smart-contracts/) sont conçus pour être « sans confiance », ce qui signifie que les utilisateurs ne devraient pas avoir à faire confiance à des tiers (par exemple, des développeurs et des entreprises) avant d'interagir avec un contrat. La condition préalable à l'absence de confiance est que les utilisateurs et les autres développeurs soient en mesure de vérifier le code source d'un contrat intelligent. La vérification du code source garantit aux utilisateurs et aux développeurs que le code du contrat publié est le même que celui qui s'exécute à l'adresse du contrat sur la blockchain Ethereum.
 
-Il est important de faire la distinction entre la « vérification du code source » et la "[vérification formelle](/developers/docs/smart-contracts/formal-verification/)". La vérification du code source, qui sera expliquée en détail ci-dessous, consiste à vérifier que le code source d'un contrat intelligent dans un langage de haut niveau (par exemple Solidity) se compile de façon à produire le même bytecode que celui qui est exécuté à l'adresse du contrat. Par contre, la vérification formelle consiste à vérifier l'exactitude d'un contrat intelligent, c'est-à-dire que le contrat se comporte comme prévu. Bien que cela dépende du contexte, la vérification des contrats fait généralement référence à la vérification du code source.
+Il est important de faire la distinction entre la « vérification du code source » et la « [vérification formelle](/developers/docs/smart-contracts/formal-verification/) ». La vérification du code source, qui sera expliquée en détail ci-dessous, consiste à vérifier que le code source d'un contrat intelligent dans un langage de haut niveau (par exemple Solidity) se compile de façon à produire le même bytecode que celui qui est exécuté à l'adresse du contrat. Par contre, la vérification formelle consiste à vérifier l'exactitude d'un contrat intelligent, c'est-à-dire que le contrat se comporte comme prévu. Bien que cela dépende du contexte, la vérification des contrats fait généralement référence à la vérification du code source.
 
 ## Qu'est-ce que la vérification du code source ? {#what-is-source-code-verification}
 
-Avant de déployer un contrat intelligent dans la [Machine Virtuelle Ethereum (EVM)](/developers/docs/evm/), les développeurs [compilent](/developers/docs/smart-contracts/compiling/) le code source du contrat, c'est-à-dire les instructions [écrites en Solidity](/developers/docs/smart-contracts/languages/) ou dans un autre langage de programmation de haut niveau, en bytecode. Comme l'EVM ne peut pas interpréter les instructions de haut niveau, la compilation du code source en bytecode (c'est-à-dire en instructions machine de bas niveau) est nécessaire à l'exécution de la logique du contrat dans l'EVM.
+Avant de déployer un contrat intelligent dans la [Machine Virtuelle Ethereum (EVM)](/developers/docs/evm/), les développeurs [compilent](/developers/docs/smart-contracts/compiling/) le code source du contrat — des instructions [écrites en Solidity](/developers/docs/smart-contracts/languages/) ou un autre langage de programmation de haut niveau — en bytecode. Comme l'EVM ne peut pas interpréter les instructions de haut niveau, la compilation du code source en bytecode (c'est-à-dire en instructions machine de bas niveau) est nécessaire à l'exécution de la logique du contrat dans l'EVM.
 
 La vérification du code source consiste à comparer le code source d'un contrat intelligent et le bytecode compilé utilisé lors de la création du contrat afin de détecter toute différence. La vérification des contrats intelligents est importante car le code du contrat annoncé peut être différent de celui qui s'exécute sur la blockchain.
 
@@ -20,17 +20,17 @@ La vérification des contrats intelligents permet d'étudier ce que fait un cont
 
 Certaines parties du code source n'affectent pas le bytecode compilé, comme les commentaires ou les noms de variables. Cela signifie que deux codes sources avec des noms de variables différents et des commentaires différents seraient tous deux capables de vérifier le même contrat. Ainsi, un acteur malveillant peut ajouter des commentaires trompeurs ou utiliser des noms de variables trompeurs dans le code source et faire vérifier le contrat à l'aide d'un code source différent du code source original.
 
-Il est possible d'éviter cela en ajoutant des données supplémentaires au bytecode pour servir de _garantie cryptographique_ de l'exactitude du code source et d'_empreinte digitale_ des informations de compilation. Les informations nécessaires se trouvent dans les [métadonnées du contrat Solidity](https://docs.soliditylang.org/en/v0.8.15/metadata.html), et le hachage de ce fichier est ajouté au bytecode d'un contrat. Vous pouvez le voir à l'œuvre dans le [metadata playground](https://playground.sourcify.dev)
+Il est possible d'éviter cela en ajoutant des données supplémentaires au bytecode pour servir de _garantie cryptographique_ de l'exactitude du code source, et d'_empreinte_ des informations de compilation. Les informations nécessaires se trouvent dans les [métadonnées du contrat de Solidity](https://docs.soliditylang.org/en/v0.8.15/metadata.html), et le hachage de ce fichier est ajouté au bytecode d'un contrat. Vous pouvez le voir en action dans le [metadata playground](https://playground.sourcify.dev)
 
 Le fichier de métadonnées contient des informations sur la compilation du contrat, y compris les fichiers sources et leurs hachages. Ce qui signifie que si l'un des paramètres de compilation ou même un octet dans l'un des fichiers source change, le fichier de métadonnées change également. Par conséquent, le hachage du fichier de métadonnées, qui est ajouté au bytecode, change également. Donc, si le bytecode d'un contrat + le hachage des métadonnées correspond au code source et aux paramètres de compilation donnés, nous pouvons être sûrs qu'il s'agit exactement du même code source utilisé dans la compilation d'origine, aucun octet n'étant différent.
 
-Ce type de vérification qui exploite le hachage des métadonnées est appelé **"[vérification complète](https://docs.sourcify.dev/docs/full-vs-partial-match/)"** (ou « vérification parfaite »). Si les hachages des métadonnées ne correspondent pas ou ne sont pas pris en compte lors de la vérification, il s'agirait d'une « correspondance partielle », ce qui est actuellement la méthode la plus courante pour vérifier les contrats. Il est possible [d'insérer du code malveillant](https://samczsun.com/hiding-in-plain-sight/) qui ne serait pas reflété dans le code source vérifié sans vérification complète. La plupart des développeurs ne sont pas au courant de la vérification complète et ne conservent pas le fichier de métadonnées de leur compilation, c'est pourquoi la vérification partielle a été la méthode habituelle de vérification des contrats jusqu'à présent.
+Ce type de vérification qui exploite le hachage des métadonnées est appelé **« [vérification complète](https://docs.sourcify.dev/docs/full-vs-partial-match/) »** (également « vérification parfaite »). Si les hachages des métadonnées ne correspondent pas ou ne sont pas pris en compte lors de la vérification, il s'agirait d'une « correspondance partielle », ce qui est actuellement la méthode la plus courante pour vérifier les contrats. Il est possible d'[insérer du code malveillant](https://samczsun.com/hiding-in-plain-sight/) qui ne serait pas reflété dans le code source vérifié sans une vérification complète. La plupart des développeurs ne sont pas au courant de la vérification complète et ne conservent pas le fichier de métadonnées de leur compilation, c'est pourquoi la vérification partielle a été la méthode habituelle de vérification des contrats jusqu'à présent.
 
 ## Pourquoi la vérification du code source est-elle importante ? {#importance-of-source-code-verification}
 
 ### Absence de confiance {#trustlessness}
 
-L'absence de confiance est sans doute la principale motivation des contrats intelligents et des [applications décentralisées (DApps)](/developers/docs/dapps/). Les contrats intelligents sont « immuables » et ne peuvent pas être modifiés ; un contrat n'exécutera que la logique définie dans le code au moment du déploiement. Les développeurs et les entreprises ne peuvent donc pas modifier le code d'un contrat après l'avoir déployé sur Ethereum.
+L'absence de confiance est sans doute le principe de base des contrats intelligents et des [applications décentralisées (dapps)](/developers/docs/dapps/). Les contrats intelligents sont « immuables » et ne peuvent pas être modifiés ; un contrat n'exécutera que la logique définie dans le code au moment du déploiement. Les développeurs et les entreprises ne peuvent donc pas modifier le code d'un contrat après l'avoir déployé sur Ethereum.
 
 Pour qu'un contrat intelligent soit sans confiance, le code du contrat doit pouvoir faire l'objet d'une vérification indépendante. Bien que le bytecode compilé pour chaque contrat intelligent soit publiquement disponible sur la blockchain, le langage de bas niveau est difficile à comprendre, tant pour les développeurs que pour les utilisateurs.
 
@@ -40,13 +40,13 @@ Les outils de vérification du code source garantissent que les fichiers du code
 
 ### Sécurité des utilisateurs {#user-safety}
 
-Avec les contrats intelligents, il y a généralement beaucoup d'argent en jeu. Cela nécessite des garanties de sécurité plus élevées et la vérification de la logique d'un contrat intelligent avant de l'utiliser. Le problème est que des développeurs peu scrupuleux peuvent tromper les utilisateurs en insérant du code malveillant dans un contrat intelligent. Sans vérification, les contrats intelligents malveillants peuvent présenter des [backdoors](https://www.trustnodes.com/2018/11/10/concerns-rise-over-backdoored-smart-contracts), des mécanismes de contrôle d'accès controversés, des vulnérabilités exploitables et d'autres éléments qui mettent en péril la sécurité des utilisateurs et qui ne seraient pas détectés.
+Avec les contrats intelligents, il y a généralement beaucoup d'argent en jeu. Cela nécessite des garanties de sécurité plus élevées et la vérification de la logique d'un contrat intelligent avant de l'utiliser. Le problème est que des développeurs peu scrupuleux peuvent tromper les utilisateurs en insérant du code malveillant dans un contrat intelligent. Sans vérification, les contrats intelligents malveillants peuvent comporter des [backdoors](https://www.trustnodes.com/2018/11/10/concerns-rise-over-backdoored-smart-contracts), des mécanismes de contrôle d'accès controversés, des vulnérabilités exploitables et d'autres éléments qui compromettent la sécurité des utilisateurs et qui passeraient inaperçus.
 
 Publier les fichiers du code source d'un contrat intelligent permet aux personnes intéressées, telles que les auditeurs, d'évaluer plus facilement le contrat pour y déceler des vecteurs d'attaque potentiels. La vérification indépendante d'un contrat intelligent par plusieurs entités permet aux utilisateurs de bénéficier de garanties plus solides quant à sa sécurité.
 
 ## Comment vérifier le code source des contrats intelligents Ethereum {#source-code-verification-for-ethereum-smart-contracts}
 
-[Le déploiement d'un contrat intelligent sur Ethereum](/developers/docs/smart-contracts/deploying/) nécessite l'envoi d'une transaction avec une charge utile de données (bytecode compilé) vers une adresse spéciale. Les données utiles sont générées par la compilation du code source et les [arguments du constructeur](https://docs.soliditylang.org/en/v0.8.14/contracts.html#constructor) de l'instance de contrat ajoutés à la charge utile des données dans la transaction. La compilation est déterministe, ce qui signifie qu'elle produit toujours le même résultat (c'est-à-dire le bytecode du contrat) si les mêmes fichiers sources et les mêmes paramètres de compilation (par ex. la version du compilateur, l'optimiseur) sont utilisés.
+[Le déploiement d'un contrat intelligent sur Ethereum](/developers/docs/smart-contracts/deploying/) nécessite l'envoi d'une transaction avec une charge utile de données (bytecode compilé) à une adresse spéciale. La charge utile de données est générée en compilant le code source, plus les [arguments du constructeur](https://docs.soliditylang.org/en/v0.8.14/contracts.html#constructor) de l'instance de contrat qui sont ajoutés à la charge utile de données dans la transaction. La compilation est déterministe, ce qui signifie qu'elle produit toujours le même résultat (c'est-à-dire le bytecode du contrat) si les mêmes fichiers sources et les mêmes paramètres de compilation (par ex. la version du compilateur, l'optimiseur) sont utilisés.
 
 ![Un diagramme montrant la vérification du code source d'un contrat intelligent](./source-code-verification.png)
 
@@ -62,7 +62,7 @@ La vérification d'un contrat intelligent comprend essentiellement les étapes s
 
 5. De plus, si les hachages de métadonnées à la fin du bytecode correspondent, il s'agira d'une correspondance complète.
 
-Notez qu'il s'agit d'une description simpliste de la vérification et qu'il existe de nombreuses exceptions qui ne fonctionneraient pas avec cette méthode, comme les [variables immuables](https://docs.sourcify.dev/docs/immutables/).
+Notez qu'il s'agit d'une description simpliste de la vérification et qu'il existe de nombreuses exceptions qui ne fonctionneraient pas avec cela, comme le fait d'avoir des [variables immuables](https://docs.sourcify.dev/docs/immutables/).
 
 ## Outils de vérification du code source {#source-code-verification-tools}
 
@@ -70,38 +70,44 @@ Le processus traditionnel de vérification des contrats peut être complexe. C'e
 
 ### Etherscan {#etherscan}
 
-Bien que principalement connu comme un [explorateur de la blockchain Ethereum](/developers/docs/data-and-analytics/block-explorers/), Etherscan propose également un [service de vérification de source code](https://etherscan.io/verifyContract) pour les développeurs et les utilisateurs de contrats intelligents.
+Bien que principalement connu en tant qu'[explorateur de la blockchain Ethereum](/developers/docs/data-and-analytics/block-explorers/), Etherscan propose également un [service de vérification de code source](https://etherscan.io/verifyContract) pour les développeurs et les utilisateurs de contrats intelligents.
 
-Etherscan vous permet de recompiler le bytecode du contrat à partir de la charge utile des données originales (code source, adresse de la bibliothèque, paramètres du compilateur, adresse du contrat, etc.) Si le bytecode recompilé est identifié comme étant identique au bytecode (et aux paramètres du constructeur) du contrat en chaîne, alors [le contrat est vérifié](https://info.etherscan.com/types-of-contract-verification/).
+Etherscan vous permet de recompiler le bytecode du contrat à partir de la charge utile des données originales (code source, adresse de la bibliothèque, paramètres du compilateur, adresse du contrat, etc.) Si le bytecode recompilé est associé au bytecode (et aux paramètres du constructeur) du contrat en chaîne, alors [le contrat est vérifié](https://info.etherscan.com/types-of-contract-verification/).
 
-Une fois vérifié, le code source de votre contrat reçoit un label « vérifié » et est publié sur Etherscan pour que d'autres puissent l'auditer. Il est également ajouté à la section [Contrats vérifiés](https://etherscan.io/contractsVerified/) - un répertoire de contrats intelligents dont les codes sources ont été vérifiés.
+Une fois vérifié, le code source de votre contrat reçoit un label « vérifié » et est publié sur Etherscan pour que d'autres puissent l'auditer. Il est également ajouté à la section [Contrats vérifiés](https://etherscan.io/contractsVerified/) — un répertoire de contrats intelligents dont les codes sources ont été vérifiés.
 
-Etherscan est l'outil le plus utilisé pour vérifier les contrats. Cependant, la vérification de contrat d'Etherscan présente un inconvénient : elle ne parvient pas à comparer le **hachage de métadonnées** du bytecode en chaîne et du bytecode recompilé. Par conséquent, les correspondances Etherscan sont des correspondances partielles.
+Etherscan est l'outil le plus utilisé pour vérifier les contrats. Cependant, la vérification de contrat d'Etherscan présente un inconvénient : elle ne parvient pas à comparer le **hachage des métadonnées** du bytecode en chaîne et du bytecode recompilé. Par conséquent, les correspondances Etherscan sont des correspondances partielles.
 
-[Plus d'informations sur la vérification des contrats sur Etherscan](https://medium.com/etherscan-blog/verifying-contracts-on-etherscan-f995ab772327).
+[En savoir plus sur la vérification des contrats sur Etherscan](https://medium.com/etherscan-blog/verifying-contracts-on-etherscan-f995ab772327).
+
+### Blockscout {#blockscout}
+
+[Blockscout](https://blockscout.com/) est un explorateur de blockchain open source qui fournit également un [service de vérification de contrat](https://eth.blockscout.com/contract-verification) pour les développeurs et les utilisateurs de contrats intelligents. En tant qu'alternative open source, Blockscout offre une transparence totale sur la manière dont la vérification est effectuée et permet à la communauté de contribuer à l'amélioration du processus de vérification.
+
+Tout comme d'autres services de vérification, Blockscout vous permet de vérifier le code source de votre contrat en recompilant le bytecode et en le comparant au contrat déployé. Une fois vérifié, votre contrat reçoit le statut « vérifié » et le code source devient accessible au public pour l'audit et les interactions. Les contrats vérifiés sont également répertoriés dans le [dépôt de contrats vérifiés](https://eth.blockscout.com/verified-contracts) de Blockscout pour faciliter leur consultation et leur découverte.
 
 ### Sourcify {#sourcify}
 
-[Sourcify](https://sourcify.dev/#/verifier) est un autre outil de vérification de contrats open-source et décentralisé. Ce n'est pas un explorateur de blocs et il ne vérifie que les contrats sur [différents réseaux basés sur l'EVM](https://docs.sourcify.dev/docs/chains). Il agit comme une infrastructure publique sur laquelle d'autres outils peuvent se baser, et vise à permettre des interactions contractuelles plus conviviales en utilisant les commentaires [ABI](/developers/docs/smart-contracts/compiling/#web-applications) et [NatSpec](https://docs.soliditylang.org/en/v0.8.15/natspec-format.html) trouvés dans le fichier de métadonnées.
+[Sourcify](https://sourcify.dev/#/verifier) est un autre outil de vérification de contrats, open source et décentralisé. Ce n'est pas un explorateur de blocs et il ne vérifie que les contrats sur [différents réseaux basés sur l'EVM](https://docs.sourcify.dev/docs/chains). Il agit comme une infrastructure publique sur laquelle d'autres outils peuvent s'appuyer et vise à permettre des interactions contractuelles plus conviviales en utilisant les commentaires [ABI](/developers/docs/smart-contracts/compiling/#web-applications) et [NatSpec](https://docs.soliditylang.org/en/v0.8.15/natspec-format.html) que l'on trouve dans le fichier de métadonnées.
 
-Contrairement à Etherscan, Sourcify prend en charge les correspondances complètes avec le hachage des métadonnées. Les contrats vérifiés sont disponibles sur son [dépôt public](https://docs.sourcify.dev/docs/repository/) en HTTP et [IPFS](https://docs.ipfs.io/concepts/what-is-ipfs/#what-is-ipfs), qui est un stockage décentralisé à [adressage de contenu](https://web3.storage/docs/concepts/content-addressing/). Cela permet de récupérer le fichier de métadonnées d'un contrat via IPFS puisque le hachage des métadonnées annexé est un hachage IPFS.
+Contrairement à Etherscan, Sourcify prend en charge les correspondances complètes avec le hachage des métadonnées. Les contrats vérifiés sont servis dans son [dépôt public](https://docs.sourcify.dev/docs/repository/) sur HTTP et [IPFS](https://docs.ipfs.io/concepts/what-is-ipfs/#what-is-ipfs), qui est un stockage décentralisé et [adressé par le contenu](https://docs.storacha.network/concepts/content-addressing/). Cela permet de récupérer le fichier de métadonnées d'un contrat via IPFS puisque le hachage des métadonnées annexé est un hachage IPFS.
 
-De plus, il est également possible de récupérer les fichiers de code source via IPFS, car les hachages IPFS de ces fichiers se trouvent également dans les métadonnées. Un contrat peut être vérifié en fournissant le fichier de métadonnées et les fichiers sources via son API, via [l'UI](https://sourcify.dev/#/verifier), ou en utilisant les plugins. L'outil de monitoring Sourcify surveille également les créations de contrats sur les nouveaux blocs et tente de vérifier les contrats si leurs métadonnées et leurs fichiers sources sont publiés sur IPFS.
+De plus, il est également possible de récupérer les fichiers de code source via IPFS, car les hachages IPFS de ces fichiers se trouvent également dans les métadonnées. Un contrat peut être vérifié en fournissant le fichier de métadonnées et les fichiers sources via son API, son [interface utilisateur](https://sourcify.dev/#/verifier) ou en utilisant des plugins. L'outil de monitoring Sourcify surveille également les créations de contrats sur les nouveaux blocs et tente de vérifier les contrats si leurs métadonnées et leurs fichiers sources sont publiés sur IPFS.
 
-[Plus d'informations sur la vérification des contrats sur Sourcify](https://blog.soliditylang.org/2020/06/25/sourcify-faq/).
+[En savoir plus sur la vérification des contrats sur Sourcify](https://soliditylang.org/blog/2020/06/25/sourcify-faq/).
 
 ### Tenderly {#tenderly}
 
-La [plateforme Tenderly](https://tenderly.co/) permet aux développeurs Web3 de concevoir, tester, contrôler et opérer des contrats intelligents. En combinant des outils de débogage avec une observabilité et des blocs de construction d'infrastructure, Tenderly aide les développeurs à accélérer le développement de contrats intelligents. Pour activer pleinement les fonctionnalités de Tenderly, les développeurs doivent [effectuer une vérification du code source](https://docs.tenderly.co/monitoring/contract-verification) à l'aide de plusieurs méthodes.
+La [plateforme Tenderly](https://tenderly.co/) permet aux développeurs Web3 de créer, tester, surveiller et exploiter des contrats intelligents. En combinant des outils de débogage avec une observabilité et des blocs de construction d'infrastructure, Tenderly aide les développeurs à accélérer le développement de contrats intelligents. Pour activer pleinement les fonctionnalités de Tenderly, les développeurs doivent [effectuer une vérification du code source](https://docs.tenderly.co/monitoring/contract-verification) à l'aide de plusieurs méthodes.
 
 On peut vérifier un contrat de manière privée ou publique. S'il est vérifié en privé, le contrat intelligent n'est visible que par vous (et les autres membres de votre projet). La vérification publique d'un contrat le rend visible à tous les utilisateurs de la plateforme Tenderly.
 
-Vous pouvez vérifier vos contrats en utilisant le [Tableau de bord](https://docs.tenderly.co/monitoring/smart-contract-verification/verifying-a-smart-contract), le [plugin Tenderly pour Hardhat](https://docs.tenderly.co/monitoring/smart-contract-verification/verifying-contracts-using-the-tenderly-hardhat-plugin) ou le [CLI](https://docs.tenderly.co/monitoring/smart-contract-verification/verifying-contracts-using-cli).
+Vous pouvez vérifier vos contrats en utilisant le [tableau de bord](https://docs.tenderly.co/contract-verification), le [plugin Tenderly pour Hardhat](https://docs.tenderly.co/contract-verification/hardhat), ou la [CLI](https://docs.tenderly.co/monitoring/smart-contract-verification/verifying-contracts-using-cli).
 
 Lors de la vérification des contrats via le Tableau de bord, vous devez importer le fichier source ou le fichier de métadonnées généré par le compilateur Solidity, l'adresse/le réseau et les paramètres du compilateur.
 
 L'utilisation du plugin Tenderly Hardhat permet de mieux contrôler le processus de vérification à moindre effort, en vous permettant de choisir entre la vérification automatique (sans code) et la vérification manuelle (avec code).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Vérification du code source d'un contrat](https://programtheblockchain.com/posts/2018/01/16/verifying-contract-source-code/)
+- [Vérification du code source du contrat](https://programtheblockchain.com/posts/2018/01/16/verifying-contract-source-code/)
diff --git a/public/content/translations/fr/developers/docs/standards/index.md b/public/content/translations/fr/developers/docs/standards/index.md
index 6962b8a2868..ba41e2c37c3 100644
--- a/public/content/translations/fr/developers/docs/standards/index.md
+++ b/public/content/translations/fr/developers/docs/standards/index.md
@@ -1,58 +1,58 @@
 ---
-title: Normes de développement Ethereum
-description:
+title: "Normes de développement Ethereum"
+description: "Découvrez les normes Ethereum, y compris les EIP, les normes de jetons comme ERC-20 et ERC-721, et les conventions de développement."
 lang: fr
 incomplete: true
 ---
 
-## Vue d'ensemble des normes {#standards-overview}
+## Aperçu des normes {#standards-overview}
 
-La communauté Ethereum a adopté de nombreuses normes qui aident à maintenir l'interopérabilité des projets (comme les [clients Ethereum](/developers/docs/nodes-and-clients/) et les portefeuilles) entre les implémentations, et garantir que les contrats intelligents et les DApps restent composables.
+La communauté Ethereum a adopté de nombreuses normes qui aident à maintenir l'interopérabilité des projets (tels que les [clients Ethereum](/developers/docs/nodes-and-clients/) et les portefeuilles) entre les implémentations, et à garantir que les contrats intelligents et les dapps restent composables.
 
-Ces normes sont généralement présentées via les [propositions d'amélioration d'Ethereum (EIP)](/eips/), qui sont discutées entre les membres de la communauté selon un [processus standard](https://eips.ethereum.org/EIPS/eip-1).
+Les normes sont généralement introduites en tant que [Propositions d'amélioration d'Ethereum](/eips/) (EIP), qui sont discutées par les membres de la communauté via un [processus standard](https://eips.ethereum.org/EIPS/eip-1).
 
 - [Introduction aux EIP](/eips/)
 - [Liste des EIP](https://eips.ethereum.org/)
-- [Repo GitHub EIP](https://github.com/ethereum/EIPs)
-- [Forum de discussions sur les EIP](https://ethereum-magicians.org/c/eips)
+- [Dépôt GitHub des EIP](https://github.com/ethereum/EIPs)
+- [Forum de discussion sur les EIP](https://ethereum-magicians.org/c/eips)
 - [Introduction à la gouvernance d'Ethereum](/governance/)
-- [Ethereum Governance Overview](https://web.archive.org/web/20201107234050/https://blog.bmannconsulting.com/ethereum-governance/) _- Boris Mann, 31 mars 2019_
-- [Ethereum Protocol Development Governance and Network Upgrade Coordination](https://hudsonjameson.com/posts/2020-03-23-ethereum-protocol-development-governance-and-network-upgrade-coordination/) _- Hudson Jameson, 23 mars 2020_
-- [Playlist de toutes les rencontres de l'équipe de développement de base Ethereum](https://www.youtube.com/@EthereumProtocol) _(YouTube Playlist)_
+- [Aperçu de la gouvernance d'Ethereum](https://web.archive.org/web/20201107234050/https://blog.bmannconsulting.com/ethereum-governance/) _31 mars 2019 - Boris Mann_
+- [Gouvernance du développement du protocole Ethereum et coordination de la mise à niveau du réseau](https://hudsonjameson.com/posts/2020-03-23-ethereum-protocol-development-governance-and-network-upgrade-coordination/) _23 mars 2020 - Hudson Jameson_
+- [Playlist de toutes les réunions des développeurs principaux d'Ethereum](https://www.youtube.com/@EthereumProtocol) _(Playlist YouTube)_
 
 ## Types de normes {#types-of-standards}
 
 Il existe trois types d'EIP :
 
 - Suivi standard : décrit tout changement qui atteint la plupart ou toutes les implémentations d'Ethereum
-- [Meta Track](https://eips.ethereum.org/meta) : décrit un processus entourant Ethereum ou propose une modification d'un processus
-- [Piste d'information](https://eips.ethereum.org/informational) : décrit une anomalie de conception Ethereum ou fournit des directives générales ou des informations à la communauté Ethereum
+- [Voie Méta](https://eips.ethereum.org/meta) : décrit un processus relatif à Ethereum ou propose une modification d'un processus
+- [Voie informationnelle](https://eips.ethereum.org/informational) : décrit un problème de conception d'Ethereum ou fournit des directives générales ou des informations à la communauté Ethereum
 
 De plus, le Standard Track est subdivisé en 4 catégories :
 
-- [Noyau](https://eips.ethereum.org/core) : améliorations nécessitant un fork de consensus
-- [Réseau](https://eips.ethereum.org/networking) : améliorations autour de devp2p et du sous-protocole Ethereum léger, ainsi que des améliorations proposées aux spécifications du protocole réseau de whisper et star.
-- [Interface](https://eips.ethereum.org/interface) : améliorations autour des spécifications et des normes API/RPC des clients, et de certaines normes au niveau du langage comme les noms de méthodes et les ABI des contrats.
-- [ERC](https://eips.ethereum.org/erc) : normes et conventions au niveau des applications
+- [Cœur (Core)](https://eips.ethereum.org/core) : améliorations nécessitant une fourche (fork) de consensus
+- [Réseau](https://eips.ethereum.org/networking) : améliorations concernant devp2p et le sous-protocole Light Ethereum, ainsi que les améliorations proposées aux spécifications du protocole de réseau de Whisper et Swarm.
+- [Interface](https://eips.ethereum.org/interface) : améliorations des spécifications et des normes d'API/RPC du client, ainsi que de certaines normes au niveau du langage comme les noms de méthode et les ABI de contrat.
+- [ERC](https://eips.ethereum.org/erc) : normes et conventions au niveau de l'application
 
-Des informations plus détaillées sur ces différents types et catégories peuvent être trouvées dans [EIP-1](https://eips.ethereum.org/EIPS/eip-1#eip-types)
+Des informations plus détaillées sur ces différents types et catégories sont disponibles dans [EIP-1](https://eips.ethereum.org/EIPS/eip-1#eip-types)
 
 ### Normes de jetons {#token-standards}
 
-- [ERC-20](/developers/docs/standards/tokens/erc-20/) - Une interface type pour les jetons fongibles (interchangeables) comme les jetons de vote, les jetons d'enjeu ou les monnaies virtuelles.
-  - [ERC-223](/developers/docs/standards/tokens/erc-223/) - Une norme de jetons fongibles qui rend les jetons identiques à l'éther et prend en charge la gestion des transferts de jetons du côté des destinataires.
-  - [ERC-1363](/developers/docs/standards/tokens/erc-1363/) - Définit une interface de jeton pour les jetons ERC-20 qui prend en charge l'exécution du code du destinataire après transfert ou transferFrom, ou du code de l'expéditeur après approbation.
-- [ERC-721](/developers/docs/standards/tokens/erc-721/) - Une interface type pour les jetons non fongibles, comme ceux requis pour les œuvres d'art ou une chanson.
-  - [ERC-2309](https://eips.ethereum.org/EIPS/eip-2309) - Événement normalisé émis lors de la création/du transfert d'un, ou de plusieurs jetons non fongibles à l'aide d'identifiants de jetons consécutifs.
-  - [ERC-4400](https://eips.ethereum.org/EIPS/eip-4400) - Extension de l'interface pour le rôle de consommateur EIP-721.
-  - [ERC-4907](https://eips.ethereum.org/EIPS/eip-4907) - Ajouter un rôle limité dans le temps avec des autorisations restreintes aux jetons ERC-721.
-- [ERC-777](/developers/docs/standards/tokens/erc-777/) - **(NON RECOMMANDÉ)** Une norme de jeton améliorant ERC-20.
-- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - Un type de jeton qui peut contenir des actifs fongibles et non fongibles.
-- [ERC-4626](/developers/docs/standards/tokens/erc-4626/) - Un standard de coffre tokenisé conçu pour optimiser et unifier les paramètres techniques des coffres à rendement.
+- [ERC-20](/developers/docs/standards/tokens/erc-20/) - Une interface standard pour les jetons fongibles (interchangeables), comme les jetons de vote, les jetons de staking ou les monnaies virtuelles.
+  - [ERC-223](/developers/docs/standards/tokens/erc-223/) - Une norme de jetons fongibles qui rend les jetons identiques à l'ether et prend en charge la gestion des transferts de jetons du côté des destinataires.
+  - [ERC-1363](/developers/docs/standards/tokens/erc-1363/) - Une interface d'extension pour les jetons ERC-20 qui prend en charge l'exécution de rappels (callbacks) sur les contrats destinataires en une seule transaction.
+- [ERC-721](/developers/docs/standards/tokens/erc-721/) - Une interface standard pour les jetons non fongibles (NFT), comme un titre de propriété pour une œuvre d'art ou une chanson.
+  - [ERC-2309](https://eips.ethereum.org/EIPS/eip-2309) - Un événement normalisé émis lors de la création/du transfert d'un ou de plusieurs jetons non fongibles à l'aide d'identifiants de jetons consécutifs.
+  - [ERC-4400](https://eips.ethereum.org/EIPS/eip-4400) - Extension d'interface pour le rôle de consommateur de l'EIP-721.
+  - [ERC-4907](https://eips.ethereum.org/EIPS/eip-4907) - Ajoute un rôle à durée limitée avec des autorisations restreintes aux jetons ERC-721.
+- [ERC-777](/developers/docs/standards/tokens/erc-777/) - **(NON RECOMMANDÉ)** Une norme de jeton qui améliore l'ERC-20.
+- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - Une norme de jeton qui peut contenir à la fois des actifs fongibles et non fongibles.
+- [ERC-4626](/developers/docs/standards/tokens/erc-4626/) - Une norme de coffre-fort tokenisé conçue pour optimiser et unifier les paramètres techniques des coffres-forts à rendement.
 
-En savoir plus sur les [normes de jetons](/developers/docs/standards/tokens/)
+En savoir plus sur les [normes de jetons](/developers/docs/standards/tokens/).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [Propositions d'amélioration d'Ethereum (EIP)](/eips/)
 
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-1155/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-1155/index.md
index a44bb34e82d..98823c0981f 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/erc-1155/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-1155/index.md
@@ -1,35 +1,35 @@
 ---
 title: Norme de multijeton ERC-1155
-description:
+description: En savoir plus sur l'ERC-1155, une norme multi-jetons qui combine des jetons fongibles et non fongibles dans un seul contrat.
 lang: fr
 ---
 
 ## Introduction {#introduction}
 
-Une interface standard pour les contrats qui gèrent plusieurs types de jetons. Un seul contrat déployé peut intégrer une combinaison de jetons fongibles, de jetons non fongibles ou encore d'autres configurations (par exemple des jetons semi-fongibles).
+Une interface standard pour les contrats qui gèrent plusieurs types de jetons. Un seul contrat déployé peut inclure n'importe quelle combinaison de jetons fongibles, de jetons non fongibles ou d'autres configurations (p. ex. des jetons semi-fongibles).
 
-**Qu’entend-on par norme multijeton ?**
+**Qu'entend-on par norme multi-jetons ?**
 
-L'idée est simple et cherche à créer une interface de contrat intelligent qui peut représenter et contrôler n'importe quel nombre de types de jetons fongibles et non fongibles. De cette façon, le jeton ERC-1155 peut exécuter les mêmes fonctions qu'un jeton [ERC-20](/developers/docs/standards/tokens/erc-20/) et [ERC-721](/developers/docs/standards/tokens/erc-721/) et même les deux en même temps. Cela améliore la fonctionnalité des normes ERC-20 et ERC-721, ce qui la rend plus efficace et corrige les erreurs évidentes de mise en œuvre.
+L'idée est simple et cherche à créer une interface de contrat intelligent qui peut représenter et contrôler n'importe quel nombre de types de jetons fongibles et non fongibles. De cette manière, le jeton ERC-1155 peut exécuter les mêmes fonctions qu'un jeton [ERC-20](/developers/docs/standards/tokens/erc-20/) et [ERC-721](/developers/docs/standards/tokens/erc-721/), et même les deux en même temps. Cela améliore la fonctionnalité des normes ERC-20 et ERC-721, ce qui la rend plus efficace et corrige les erreurs évidentes de mise en œuvre.
 
-Le jeton ERC-1155 est décrit dans les détails dans [EIP-1155](https://eips.ethereum.org/EIPS/eip-1155).
+Le jeton ERC-1155 est entièrement décrit dans l'[EIP-1155](https://eips.ethereum.org/EIPS/eip-1155).
 
 ## Prérequis {#prerequisites}
 
-Pour mieux comprendre cette page, nous vous recommandons de commencer par lire celles concernant [les normes de jeton](/developers/docs/standards/tokens/), [ERC-20](/developers/docs/standards/tokens/erc-20/), et [ERC-721](/developers/docs/standards/tokens/erc-721/).
+Pour mieux comprendre cette page, nous vous recommandons de vous informer d'abord sur les [normes de jetons](/developers/docs/standards/tokens/), l'[ERC-20](/developers/docs/standards/tokens/erc-20/) et l'[ERC-721](/developers/docs/standards/tokens/erc-721/).
 
-## Fonctions et fonctionnalités ERC-1155 : {#body}
+## Fonctions et fonctionnalités de l'ERC-1155 : {#body}
 
-- [Transfert par lot](#batch_transfers) : Transférer plusieurs actifs en un seul appel.
-- [Solde par lot](#batch_balance) : Obtenez les soldes de plusieurs actifs en un seul appel.
-- [Approbation par lot](#batch_approval) : Approuver tous les jetons à une adresse.
-- [Crochets](#recieve_hook) : Recevoir des crochets de jetons.
-- [Support NFT](#nft_support) : Si l'échange est unique, le traiter comme NFT.
-- [Règles de transfert sécurisées](#safe_transfer_rule) : Ensemble de règles pour sécuriser un transfert.
+- [Transfert par lots](#batch_transfers) : transférez plusieurs actifs en un seul appel.
+- [Solde par lots](#batch_balance) : obtenez les soldes de plusieurs actifs en un seul appel.
+- [Approbation par lots](#batch_approval) : approuvez tous les jetons à une adresse.
+- [Hooks](#receive_hook) : hook de réception de jetons.
+- [Support NFT](#nft_support) : si l'offre n'est que de 1, traitez-le comme un NFT.
+- [Règles de transfert sécurisé](#safe_transfer_rule) : ensemble de règles pour un transfert sécurisé.
 
-### Transferts par lot {#batch-transfers}
+### Transferts par lots {#batch-transfers}
 
-Les transferts par lot fonctionnent de la même façon que les transferts réguliers ERC-20. Examinons la fonction régulière `transferFrom` ERC-20 :
+Les transferts par lot fonctionnent de la même façon que les transferts réguliers ERC-20. Examinons la fonction `transferFrom` standard de l'ERC-20 :
 
 ```solidity
 // ERC-20
@@ -45,17 +45,17 @@ function safeBatchTransferFrom(
 ) external;
 ```
 
-La seule différence avec ERC-1155 est que nous passons les valeurs en tant que tableau et que nous fournissons également un tableau d'identifiants. Par exemple compte tenu de `ids=[3, 6, 13]` et `values=[100, 200, 5]`, les transferts résultants seront
+La seule différence avec ERC-1155 est que nous passons les valeurs en tant que tableau et que nous fournissons également un tableau d'identifiants. Par exemple, pour `ids=[3, 6, 13]` et `values=[100, 200, 5]`, les transferts résultants seront
 
-1. Transférez 100 jetons avec l'id 3 de `_from` à `_to`.
-2. Transférez 200 jetons avec l'id 6 de `_from` à `_to`.
-3. Transférez 5 jetons avec l'id 13 de `_from` à `_to`.
+1. Transfert de 100 jetons avec l'id 3 de `_from` vers `_to`.
+2. Transfert de 200 jetons avec l'id 6 de `_from` vers `_to`.
+3. Transfert de 5 jetons avec l'id 13 de `_from` vers `_to`.
 
-Dans l'ERC-1155, nous n'avons que `transferFrom` et non `transfert`. Pour l'utiliser comme un `transfer` régulier, il suffit de définir l'adresse d'expéditeur sur l'adresse qui appelle la fonction.
+Dans l'ERC-1155, nous avons uniquement `transferFrom`, pas `transfer`. Pour l'utiliser comme une fonction `transfer` classique, il suffit de définir l'adresse d'expédition comme étant l'adresse qui appelle la fonction.
 
-### Solde par lot {#batch-balance}
+### Solde par lots {#batch-balance}
 
-L'appel ERC-20 `balanceOf` dispose également de sa fonction de partenaire avec le support par lots. Pour rappel, ceci est la version ERC-20 :
+L'appel `balanceOf` de l'ERC-20 a également sa fonction partenaire avec prise en charge des lots. Pour rappel, ceci est la version ERC-20 :
 
 ```solidity
 // ERC-20
@@ -70,7 +70,7 @@ function balanceOfBatch(
 
 Encore plus simple pour l'appel de solde, nous pouvons récupérer plusieurs soldes en un seul appel. Nous passons le tableau des propriétaires, suivi du tableau des identifiants de jetons.
 
-Par exemple, pour les données `_ids=[3, 6, 13]` et `_owners=[0xbeef..., 0x1337..., 0x1111...]`, la valeur retournée sera
+Par exemple, pour `_ids=[3, 6, 13]` et `_owners=[0xbeef..., 0x1337..., 0x1111...]`, la valeur renvoyée sera
 
 ```solidity
 [
@@ -80,7 +80,7 @@ Par exemple, pour les données `_ids=[3, 6, 13]` et `_owners=[0xbeef..., 0x1337.
 ]
 ```
 
-### Approbation par lot {#batch-approval}
+### Approbation par lots {#batch-approval}
 
 ```solidity
 // ERC-1155
@@ -95,13 +95,13 @@ function isApprovedForAll(
 ) external view returns (bool);
 ```
 
-Les approbations sont légèrement différentes de l'ERC-20. Au lieu d'approuver des montants spécifiques, vous définissez un opérateur qui approuvera ou non via `setApprovalForAll`.
+Les approbations sont légèrement différentes de l'ERC-20. Au lieu d'approuver des montants spécifiques, vous définissez un opérateur comme approuvé ou non approuvé via `setApprovalForAll`.
 
-La lecture du statut actuel peut être exécutée via `isApprovedForAll`. Comme vous pouvez le voir, c'est une opération tout ou rien. Vous ne pouvez pas définir le nombre de jetons ou même la classe de jeton à approuver.
+La lecture de l'état actuel peut se faire via `isApprovedForAll`. Comme vous pouvez le voir, c'est une opération tout ou rien. Vous ne pouvez pas définir le nombre de jetons ou même la classe de jeton à approuver.
 
 Cela a été conçu intentionnellement en gardant à l'esprit le principe de simplicité. Vous ne pouvez tout approuver que pour une seule adresse.
 
-### Recevoir un crochet {#receive-hook}
+### Hook de réception {#receive-hook}
 
 ```solidity
 function onERC1155BatchReceived(
@@ -113,7 +113,7 @@ function onERC1155BatchReceived(
 ) external returns(bytes4);
 ```
 
-Au regard du support [EIP-165](https://eips.ethereum.org/EIPS/eip-165), le support ERC-1155 ne prend en charge que les crochets pour les contrats intelligents. La fonction crochet doit retourner une valeur magique prédéfinie bytes4 qui est donnée en tant que :
+Étant donné la prise en charge de l'[EIP-165](https://eips.ethereum.org/EIPS/eip-165), l'ERC-1155 ne prend en charge les hooks de réception que pour les contrats intelligents. La fonction crochet doit retourner une valeur magique prédéfinie bytes4 qui est donnée en tant que :
 
 ```solidity
 bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
@@ -121,7 +121,7 @@ bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],byt
 
 Lorsque le contrat de réception renvoie cette valeur, cela suppose que le contrat accepte le transfert et sait gérer les jetons ERC-1155. Génial, plus aucun jeton coincé dans un contrat !
 
-### Prise en charge NFT {#nft-support}
+### Support NFT {#nft-support}
 
 Lorsque la fourniture est unique, le jeton est essentiellement un jeton non fongible (NFT). Et comme c'est la norme pour ERC-721, vous pouvez définir une URL de métadonnées. L'URL peut être lue et modifiée par les clients, voir [ici](https://eips.ethereum.org/EIPS/eip-1155#metadata).
 
@@ -129,18 +129,18 @@ Lorsque la fourniture est unique, le jeton est essentiellement un jeton non fong
 
 Nous avons déjà abordé quelques règles de transfert sécurisé dans les explications précédentes. Mais concentrons-nous sur les règles les plus importantes :
 
-1. L'appelant doit être approuvé pour envoyer les jetons depuis l'adresse `_from` ou l'appelant doit être égal à `_from`.
+1. L'appelant doit être approuvé pour dépenser les jetons de l'adresse `_from` ou l'appelant doit être égal à `_from`.
 2. L'appel de transfert doit être annulé si
    1. l'adresse `_to` est 0.
-   2. la longueur des `_ids` n'est pas la même que la longueur des `_values`.
-   3. le(s) solde(s) du(des) détenteur(s) de jeton(s) dans `_ids` est(sont) inférieur(s) au(x) montant(s) respectif(s) dans les `_values` envoyées au destinataire.
+   2. la longueur de `_ids` n'est pas la même que la longueur de `_values`.
+   3. l'un des soldes du ou des détenteurs pour le(s) jeton(s) dans `_ids` est inférieur au(x) montant(s) respectif(s) dans `_values` envoyé(s) au destinataire.
    4. toute autre erreur se produit.
 
-_Note_ : Toutes les fonctions par lot, y compris le crochet, existent également en tant que versions sans lot. Cela renforce l'efficacité du carburant étant donné que le transfert d'un seul actif reste probablement la méthode la plus couramment utilisée. Nous les avons laissés à l'écart par souci de simplicité dans les explications, y compris des règles de transfert sécurisé. Les noms sont identiques, il suffit de supprimer le lot ('Batch)'.
+_Remarque_ : Toutes les fonctions de traitement par lots, y compris le hook, existent également en versions sans traitement par lots. Cela renforce l'efficacité du carburant étant donné que le transfert d'un seul actif reste probablement la méthode la plus couramment utilisée. Nous les avons laissés à l'écart par souci de simplicité dans les explications, y compris des règles de transfert sécurisé. Les noms sont identiques, il suffit de supprimer le lot ('Batch)'.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Norme de multijeton ERC-1155](https://eips.ethereum.org/EIPS/eip-1155)
-- [ERC-1155 : Documentation Openzeppelin](https://docs.openzeppelin.com/contracts/5.x/erc1155)
-- [ERC-1155 : Répertoire GitHub](https://github.com/enjin/erc-1155)
-- [API NFT d'Alchemy](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api)
+- [EIP-1155 : Norme multi-jetons](https://eips.ethereum.org/EIPS/eip-1155)
+- [ERC-1155 : Docs OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/erc1155)
+- [ERC-1155 : Dépôt GitHub](https://github.com/enjin/erc-1155)
+- [API NFT d'Alchemy](https://www.alchemy.com/docs/reference/nft-api-quickstart)
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-1363/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-1363/index.md
new file mode 100644
index 00000000000..78c643fbc2f
--- /dev/null
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-1363/index.md
@@ -0,0 +1,213 @@
+---
+title: Norme de jeton payable ERC-1363
+description: "L'ERC-1363 est une interface d'extension pour les jetons ERC-20 qui prend en charge l'exécution d'une logique personnalisée sur un contrat destinataire après les transferts, ou sur un contrat dépensier après les approbations, le tout au sein d'une seule transaction."
+lang: fr
+---
+
+## Introduction {#introduction}
+
+### Qu'est-ce que l'ERC-1363 ? {#what-is-erc1363}
+
+L'ERC-1363 est une interface d'extension pour les jetons ERC-20 qui prend en charge l'exécution d'une logique personnalisée sur un contrat destinataire après les transferts, ou sur un contrat dépensier après les approbations, le tout au sein d'une seule transaction.
+
+### Différences par rapport à l'ERC-20 {#erc20-differences}
+
+Les opérations standard ERC-20 telles que `transfer`, `transferFrom` et `approve` ne permettent pas l'exécution de code sur le contrat destinataire ou dépensier sans une transaction distincte.
+Cela introduit de la complexité dans le développement de l'interface utilisateur et des frictions lors de l'adoption, car les utilisateurs doivent attendre que la première transaction soit exécutée pour ensuite soumettre la seconde.
+Ils doivent également payer le GAS deux fois.
+
+L'ERC-1363 permet aux jetons fongibles d'effectuer des actions plus facilement et de fonctionner sans l'utilisation d'un auditeur hors chaîne.
+Il permet d'effectuer un rappel sur un contrat récepteur ou dépensier, après un transfert ou une approbation, en une seule transaction.
+
+## Prérequis {#prerequisites}
+
+Pour mieux comprendre cette page, nous vous recommandons de lire d'abord ce qui suit :
+
+- [Norme de jetons](/developers/docs/standards/tokens/)
+- [ERC-20](/developers/docs/standards/tokens/erc-20/)
+
+## Corps {#body}
+
+L'ERC-1363 introduit une API standard pour que les jetons ERC-20 interagissent avec les contrats intelligents après `transfer`, `transferFrom` ou `approve`.
+
+Cette norme fournit une fonctionnalité de base pour transférer des jetons, ainsi que pour permettre l'approbation de jetons afin qu'ils puissent être dépensés par un tiers sur la chaîne, puis effectuer un rappel sur le contrat récepteur ou dépensier.
+
+Il existe de nombreuses utilisations proposées de contrats intelligents pouvant accepter les rappels ERC-20.
+
+Par exemple :
+
+- **Ventes participatives** : les jetons envoyés déclenchent une allocation de récompense instantanée.
+- **Services** : le paiement active l'accès au service en une seule étape.
+- **Factures** : les jetons règlent les factures automatiquement.
+- **Abonnements** : l'approbation du tarif annuel active l'abonnement dès le paiement du premier mois.
+
+Pour ces raisons, il a été initialement nommé **\"Jeton payable\"**.
+
+Le comportement de rappel étend encore son utilité, permettant des interactions transparentes comme :
+
+- **Jalonnement** : les jetons transférés déclenchent un verrouillage automatique dans un contrat de jalonnement.
+- **Vote** : les jetons reçus enregistrent les votes dans un système de gouvernance.
+- **Échange** : les approbations de jetons activent la logique d'échange en une seule étape.
+
+Les jetons ERC-1363 peuvent être utilisés pour des utilitaires spécifiques dans tous les cas qui nécessitent l'exécution d'un rappel après un transfert ou une approbation reçue.
+L'ERC-1363 est également utile pour éviter la perte ou le verrouillage de jetons dans les contrats intelligents en vérifiant la capacité du destinataire à gérer les jetons.
+
+Contrairement à d'autres propositions d'extension ERC-20, l'ERC-1363 ne remplace pas les méthodes `transfer` et `transferFrom` de l'ERC-20 et définit les ID d'interfaces à implémenter tout en maintenant la rétrocompatibilité avec l'ERC-20.
+
+Provenant de l'[EIP-1363](https://eips.ethereum.org/EIPS/eip-1363):
+
+### Méthodes {#methods}
+
+Les contrats intelligents qui implémentent la norme ERC-1363 **DOIVENT** implémenter toutes les fonctions de l'interface `ERC1363`, ainsi que les interfaces `ERC20` et `ERC165`.
+
+```solidity
+pragma solidity ^0.8.0;
+
+/**
+ * @title ERC1363
+ * @dev Une interface d'extension pour les jetons ERC-20 qui prend en charge l'exécution de code sur un contrat destinataire
+ * après `transfer` ou `transferFrom`, ou de code sur un contrat dépensier après `approve`, en une seule transaction.
+ */
+interface ERC1363 is ERC20, ERC165 {
+  /*
+   * NOTE : l'identifiant ERC-165 pour cette interface est 0xb0202a11.
+   * 0xb0202a11 ===
+   *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
+   *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
+   *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
+   *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
+   *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
+   *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
+   */
+
+  /**
+   * @dev Déplace un montant `value` de jetons du compte de l'appelant vers `to`
+   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
+   * @param to L'adresse à laquelle les jetons sont transférés.
+   * @param value Le montant de jetons à transférer.
+   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
+   */
+  function transferAndCall(address to, uint256 value) external returns (bool);
+
+  /**
+   * @dev Déplace un montant `value` de jetons du compte de l'appelant vers `to`
+   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
+   * @param to L'adresse à laquelle les jetons sont transférés.
+   * @param value Le montant de jetons à transférer.
+   * @param data Données supplémentaires sans format spécifié, envoyées dans l'appel à `to`.
+   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
+   */
+  function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
+
+  /**
+   * @dev Déplace un montant `value` de jetons de `from` vers `to` en utilisant le mécanisme d'autorisation
+   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
+   * @param from L'adresse à partir de laquelle envoyer les jetons.
+   * @param to L'adresse à laquelle les jetons sont transférés.
+   * @param value Le montant de jetons à transférer.
+   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
+   */
+  function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
+
+  /**
+   * @dev Déplace un montant `value` de jetons de `from` vers `to` en utilisant le mécanisme d'autorisation
+   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
+   * @param from L'adresse à partir de laquelle envoyer les jetons.
+   * @param to L'adresse à laquelle les jetons sont transférés.
+   * @param value Le montant de jetons à transférer.
+   * @param data Données supplémentaires sans format spécifié, envoyées dans l'appel à `to`.
+   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
+   */
+  function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
+
+  /**
+   * @dev Définit un montant `value` de jetons comme autorisation de `spender` sur les jetons de l'appelant
+   * et puis appelle `ERC1363Spender::onApprovalReceived` sur `spender`.
+   * @param spender L'adresse qui dépensera les fonds.
+   * @param value Le montant des jetons à dépenser.
+   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
+   */
+  function approveAndCall(address spender, uint256 value) external returns (bool);
+
+  /**
+   * @dev Définit un montant `value` de jetons comme autorisation de `spender` sur les jetons de l'appelant
+   * et puis appelle `ERC1363Spender::onApprovalReceived` sur `spender`.
+   * @param spender L'adresse qui dépensera les fonds.
+   * @param value Le montant des jetons à dépenser.
+   * @param data Données supplémentaires sans format spécifié, envoyées lors de l'appel à `spender`.
+   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
+   */
+  function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
+}
+
+interface ERC20 {
+  event Transfer(address indexed from, address indexed to, uint256 value);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+  function transfer(address to, uint256 value) external returns (bool);
+  function transferFrom(address from, address to, uint256 value) external returns (bool);
+  function approve(address spender, uint256 value) external returns (bool);
+  function totalSupply() external view returns (uint256);
+  function balanceOf(address account) external view returns (uint256);
+  function allowance(address owner, address spender) external view returns (uint256);
+}
+
+interface ERC165 {
+  function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+```
+
+Un contrat intelligent qui veut accepter les jetons ERC-1363 via `transferAndCall` ou `transferFromAndCall` **DOIT** implémenter l'interface `ERC1363Receiver` :
+
+```solidity
+/**
+ * @title ERC1363Receiver
+ * @dev Interface pour tout contrat qui veut prendre en charge `transferAndCall` ou `transferFromAndCall` à partir de contrats de jeton ERC-1363.
+ */
+interface ERC1363Receiver {
+  /**
+   * @dev Chaque fois que des jetons ERC-1363 sont transférés à ce contrat via `ERC1363::transferAndCall` ou `ERC1363::transferFromAndCall`
+   * par `operator` depuis `from`, cette fonction est appelée.
+   *
+   * NOTE : pour accepter le transfert, cette fonction doit retourner
+   * `bytes4(keccak256(\"onTransferReceived(address,address,uint256,bytes)\"))`
+   * (c.-à-d. 0x88a7ca5c, ou son propre sélecteur de fonction).
+   *
+   * @param operator L'adresse qui a appelé la fonction `transferAndCall` ou `transferFromAndCall`.
+   * @param from L'adresse depuis laquelle les jetons sont transférés.
+   * @param value Le montant des jetons transférés.
+   * @param data Données supplémentaires sans format spécifié.
+   * @return `bytes4(keccak256(\"onTransferReceived(address,address,uint256,bytes)\"))` si le transfert est autorisé, sauf en cas d'erreur.
+   */
+  function onTransferReceived(address operator, address from, uint256 value, bytes calldata data) external returns (bytes4);
+}
+```
+
+Un contrat intelligent qui veut accepter les jetons ERC-1363 via `approveAndCall` **DOIT** implémenter l'interface `ERC1363Spender` :
+
+```solidity
+/**
+ * @title ERC1363Spender
+ * @dev Interface pour tout contrat qui veut prendre en charge `approveAndCall` à partir de contrats de jeton ERC-1363.
+ */
+interface ERC1363Spender {
+  /**
+   * @dev Chaque fois qu'un `owner` de jetons ERC-1363 approuve ce contrat via `ERC1363::approveAndCall`
+   * pour dépenser ses jetons, cette fonction est appelée.
+   *
+   * NOTE : pour accepter l'approbation, cette fonction doit retourner
+   * `bytes4(keccak256(\"onApprovalReceived(address,uint256,bytes)\"))`
+   * (c.-à-d. 0x7b04a2d0, ou son propre sélecteur de fonction).
+   *
+   * @param owner L'adresse qui a appelé la fonction `approveAndCall` et qui possédait auparavant les jetons.
+   * @param value Le montant des jetons à dépenser.
+   * @param data Données supplémentaires sans format spécifié.
+   * @return `bytes4(keccak256(\"onApprovalReceived(address,uint256,bytes)\"))` si l'approbation est autorisée, sauf en cas d'erreur.
+   */
+  function onApprovalReceived(address owner, uint256 value, bytes calldata data) external returns (bytes4);
+}
+```
+
+## En savoir plus {#further-reading}
+
+- [ERC-1363 : Norme de jeton payable](https://eips.ethereum.org/EIPS/eip-1363)
+- [ERC-1363 : Dépôt GitHub](https://github.com/vittominacori/erc1363-payable-token)
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-20/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-20/index.md
index 8010a158707..5063efd4897 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/erc-20/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-20/index.md
@@ -1,6 +1,6 @@
 ---
 title: Norme de jeton ERC-20
-description:
+description: Learn about ERC-20, the standard for fungible tokens on Ethereum that enables interoperable token applications.
 lang: fr
 ---
 
@@ -17,7 +17,7 @@ Un jeton peut représenter à peu près n'importe quoi sur Ethereum :
 - Une once d'or
 - Et plus encore...
 
-Un écosystème aussi puissant qu'Ethereum doit être géré selon une norme robuste, non ? C'est exactement là que l'ERC-20 joue son rôle ! Cette norme permet aux développeurs de construire des applications de jetons interopérables avec d'autres produits et services. La norme ERC-20 est également utilisée pour fournir des fonctionnalités supplémentaires à l'[ether](/glossary/#ether).
+Un écosystème aussi puissant qu'Ethereum doit être géré selon une norme robuste, non ? C'est exactement là que l'ERC-20 joue son rôle ! Cette norme permet aux développeurs de créer des applications de jetons interopérables avec d'autres produits et services. La norme ERC-20 est également utilisée pour fournir des fonctionnalités supplémentaires à l'[ether](/glossary/#ether).
 
 **Qu'est-ce que l'ERC-20 ?**
 
@@ -27,11 +27,12 @@ L'ERC-20 introduit une norme standard pour les Jetons Fongibles. En d'autres ter
 
 - [Comptes](/developers/docs/accounts)
 - [Contrats intelligents](/developers/docs/smart-contracts/)
-- [Normes de jetons](/developers/docs/standards/tokens/)
+- [Norme de jetons](/developers/docs/standards/tokens/)
 
-## Présentation {#body}
+## Corps {#body}
 
-La demande de commentaires ERC-20, proposée par Fabian Vogelsteller en novembre 2015, est une norme de jeton qui implémente une API pour les jetons au sein des contrats intelligents.
+La demande de commentaires ERC-20, proposée par Fabian Vogelsteller en novembre 2015, est une norme de jeton qui
+implémente une API pour les jetons au sein des contrats intelligents.
 
 Exemples de fonctionnalités fournies par ERC-20 :
 
@@ -42,7 +43,7 @@ Exemples de fonctionnalités fournies par ERC-20 :
 
 Si un contrat intelligent implémente les méthodes et les événements suivants, il peut être nommé Contrat de jeton ERC-20 et, une fois déployé, sera responsable d'effectuer un suivi des jetons créés sur Ethereum.
 
-De [EIP-20](https://eips.ethereum.org/EIPS/eip-20) :
+Provenant de l'[EIP-20](https://eips.ethereum.org/EIPS/eip-20):
 
 ### Méthodes {#methods}
 
@@ -58,7 +59,7 @@ function approve(address _spender, uint256 _value) public returns (bool success)
 function allowance(address _owner, address _spender) public view returns (uint256 remaining)
 ```
 
-### Évènements {#events}
+### Événements {#events}
 
 ```solidity
 event Transfer(address indexed _from, address indexed _to, uint256 _value)
@@ -67,11 +68,12 @@ event Approval(address indexed _owner, address indexed _spender, uint256 _value)
 
 ### Exemples {#web3py-example}
 
-Voyons pourquoi une norme est importante et pourquoi elle nous facilite le contrôle de tout contrat de jeton ERC-20 sur Ethereum. Nous avons juste besoin de l'interface binaire-programme (ABI) du contrat pour créer une interface à n'importe quel jeton ERC-20. Comme vous pouvez le voir ci-dessous, nous utiliserons une ABI simplifiée, pour en faire un exemple facile à comprendre.
+Voyons pourquoi une norme est importante et pourquoi elle nous facilite le contrôle de tout contrat de jeton ERC-20 sur Ethereum.
+Nous avons juste besoin de l'interface binaire-programme (ABI) du contrat pour créer une interface à n'importe quel jeton ERC-20. Comme vous pouvez le voir ci-dessous, nous utiliserons une ABI simplifiée, pour en faire un exemple facile à comprendre.
 
 #### Exemple Web3.py {#web3py-example}
 
-Pour commencer, assurez-vous d'avoir installé la bibliothèque Python [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation) :
+Tout d'abord, assurez-vous d'avoir installé la bibliothèque Python [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation) :
 
 ```
 pip install web3
@@ -84,12 +86,12 @@ from web3 import Web3
 w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))
 
 dai_token_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"     # DAI
-weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"    # Wrapped ether (WETH)
+weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"    # Ether enveloppé (WETH)
 
-acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11"        # Uniswap V2: DAI 2
+acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11"        # Uniswap V2 : DAI 2
 
-# This is a simplified Contract Application Binary Interface (ABI) of an ERC-20 Token Contract.
-# It will expose only the methods: balanceOf(address), decimals(), symbol() and totalSupply()
+# Ceci est une Interface Binaire d'Application (ABI) de contrat simplifiée d'un contrat de jeton ERC-20.
+# Elle exposera uniquement les méthodes : balanceOf(address), decimals(), symbol() et totalSupply()
 simplified_abi = [
     {
         'inputs': [{'internalType': 'address', 'name': 'account', 'type': 'address'}],
@@ -125,8 +127,8 @@ addr_balance = dai_contract.functions.balanceOf(acc_address).call() / 10**decima
 
 #  DAI
 print("===== %s =====" % symbol)
-print("Total Supply:", totalSupply)
-print("Addr Balance:", addr_balance)
+print("Offre totale :", totalSupply)
+print("Solde de l'adresse :", addr_balance)
 
 weth_contract = w3.eth.contract(address=w3.to_checksum_address(weth_token_addr), abi=simplified_abi)
 symbol = weth_contract.functions.symbol().call()
@@ -136,38 +138,50 @@ addr_balance = weth_contract.functions.balanceOf(acc_address).call() / 10**decim
 
 #  WETH
 print("===== %s =====" % symbol)
-print("Total Supply:", totalSupply)
-print("Addr Balance:", addr_balance)
+print("Offre totale :", totalSupply)
+print("Solde de l'adresse :", addr_balance)
 ```
 
 ## Problèmes connus {#erc20-issues}
 
-### Problème de réception de jeton ERC-20 {#reception-issue}
+### Problème de réception de jetons ERC-20 {#reception-issue}
+
+**Au 20 juin 2024, au moins 83 656 418 dollars de jetons ERC-20 ont été perdus en raison de ce problème. Notez qu'une implémentation pure d'ERC-20 est sujette à ce problème, à moins que vous n'implémentiez un ensemble de restrictions supplémentaires à la norme, comme indiqué ci-dessous.**
 
 Quand des jetons ERC-20 sont envoyés à un contrat intelligent qui n'est pas conçu pour traiter des jetons ERC-20, ces jetons peuvent être définitivement perdus. Cela se produit parce que le contrat destinataire n'a pas la fonctionnalité nécessaire pour reconnaître ou répondre aux jetons entrants, et il n'existe aucun mécanisme dans la norme ERC-20 pour informer le contrat destinataire des jetons entrants. Ce problème se manifeste à travers ces principaux cas :
 
-1.  Mécanisme de transfert de jetons
-  - Les jetons ERC-20 sont transférés en utilisant les fonctions transfer ou transferFrom
-    -   Lorsqu'un utilisateur envoie des jetons à une adresse de contrat en utilisant ces fonctions, les jetons sont transférés indépendamment du fait que le contrat récepteur soit conçu pour les gérer ou non
-2.  Manque de notification
-    -   Le contrat récepteur ne reçoit pas de notification ou de rappel indiquant que des jetons lui ont été envoyés
-    -   Si le contrat récepteur ne dispose pas d'un mécanisme destiné à gérer les jetons (par exemple, une fonction de rappel ou une fonction dédiée à la réception des jetons), les jetons restent effectivement bloqués à l'adresse du contrat
-3.  Aucune gestion intégrée
-    -   La norme ERC-20 n'inclut pas de fonction obligatoire à mettre en œuvre pour les contrats de réception, ce qui conduit à une situation où de nombreux contrats ne sont pas en mesure de gérer correctement l'arrivée de jetons
+1. Mécanisme de transfert de jetons
 
-Ce problème a donné naissance à des normes alternatives, telles que l'[ERC-223](/developers/docs/standards/tokens/erc-223) ou l'[ERC-1363](/developers/docs/standards/tokens/erc-1363).
+- Les jetons ERC-20 sont transférés en utilisant les fonctions transfer ou transferFrom
+  - Lorsqu'un utilisateur envoie des jetons à une adresse de contrat en utilisant ces fonctions, les jetons sont transférés indépendamment du fait que le contrat récepteur soit conçu pour les gérer ou non
 
-## Complément d'information {#further-reading}
+2. Manque de notification
+   - Le contrat récepteur ne reçoit pas de notification ou de rappel indiquant que des jetons lui ont été envoyés
+   - Si le contrat récepteur ne dispose pas d'un mécanisme destiné à gérer les jetons (par exemple, une fonction de rappel ou une fonction dédiée à la réception des jetons), les jetons restent effectivement bloqués à l'adresse du contrat
+3. Aucune gestion intégrée
+   - La norme ERC-20 n'inclut pas de fonction obligatoire à mettre en œuvre pour les contrats de réception, ce qui conduit à une situation où de nombreux contrats ne sont pas en mesure de gérer correctement l'arrivée de jetons
 
-- [EIP-20 : ERC-20 Token Standard](https://eips.ethereum.org/EIPS/eip-20)
-- [OpenZeppelin - Tokens](https://docs.openzeppelin.com/contracts/3.x/tokens#ERC20)
-- [OpenZeppelin - Implémentation ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)
-- [Alchemy - Guide des jetons ERC20 Solidity](https://www.alchemy.com/overviews/erc20-solidity)
+**Solutions envisageables**
+
+Bien qu’il ne soit pas possible d’éliminer complètement ce problème avec l’ERC-20, il existe des méthodes permettant de réduire significativement le risque de perte de jetons pour l’utilisateur final :
+
+- Le problème le plus courant survient lorsqu'un utilisateur envoie des jetons à l'adresse du contrat du jeton lui-même (par exemple, des USDT déposés à l'adresse du contrat du jeton USDT). Il est recommandé de restreindre la fonction `transfer(..)` pour annuler de telles tentatives de transfert. Envisagez d'ajouter la vérification `require(_to != address(this));` dans l'implémentation de la fonction `transfer(..)`.
+- En général, la fonction `transfer(..)` n'est pas conçue pour déposer des jetons dans des contrats. `approve(..) Pour déposer des jetons ERC-20 sur des contrats, on utilise plutôt le modèle `transferFrom(..)`. Il est possible de restreindre la fonction de transfert afin d'empêcher le dépôt de jetons vers des contrats. Toutefois, cela peut rompre la compatibilité avec certains contrats qui supposent que les jetons peuvent être déposés via la fonction `transfer(..)` (par exemple, les pools de liquidité d’Uniswap).
+- Supposons toujours que les jetons ERC-20 peuvent se retrouver dans votre contrat même si votre contrat n'est jamais censé en recevoir. Il n'y a aucun moyen d'empêcher ou de rejeter les dépôts accidentels du côté des destinataires. Il est recommandé de mettre en œuvre une fonction qui permettrait d'extraire des jetons ERC-20 déposés accidentellement.
+- Envisagez d'utiliser d'autres normes de jetons.
 
+Certaines normes alternatives ont vu le jour suite à ce problème, comme [l'ERC-223](/developers/docs/standards/tokens/erc-223) ou [l'ERC-1363](/developers/docs/standards/tokens/erc-1363).
+
+## En savoir plus {#further-reading}
+
+- [EIP-20 : Standard de jeton ERC-20](https://eips.ethereum.org/EIPS/eip-20)
+- [OpenZeppelin - Jetons](https://docs.openzeppelin.com/contracts/3.x/tokens#ERC20)
+- [OpenZeppelin - Implémentation de l'ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)
+- [Alchemy - Guide des jetons ERC20 Solidity](https://www.alchemy.com/overviews/erc20-solidity)
 
 ## Autres normes de jetons fongibles {#fungible-token-standards}
 
 - [ERC-223](/developers/docs/standards/tokens/erc-223)
 - [ERC-1363](/developers/docs/standards/tokens/erc-1363)
 - [ERC-777](/developers/docs/standards/tokens/erc-777)
-- [ERC-4626 - Coffre-fort à jetons](/developers/docs/standards/tokens/erc-4626)
\ No newline at end of file
+- [ERC-4626 - Coffres-forts tokenisés](/developers/docs/standards/tokens/erc-4626)
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-223/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-223/index.md
index a44a4377320..dad34ffa3b2 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/erc-223/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-223/index.md
@@ -1,6 +1,6 @@
 ---
 title: Norme de jeton ERC-223
-description: Un aperçu du standard de jeton fongible ERC-223, de son fonctionnement, et une comparaison avec l'ERC-20.
+description: "Un aperçu du standard de jeton fongible ERC-223, de son fonctionnement, et une comparaison avec l'ERC-20."
 lang: fr
 ---
 
@@ -180,7 +180,7 @@ contract RecipientContract is IERC223Recipient {
 
 Lorsque le 'RecipientContract' recevra un token ERC-223, le contrat exécutera une fonction encodée sous forme de paramètre '_data' de la transaction du jeton, de la même manière que les transactions d'ether encodent les appels de fonction en tant que 'data' de transaction. Consultez [le champ de données](/developers/docs/transactions/#the-data-field) pour plus d'informations.
 
-Dans l'exemple ci-dessus, un jeton ERC-223 doit être transféré à l'adresse du `RecipientContract` avec la fonction `transfer(address,uint256,bytes calldata _data)`. Si le paramètre de données est `0xc2985578` (la signature de la fonction `faut()`), alors la fonction `foo()` sera invoquée après la réception du dépôt de jetons, et l'événement `Foo()` sera déclenché.
+Dans l'exemple ci-dessus, un jeton ERC-223 doit être transféré à l'adresse du `RecipientContract` avec la fonction `transfer(address,uint256,bytes calldata _data)`. Si le paramètre de données est `0xc2985578` (la signature de la fonction `foo()`), alors la fonction `foo()` sera invoquée après la réception du dépôt de jetons, et l'événement `Foo()` sera déclenché.
 
 Les paramètres peuvent également être encodés dans les `data` du transfert de jetons. Par exemple, nous pouvons appeler la fonction `bar()` avec la valeur `12345` pour `_someNumber`. Dans ce cas, les `data` doivent être `0x0423a13200000000000000000000000000000000000000000000000000000000000004d2`, où `0x0423a132` est la signature de la fonction `bar(uint256)` et `00000000000000000000000000000000000000000000000000000000000004d2` correspond à `12345` en tant que `uint256`.
 
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-4626/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-4626/index.md
index 80598bc0c89..2f359f07ce6 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/erc-4626/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-4626/index.md
@@ -1,6 +1,6 @@
 ---
 title: Norme de coffre-fort avec les jetons ERC-4626
-description: Une norme pour les coffres-forts à rendement.
+description: "Une norme pour les coffres-forts à rendement."
 lang: fr
 ---
 
@@ -14,7 +14,7 @@ Les marchés de prêts, les agrégateurs et les jetons intrinsèquement porteurs
 
 Les coffres de rendement ERC-4626 réduiront l'effort d'intégration et ouvriront l'accès au rendement de diverses applications avec peu d'efforts spécialisés de la part des développeurs, en créant des modèles d'implémentation plus cohérents et plus robustes.
 
-Le jeton ERC-4626 est décrit dans les détails dans [EIP-4626](https://eips.ethereum.org/EIPS/eip-4626).
+Le jeton ERC-4626 est entièrement décrit dans [l'EIP-4626](https://eips.ethereum.org/EIPS/eip-4626).
 
 **Extension de coffre-fort asynchrone (ERC-7540)**
 
@@ -22,25 +22,25 @@ L'ERC-4626 est optimisé pour les dépôts et les rachats atomiques jusqu'à une
 
 L'ERC-7540 étend l'utilité des coffre-forts ERC-4626 pour les cas d'utilisation asynchrones. L'interface de coffre-fort existante (`deposit`/`withdraw`/`mint`/`redeem`) est pleinement utilisée pour réclamer les demandes asynchrones.
 
-L'extension ERC-7540 est décrite en détail dans [ERC-7540](https://eips.ethereum.org/EIPS/eip-7540).
+L'extension ERC-7540 est entièrement décrite dans [l'ERC-7540](https://eips.ethereum.org/EIPS/eip-7540).
 
-**Extension du coffre-fort multi-actifs (ERC-75757)**
+**Extension du coffre-fort multi-actifs (ERC-7575)**
 
 Parmi les cas d'utilisation qui ne sont pas pris en charge par l'ERC-4626, on trouve les coffres-forts qui possèdent plusieurs actifs ou points d'entrée, tels que les jetons de fournisseurs de liquidités (LP). Ces derniers sont généralement difficiles à manipuler ou non conformes en raison de l'exigence de l'ERC-4626 d'être lui-même un ERC-20.
 
 L'ERC-7575 ajoute la prise en charge des coffre-forts comportant plusieurs actifs en externalisant l'implémentation du jeton ERC-20 à partir de l'implémentation de l'ERC-4626.
 
-L'extension ERC-7575 est décrite en détail dans [ERC-7575](https://eips.ethereum.org/EIPS/eip-7575).
+L'extension ERC-7575 est entièrement décrite dans [l'ERC-7575](https://eips.ethereum.org/EIPS/eip-7575).
 
-## Pré-requis {#prerequisites}
+## Prérequis {#prerequisites}
 
-Pour mieux comprendre cette page, nous vous recommandons de commencer par lire celles concernant [les normes des jetons](/developers/docs/standards/tokens/) et [ERC-20](/developers/docs/standards/tokens/erc-20/).
+Pour mieux comprendre cette page, nous vous recommandons de commencer par vous informer sur les [normes de jetons](/developers/docs/standards/tokens/) et l'[ERC-20](/developers/docs/standards/tokens/erc-20/).
 
-## Fonctions et fonctionnalités ERC-4626 : {#body}
+## Fonctions et fonctionnalités ERC-4626 : {#body}
 
 ### Méthodes {#methods}
 
-#### asset {#asset}
+#### actif {#asset}
 
 ```solidity
 function asset() public view returns (address assetTokenAddress)
@@ -62,7 +62,7 @@ Cette fonction retourne le montant total des actifs sous-jacents détenus dans l
 function convertToShares(uint256 assets) public view returns (uint256 shares)
 ```
 
-Cette fonction retourne le montant de `shares` qui seraient échangées par le coffre pour le montant d'`assets` fourni.
+Cette fonction renvoie le montant de `parts` qui seraient échangées par le coffre-fort contre le montant d' `actifs` fournis.
 
 #### convertToAssets {#convertoassets}
 
@@ -70,7 +70,7 @@ Cette fonction retourne le montant de `shares` qui seraient échangées par le c
 function convertToAssets(uint256 shares) public view returns (uint256 assets)
 ```
 
-Cette fonction retourne le montant d'`assets` qui seraient échangés par le coffre pour le montant de `shares` fourni.
+Cette fonction renvoie le montant d' `actifs` qui seraient échangés par le coffre-fort contre le montant de `parts` fournies.
 
 #### maxDeposit {#maxdeposit}
 
@@ -78,7 +78,7 @@ Cette fonction retourne le montant d'`assets` qui seraient échangés par le cof
 function maxDeposit(address receiver) public view returns (uint256 maxAssets)
 ```
 
-Cette fonction retourne le montant maximal des actifs sous-jacents qui peuvent être déposés en un seul appel de [`deposit`](#deposit) par le `receiver`.
+Cette fonction renvoie le montant maximal d'actifs sous-jacents qui peuvent être déposés en un seul appel [`deposit`](#deposit), les parts étant frappées pour le `receiver`.
 
 #### previewDeposit {#previewdeposit}
 
@@ -88,13 +88,13 @@ function previewDeposit(uint256 assets) public view returns (uint256 shares)
 
 Cette fonction permet aux utilisateurs de simuler les effets de leur dépôt sur le bloc actuel.
 
-#### dépôt {#deposit}
+#### deposit {#deposit}
 
 ```solidity
 function deposit(uint256 assets, address receiver) public returns (uint256 shares)
 ```
 
-Cette fonction dépose les `assets` de jetons sous-jacents dans le coffre et accorde la propriété de `shares` au `receiver`.
+Cette fonction dépose des `actifs` de jetons sous-jacents dans le coffre-fort et accorde la propriété de `parts` au `destinataire`.
 
 #### maxMint {#maxmint}
 
@@ -102,7 +102,7 @@ Cette fonction dépose les `assets` de jetons sous-jacents dans le coffre et acc
 function maxMint(address receiver) public view returns (uint256 maxShares)
 ```
 
-Cette fonction retourne le nombre maximum d'actions qui peuvent être produites en un seul appel [`mint`](#mint) par le `receiver`.
+Cette fonction renvoie le montant maximal de parts qui peuvent être frappées en un seul appel [`mint`](#mint), les parts étant frappées pour le `receiver`.
 
 #### previewMint {#previewmint}
 
@@ -112,13 +112,13 @@ function previewMint(uint256 shares) public view returns (uint256 assets)
 
 Cette fonction permet aux utilisateurs de simuler les effets de leur frappe sur le bloc actuel.
 
-#### frapper {#mint}
+#### mint {#mint}
 
 ```solidity
 function mint(uint256 shares, address receiver) public returns (uint256 assets)
 ```
 
-Cette fonction produit exactement `shares` actions du coffre au `receiver` en déposant des `assets` de jetons sous-jacents.
+Cette fonction frappe exactement un nombre de `parts` du coffre-fort pour le `destinataire` en déposant des `actifs` de jetons sous-jacents.
 
 #### maxWithdraw {#maxwithdraw}
 
@@ -126,7 +126,7 @@ Cette fonction produit exactement `shares` actions du coffre au `receiver` en d
 function maxWithdraw(address owner) public view returns (uint256 maxAssets)
 ```
 
-Cette fonction retourne le montant maximal des actifs sous-jacents qui peuvent être retirés du solde de l'`owner` en un seul appel à la fonction [`withdraw`](#withdraw).
+Cette fonction renvoie le montant maximal d'actifs sous-jacents qui peuvent être retirés du solde du `propriétaire` avec un seul appel [`withdraw`](#withdraw).
 
 #### previewWithdraw {#previewwithdraw}
 
@@ -136,13 +136,13 @@ function previewWithdraw(uint256 assets) public view returns (uint256 shares)
 
 Cette fonction permet aux utilisateurs de simuler les effets de leur retrait sur le bloc actuel.
 
-#### retrait {#withdraw}
+#### withdraw {#withdraw}
 
 ```solidity
 function withdraw(uint256 assets, address receiver, address owner) public returns (uint256 shares)
 ```
 
-Cette fonction détruit `shares` de l'`owner` et envoie exactement `assets` jeton depuis le coffre au `receiver`.
+Cette fonction brûle les `parts` du `propriétaire` et envoie exactement les `actifs` de jetons du coffre-fort au `destinataire`.
 
 #### maxRedeem {#maxredeem}
 
@@ -150,7 +150,7 @@ Cette fonction détruit `shares` de l'`owner` et envoie exactement `assets` jeto
 function maxRedeem(address owner) public view returns (uint256 maxShares)
 ```
 
-Cette fonction retourne le montant maximum d'actions qui peuvent être rachetées du solde de l'`orner` par un appel à la fonction [`redeem`](#redeem).
+Cette fonction renvoie le montant maximal de parts qui peuvent être rachetées sur le solde du `propriétaire` par le biais d'un appel [`redeem`](#redeem).
 
 #### previewRedeem {#previewredeem}
 
@@ -166,7 +166,7 @@ Cette fonction permet aux utilisateurs de simuler les effets de leur rachat sur
 function redeem(uint256 shares, address receiver, address owner) public returns (uint256 assets)
 ```
 
-Cette fonction rachète un nombre spécifique de `shares` de l'`owner` et envoie des `assets` de jeton sous-jacent du coffre au `receiver`.
+Cette fonction rachète un nombre spécifique de `parts` auprès du `propriétaire` et envoie des `actifs` du jeton sous-jacent du coffre-fort au `destinataire`.
 
 #### totalSupply {#totalsupply}
 
@@ -182,46 +182,35 @@ Renvoie le nombre total d'actions non rachetées en circulation.
 function balanceOf(address owner) public view returns (uint256)
 ```
 
-Renvoie le nombre total d'actions détenues par l'`owner`.
+Renvoie le montant total de parts de coffre-fort que le `propriétaire` détient actuellement.
 
-### Plan de l'interface {#mapOfTheInterface}
+### Carte de l'interface {#mapOfTheInterface}
 
-![Plan de l'interface ERC-4626](./map-of-erc-4626.png)
+![Carte de l'interface ERC-4626](./map-of-erc-4626.png)
 
-### Évènements {#events}
+### Événements {#events}
 
 #### Événement de dépôt
 
 **DOIT** être émis lorsque des jetons sont déposés dans le coffre-fort via les méthodes [`mint`](#mint) et [`deposit`](#deposit).
 
 ```solidity
-event Deposit(
-    address indexed sender,
-    address indexed owner,
-    uint256 assets,
-    uint256 shares
-)
+event Deposit(\n    address indexed sender,\n    address indexed owner,\n    uint256 assets,\n    uint256 shares\n)
 ```
 
-Où `sender` est l'utilisateur qui a échangé `assets` contre `shares`, et a transféré ces `shares` à l'`owner`.
+Où `sender` est l'utilisateur qui a échangé des `assets` contre des `shares`, et a transféré ces `shares` à `owner`.
 
 #### Évènement de retrait
 
-**DOIT** être déclenché lorsque les actions sont retirées du coffre par un déposant via les méthodes [`redeem`](#redeem) ou [`withdraw`](#withdraw).
+**DOIT** être émis lorsque des parts sont retirées du coffre-fort par un déposant dans les méthodes [`redeem`](#redeem) ou [`withdraw`](#withdraw).
 
 ```solidity
-event Withdraw(
-    address indexed sender,
-    address indexed receiver,
-    address indexed owner,
-    uint256 assets,
-    uint256 shares
-)
+event Withdraw(\n    address indexed sender,\n    address indexed receiver,\n    address indexed owner,\n    uint256 assets,\n    uint256 shares\n)
 ```
 
-Où `sender` est l'utilisateur qui a déclenché le retrait et échangé `shares`, détenues par `owner`, contre `assets`. `receiver` est l'utilisateur qui a reçu les `assets` retirés.
+Où `sender` est l'utilisateur qui a déclenché le retrait et échangé des `shares`, détenues par le `propriétaire`, contre des `assets`. `receiver` est l'utilisateur qui a reçu les `assets` retirés.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [EIP-4626 : Standard de coffre-fort tokenisé](https://eips.ethereum.org/EIPS/eip-4626)
-- [ERC-4626 : Répertoire GitHub](https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC4626.sol)
+- [EIP-4626 : Norme de coffre-fort tokenisé](https://eips.ethereum.org/EIPS/eip-4626)
+- [ERC-4626 : Dépôt GitHub](https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC4626.sol)
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-721/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-721/index.md
index 1300e12a3b5..38f466af09c 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/erc-721/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-721/index.md
@@ -1,6 +1,6 @@
 ---
 title: Norme de jeton non fongible ERC-721
-description:
+description: "En savoir plus sur ERC-721, la norme pour les jetons non fongibles (NFT) qui représentent des actifs numériques uniques sur Ethereum."
 lang: fr
 ---
 
@@ -8,29 +8,34 @@ lang: fr
 
 **Qu'est-ce qu'un jeton non fongible (NFT) ?**
 
-Un NFT est utilisé pour identifier quelque chose ou quelqu'un d'une façon unique. Ce type de jeton est parfait pour une utilisation sur les plateformes proposant des objets de collection, clés d'accès, billets de loterie, sièges numérotés pour concerts et matchs sportifs, etc. Ce type spécial de jeton ayant des possibilités incroyables, il mérite donc une norme adéquate, comme l'ERC-721.
+Un NFT est utilisé pour identifier quelque chose ou quelqu'un d'une façon unique. Ce type de jeton est parfait pour une utilisation sur les plateformes proposant des objets de collection, clés d'accès, billets de loterie, sièges numérotés pour concerts et
+matchs sportifs, etc. Ce type spécial de jeton ayant des possibilités incroyables, il mérite donc une norme adéquate, comme l'ERC-721.
 
 **Qu'est-ce que l'ERC-721 ?**
 
-L'ERC-721 introduit une norme pour les NFT. En d'autres termes, ce type de jeton est unique et peut avoir une valeur différente de celle d'un autre jeton du même contrat intelligent, peut-être en raison de son âge, de sa rareté ou du visuel qui lui est associé. Visuel ? Vous avez dit visuel ?
+L'ERC-721 introduit une norme pour les NFT. En d'autres termes, ce type de jeton est unique et peut avoir une valeur différente de celle d'un autre jeton du même contrat intelligent, peut-être en raison de son âge, de sa rareté ou du visuel qui lui est associé.
+Visuel ? Vous avez dit visuel ?
 
-Oui ! Tous les NFT ont une variable `uint256` appelée `tokenId` ainsi, pour tout contrat ERC-721, la paire `contract address, uint256 tokenId` doit être globalement unique. Cela dit, une dApp peut avoir un « convertisseur » qui utilisent le `tokenld` comme entrée et affiche une image de quelque chose de cool, comme des zombies, des armes, des compétences ou des incroyables chatons !
+Oui ! Tous les NFT ont une variable `uint256` appelée `tokenId`, donc pour tout contrat ERC-721, la paire
+`contract address, uint256 tokenId` doit être globalement unique. Ceci dit, une dapp peut avoir un « convertisseur » qui
+utilise le `tokenId` en entrée et produit en sortie une image de quelque chose de cool, comme des zombies, des armes, des compétences ou d'incroyables chatons !
 
 ## Prérequis {#prerequisites}
 
 - [Comptes](/developers/docs/accounts/)
 - [Contrats intelligents](/developers/docs/smart-contracts/)
-- [Normes de jetons](/developers/docs/standards/tokens/)
+- [Norme de jetons](/developers/docs/standards/tokens/)
 
-## Présentation {#body}
+## Corps {#body}
 
 L'ERC-721 (pour "Ethereum Request for Comments 721") proposé par William Entriken, Dieter Shirley, Jacob Evans, Nastassia Sachs en janvier 2018, est une norme de jeton non fongible qui implémente une API pour les jetons des contrats intelligents.
 
-Elle fournit des fonctionnalités permettant de transférer des jetons d'un compte à un autre, ou d'obtenir le solde actuel d'un compte en jetons, le nom du propriétaire d'un jeton spécifique et le nombre total de jetons disponibles sur le réseau. En plus de celles-ci, il en existe d'autres pour, par exemple, approuver que des jetons provenant d'un compte soient déplacés par un compte tiers.
+Elle fournit des fonctionnalités permettant de transférer des jetons d'un compte à un autre, ou d'obtenir le solde actuel d'un compte en jetons, le nom du propriétaire d'un jeton spécifique et le nombre total de jetons disponibles sur le réseau.
+En plus de celles-ci, il en existe d'autres pour, par exemple, approuver que des jetons provenant d'un compte soient déplacés par un compte tiers.
 
 Si un contrat intelligent implémente les méthodes et les événements suivants, il peut être nommé Contrat de jeton non fongible ERC-721 et, une fois déployé, sera responsable d'effectuer un suivi des jetons créés sur Ethereum.
 
-De [EIP-721](https://eips.ethereum.org/EIPS/eip-721) :
+Provenant de l'[EIP-721](https://eips.ethereum.org/EIPS/eip-721):
 
 ### Méthodes {#methods}
 
@@ -46,7 +51,7 @@ De [EIP-721](https://eips.ethereum.org/EIPS/eip-721) :
     function isApprovedForAll(address _owner, address _operator) external view returns (bool);
 ```
 
-### Évènements {#events}
+### Événements {#events}
 
 ```solidity
     event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
@@ -56,11 +61,12 @@ De [EIP-721](https://eips.ethereum.org/EIPS/eip-721) :
 
 ### Exemples {#web3py-example}
 
-Voyons comment une norme peut être si importante pour nous faciliter le contrôle de tout contrat de jeton ERC-721 sur Ethereum. Nous avons juste besoin de l'interface binaire-programme (ABI) du contrat pour créer une interface à n'importe quel jeton ERC-721. Comme vous pouvez le voir ci-dessous, nous utiliserons une ABI simplifiée, pour en faire un exemple de faible friction.
+Voyons comment une norme peut être si importante pour nous faciliter le contrôle de tout contrat de jeton ERC-721 sur Ethereum.
+Nous avons juste besoin de l'interface binaire-programme (ABI) du contrat pour créer une interface à n'importe quel jeton ERC-721. Comme vous pouvez le voir ci-dessous, nous utiliserons une ABI simplifiée, pour en faire un exemple facile à comprendre.
 
 #### Exemple Web3.py {#web3py-example}
 
-Pour commencer, assurez-vous d'avoir installé la bibliothèque Python [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation):
+Tout d'abord, assurez-vous d'avoir installé la bibliothèque Python [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation) :
 
 ```
 pip install web3
@@ -73,12 +79,12 @@ from web3._utils.events import get_event_data
 
 w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))
 
-ck_token_addr = "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d"    # CryptoKitties Contract
+ck_token_addr = "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d"    # Contrat CryptoKitties
 
-acc_address = "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C"      # CryptoKitties Sales Auction
+acc_address = "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C"      # Enchères de ventes de CryptoKitties
 
-# This is a simplified Contract Application Binary Interface (ABI) of an ERC-721 NFT Contract.
-# It will expose only the methods: balanceOf(address), name(), ownerOf(tokenId), symbol(), totalSupply()
+# Ceci est une Interface Binaire d'Application (ABI) de Contrat simplifiée d'un contrat NFT ERC-721.
+# Elle n'exposera que les méthodes : balanceOf(address), name(), ownerOf(tokenId), symbol(), totalSupply()
 simplified_abi = [
     {
         'inputs': [{'internalType': 'address', 'name': 'owner', 'type': 'address'}],
@@ -131,12 +137,12 @@ ck_contract = w3.eth.contract(address=w3.to_checksum_address(ck_token_addr), abi
 name = ck_contract.functions.name().call()
 symbol = ck_contract.functions.symbol().call()
 kitties_auctions = ck_contract.functions.balanceOf(acc_address).call()
-print(f"{name} [{symbol}] NFTs in Auctions: {kitties_auctions}")
+print(f"{name} [{symbol}] NFT aux enchères : {kitties_auctions}")
 
 pregnant_kitties = ck_contract.functions.pregnantKitties().call()
-print(f"{name} [{symbol}] NFTs Pregnants: {pregnant_kitties}")
+print(f"{name} [{symbol}] NFT en gestation : {pregnant_kitties}")
 
-# Using the Transfer Event ABI to get info about transferred Kitties.
+# Utilisation de l'ABI de l'événement Transfer pour obtenir des informations sur les chatons transférés.
 tx_event_abi = {
     'anonymous': False,
     'inputs': [
@@ -147,7 +153,7 @@ tx_event_abi = {
     'type': 'event'
 }
 
-# We need the event's signature to filter the logs
+# Nous avons besoin de la signature de l'événement pour filtrer les journaux
 event_signature = w3.keccak(text="Transfer(address,address,uint256)").hex()
 
 logs = w3.eth.get_logs({
@@ -156,25 +162,25 @@ logs = w3.eth.get_logs({
     "topics": [event_signature]
 })
 
-# Notes:
-#   - Increase the number of blocks up from 120 if no Transfer event is returned.
-#   - If you didn't find any Transfer event you can also try to get a tokenId at:
+# Remarques :
+#   - Augmentez le nombre de blocs au-dessus de 120 si aucun événement Transfer n'est renvoyé.
+#   - Si vous n'avez trouvé aucun événement Transfer, vous pouvez également essayer d'obtenir un tokenId sur :
 #       https://etherscan.io/address/0x06012c8cf97BEaD5deAe237070F9587f8E7A266d#events
-#       Click to expand the event's logs and copy its "tokenId" argument
+#       Cliquez pour développer les journaux de l'événement et copiez son argument « tokenId »
 recent_tx = [get_event_data(w3.codec, tx_event_abi, log)["args"] for log in logs]
 
 if recent_tx:
-    kitty_id = recent_tx[0]['tokenId'] # Paste the "tokenId" here from the link above
+    kitty_id = recent_tx[0]['tokenId'] # Collez ici le « tokenId » du lien ci-dessus
     is_pregnant = ck_contract.functions.isPregnant(kitty_id).call()
-    print(f"{name} [{symbol}] NFTs {kitty_id} is pregnant: {is_pregnant}")
+    print(f"{name} [{symbol}] Le NFT {kitty_id} est en gestation : {is_pregnant}")
 ```
 
 Le contrat CryptoKitties comporte des événements intéressants en dehors des événements standards.
 
-Vérifions deux d'entre eux, `Pregnant` et `Birth`.
+Vérifions-en deux, `Pregnant` et `Birth`.
 
 ```python
-# Using the Pregnant and Birth Events ABI to get info about new Kitties.
+# Utilisation des ABI des événements Pregnant et Birth pour obtenir des informations sur les nouveaux chatons.
 ck_extra_events_abi = [
     {
         'anonymous': False,
@@ -198,13 +204,13 @@ ck_extra_events_abi = [
         'type': 'event'
     }]
 
-# We need the event's signature to filter the logs
+# Nous avons besoin de la signature de l'événement pour filtrer les journaux
 ck_event_signatures = [
     w3.keccak(text="Pregnant(address,uint256,uint256,uint256)").hex(),
     w3.keccak(text="Birth(address,uint256,uint256,uint256,uint256)").hex(),
 ]
 
-# Here is a Pregnant Event:
+# Voici un événement Pregnant :
 # - https://etherscan.io/tx/0xc97eb514a41004acc447ac9d0d6a27ea6da305ac8b877dff37e49db42e1f8cef#eventlog
 pregnant_logs = w3.eth.get_logs({
     "fromBlock": w3.eth.block_number - 120,
@@ -214,7 +220,7 @@ pregnant_logs = w3.eth.get_logs({
 
 recent_pregnants = [get_event_data(w3.codec, ck_extra_events_abi[0], log)["args"] for log in pregnant_logs]
 
-# Here is a Birth Event:
+# Voici un événement Birth :
 # - https://etherscan.io/tx/0x3978028e08a25bb4c44f7877eb3573b9644309c044bf087e335397f16356340a
 birth_logs = w3.eth.get_logs({
     "fromBlock": w3.eth.block_number - 120,
@@ -227,18 +233,24 @@ recent_births = [get_event_data(w3.codec, ck_extra_events_abi[1], log)["args"] f
 
 ## NFT populaires {#popular-nfts}
 
-- [Etherscan NFT Tracker](https://etherscan.io/tokens-nft) répertorie les NFT les plus importants sur Ethereum en termes de volume de transferts.
-- [CryptoKitties](https://www.cryptokitties.co/) est un jeu axé sur des créatures de collection adorables dont on peut faire l'élevage et que nous appelons CryptoKitties.
-- [Sorare](https://sorare.com/) est un jeu de football mondial où vous pouvez collectionner des objets en édition limitée, gérer vos équipes et concourir pour gagner des prix.
-- [Ethereum Name Service (ENS)](https://ens.domains/) offre un moyen sécurisé et décentralisé d'adresser des ressources à la fois sur et hors de la blockchain en utilisant des noms simples et lisibles.
-- [POAP](https://poap.xyz) fournit des NFT gratuits aux personnes qui assistent à des événements ou accomplissent des actions spécifiques. Les POAP sont libres de création et de distribution.
-- [Unstoppable Domains](https://unstoppabledomains.com/) est une société basée à San Francisco, qui construit des domaines sur des blockchains. Les domaines de blockchains remplacent les adresses des cryptomonnaies par des noms lisibles et peuvent être utilisés pour activer des sites Web résistants à la censure.
-- [Gods Unchained Cards](https://godsunchained.com/) est un jeu de cartes à collectionner (JCC) de la blockchain Ethereum, qui utilise des NFT pour apporter une vraie propriété aux actifs en jeu.
-- [Bored Ape Yacht Club](https://boredapeyachtclub.com) est une collection de 10 000 NFT uniques qui, en plus d'être une œuvre d'art remarquablement rare, agit en tant que jeton d’adhésion au club en fournissant aux membres des atouts et des avantages qui augmentent au fil du temps grâce aux efforts de la communauté.
-
-## Complément d'information {#further-reading}
-
-- [EIP-721: ERC-721 Non-Fungible Token Standard](https://eips.ethereum.org/EIPS/eip-721)
-- [OpenZeppelin - ERC-721 Docs](https://docs.openzeppelin.com/contracts/3.x/erc721)
+- [Etherscan NFT Tracker](https://etherscan.io/nft-top-contracts) répertorie les principaux NFT sur Ethereum par volume de transferts.
+- [CryptoKitties](https://www.cryptokitties.co/) est un jeu centré sur des créatures à élever, à collectionner et ô combien adorables
+  que nous appelons CryptoKitties.
+- [Sorare](https://sorare.com/) est un jeu de fantasy football mondial dans lequel vous pouvez collectionner des objets de collection en édition limitée,
+  gérer vos équipes et participer à des compétitions pour gagner des prix.
+- [Ethereum Name Service (ENS)](https://ens.domains/) offre un moyen sécurisé et décentralisé d'adresser des ressources à la fois
+  sur la blockchain et en dehors en utilisant des noms simples et lisibles par l'homme.
+- [POAP](https://poap.xyz) distribue des NFT gratuits aux personnes qui participent à des événements ou effectuent des actions spécifiques. Les POAP sont libres de création et de distribution.
+- [Unstoppable Domains](https://unstoppabledomains.com/) est une société basée à San Francisco qui crée des domaines sur
+  les blockchains. Les domaines blockchain remplacent les adresses de cryptomonnaie par des noms lisibles par l'homme et peuvent être utilisés pour permettre
+  des sites Web résistants à la censure.
+- [Gods Unchained Cards](https://godsunchained.com/) est un jeu de cartes à collectionner (TCG) sur la blockchain Ethereum qui utilise des NFT pour apporter la pleine propriété
+  des actifs en jeu.
+- [Bored Ape Yacht Club](https://boredapeyachtclub.com) est une collection de 10 000 NFT uniques qui, en plus d'être une œuvre d'art à la rareté prouvable, sert de jeton d'adhésion au club, offrant aux membres des avantages qui augmentent avec le temps grâce aux efforts de la communauté.
+
+## En savoir plus {#further-reading}
+
+- [EIP-721 : Norme de jeton non fongible ERC-721](https://eips.ethereum.org/EIPS/eip-721)
+- [OpenZeppelin - Documentation ERC-721](https://docs.openzeppelin.com/contracts/3.x/erc721)
 - [OpenZeppelin - Implémentation ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol)
-- [API NFT d'Alchemy](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api)
+- [API NFT d'Alchemy](https://www.alchemy.com/docs/reference/nft-api-quickstart)
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/erc-777/index.md b/public/content/translations/fr/developers/docs/standards/tokens/erc-777/index.md
index 2582c95635e..c6cb9247cea 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/erc-777/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/erc-777/index.md
@@ -1,6 +1,6 @@
 ---
 title: Norme de jeton ERC-777
-description:
+description: "Découvrez ERC-777, une norme de jeton fongible améliorée avec des crochets, bien qu'ERC-20 soit recommandé pour des raisons de sécurité."
 lang: fr
 ---
 
@@ -42,4 +42,4 @@ Les contrats ERC-777 peuvent interagir comme s'il s'agissait de contrats ERC-20.
 
 ## En savoir plus {#further-reading}
 
-[EIP-777 : Jeton standard] (https://eips.ethereum.org/EIPS/eip-777)
+[EIP-777 : Jeton standard](https://eips.ethereum.org/EIPS/eip-777)
diff --git a/public/content/translations/fr/developers/docs/standards/tokens/index.md b/public/content/translations/fr/developers/docs/standards/tokens/index.md
index e20901a4082..6d907c310ae 100644
--- a/public/content/translations/fr/developers/docs/standards/tokens/index.md
+++ b/public/content/translations/fr/developers/docs/standards/tokens/index.md
@@ -1,39 +1,41 @@
 ---
 title: Normes de jetons
-description:
+description: Explorez les normes de jetons Ethereum, y compris ERC-20, ERC-721 et ERC-1155 pour les jetons fongibles et non fongibles.
 lang: fr
 incomplete: true
 ---
 
 ## Introduction {#introduction}
 
-De nombreuses normes de développement Ethereum se concentrent sur les interfaces de jetons. Ces normes aident à garantir que les contrats intelligents restent composables, afin que, par exemple, lorsqu'un nouveau projet émet un jeton, celui-ci reste compatible avec les échanges décentralisés existants.
+De nombreuses normes de développement Ethereum se concentrent sur les interfaces de jetons. Ces normes contribuent à garantir que les contrats intelligents restent composables, de sorte que lorsqu'un nouveau projet émet un jeton, celui-ci reste compatible avec les échanges décentralisés et les applications existants.
+
+Les normes de jetons définissent la manière dont les jetons se comportent et interagissent dans l'écosystème Ethereum. Elles permettent aux développeurs de créer plus facilement sans réinventer la roue, en garantissant que les jetons fonctionnent de manière transparente avec les portefeuilles, les échanges et les plateformes DeFi. Que ce soit dans les jeux, la gouvernance ou d'autres cas d'utilisation, ces normes assurent la cohérence et rendent Ethereum plus interconnecté.
 
 ## Prérequis {#prerequisites}
 
-- [Normes de développement Ethereum](/developers/docs/standards/)
+- [Normes de développement d'Ethereum](/developers/docs/standards/)
 - [Contrats intelligents](/developers/docs/smart-contracts/)
 
-## Normes des jetons {#token-standards}
+## Normes de jetons {#token-standards}
 
 Voici quelques-unes des normes de jetons les plus populaires sur Ethereum :
 
-- [ERC-20](/developers/docs/standards/tokens/erc-20/) - Une interface type pour les jetons fongibles (interchangeables) comme les jetons de vote, les jetons d'enjeu ou les monnaies virtuelles.
+- [ERC-20](/developers/docs/standards/tokens/erc-20/) - Une interface standard pour les jetons fongibles (interchangeables), comme les jetons de vote, les jetons de staking ou les monnaies virtuelles.
 
 ### Normes NFT {#nft-standards}
 
-- [ERC-721](/developers/docs/standards/tokens/erc-721/) - Une interface type pour les jetons non fongibles, comme ceux requis pour les œuvres d'art ou une chanson.
-- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - Permet des transactions et des regroupements de transactions plus efficaces – réduisant ainsi les coûts. Cette norme de jeton permet de créer à la fois des jetons utilitaires (comme $BNB ou $BAT) et des jetons non fongibles comme les CryptoPunks.
+- [ERC-721](/developers/docs/standards/tokens/erc-721/) - Une interface standard pour les jetons non fongibles (NFT), comme un titre de propriété pour une œuvre d'art ou une chanson.
+- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - L'ERC-1155 permet des échanges plus efficaces et le regroupement des transactions, réduisant ainsi les coûts. Cette norme de jeton permet de créer à la fois des jetons utilitaires (comme $BNB ou $BAT) et des jetons non fongibles comme les CryptoPunks.
 
 La liste complète des propositions [ERC](https://eips.ethereum.org/erc).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
 ## Tutoriels connexes {#related-tutorials}
 
-- [Liste de contrôle d'intégration de jetons](/developers/tutorials/token-integration-checklist/) _- Liste de contrôle des choses à prendre en compte quand on interagit avec des jetons._
-- [Comprendre le contrat intelligent de jeton ERC-20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _- Introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum._
-- [Transférer et approuver des jetons ERC20 depuis un contrat intelligent Solidity](/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/) _– Comment utiliser un contrat intelligent pour interagir avec un jeton en utilisant le langage Solidity._
-- [Implémenter un marché ERC721 [guide pratique]](/developers/tutorials/how-to-implement-an-erc721-market/) _- Comment mettre à la vente des objets jetonnés sur une planche de classification décentralisée._
+- [Liste de contrôle d'intégration de jetons](/developers/tutorials/token-integration-checklist/) _– Une liste de contrôle des éléments à prendre en compte lors de l'interaction avec des jetons._
+- [Comprendre le contrat intelligent de jeton ERC-20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _– Une introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum._
+- [Transferts et approbation de jetons ERC-20 à partir d'un contrat intelligent Solidity](/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/) _– Comment utiliser un contrat intelligent pour interagir avec un jeton à l'aide du langage Solidity._
+- [Mettre en œuvre un marché ERC-721 [guide pratique]](/developers/tutorials/how-to-implement-an-erc721-market/) _– Comment mettre en vente des articles jetonisés sur un tableau d'annonces décentralisé._
diff --git a/public/content/translations/fr/developers/docs/storage/index.md b/public/content/translations/fr/developers/docs/storage/index.md
index c3833772c72..a2372d0e932 100644
--- a/public/content/translations/fr/developers/docs/storage/index.md
+++ b/public/content/translations/fr/developers/docs/storage/index.md
@@ -1,31 +1,31 @@
 ---
-title: Stockage décentralisé
-description: Présentation du stockage décentralisé et des outils disponibles à intégrer dans une dApp.
+title: "Stockage décentralisé"
+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 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).
+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. De plus, 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).
 
 En raison de ces contraintes, nous avons besoin d'une chaîne ou d'une méthodologie différente pour stocker de grandes quantités de données de manière décentralisée.
 
 En se penchant sur la question des options de stockage décentralisé (dStorage), il y a des choses qu'un utilisateur doit garder à l'esprit.
 
-- Mécanisme de persistance / structure d'incitation
+- Mécanisme de persistance / structure incitative
 - Application de conservation des données
-- Décentralisé
+- Décentralisation
 - Consensus
 
-## Mécanisme de persistance / structure incitative {#persistence-mechanism}
+## Mécanisme de persistance / Structure d'incitation {#persistence-mechanism}
 
-### Orientation blockchain {#blockchain-based}
+### Basé sur la blockchain {#blockchain-based}
 
 Pour qu'une donnée persiste indéfiniment, nous devons utiliser un mécanisme de persistance. Par exemple sur Ethereum, le mécanisme de persistance réside dans le fait que toute la chaîne doit être prise en compte lors de l'exécution d'un nœud. De nouvelles données sont traitées en bout de chaîne et elle ne cesse donc de croître, exigeant que chaque nœud reproduise toutes les données embarquées.
 
-Ce processus est connu sous le nom de : persistance **basée sur la blockchain**.
+C'est ce qu'on appelle la 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).
+Le problème avec la persistance basée sur la blockchain est que la chaîne pourrait devenir beaucoup trop volumineuse pour maintenir et stocker toutes les données de manière réalisable (par exemple, [de nombreuses sources](https://healthit.com.au/how-big-is-the-internet-and-how-do-we-measure-it/) estiment qu'Internet nécessite plus de 40 zettaoctets 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 validateur. Les validateurs sont payés pour ajouter les données lorsqu'elles sont ajoutées à la chaine.
 
@@ -34,23 +34,23 @@ Plateformes avec persistance basée sur la blockchain :
 - Ethereum
 - [Arweave](https://www.arweave.org/)
 
-### Orientation contrat {#contract-based}
+### Basé sur les contrats {#contract-based}
 
-**La persistance orientée contrat** a l'intuition que les données ne peuvent pas être reproduites par chaque nœud et stockées pour toujours et au lieu de cela, il doit alors être gardé à jour avec des accords contractuels. Ce sont des accords conclus avec plusieurs nœuds qui promettent de conserver une partie de données pendant une certaine période. Ils doivent être remboursés ou renouvelés chaque fois qu'ils sont exécutés pour conserver les données.
+La persistance **basée sur les contrats** repose sur l'intuition que les données ne peuvent pas être répliquées par chaque nœud et stockées éternellement, et qu'elles doivent plutôt être maintenues par des accords contractuels. Ce sont des accords conclus avec plusieurs nœuds qui promettent de conserver une partie de données pendant une certaine période. Ils doivent être remboursés ou renouvelés chaque fois qu'ils sont exécutés pour conserver les données.
 
 Dans la plupart des cas, au lieu de stocker toutes les données en chaîne, le hachage de l'endroit où les données se trouvent sur une chaîne est stocké. Ainsi, l'ensemble de la chaîne n'a pas besoin d'évoluer pour conserver toutes les données.
 
 Les plateformes avec persistance basée sur contrat :
 
-- [Filecoin](https://docs.filecoin.io/about-filecoin/what-is-filecoin/)
-- [Skynet](https://siasky.net/)
+- [Filecoin](https://docs.filecoin.io/basics/what-is-filecoin)
+- [Skynet](https://sia.tech/)
 - [Storj](https://storj.io/)
 - [Züs](https://zus.network/)
-- [Réseau Crust](https://crust.network)
+- [Crust Network](https://crust.network)
 - [Swarm](https://www.ethswarm.org/)
 - [4EVERLAND](https://www.4everland.org/)
 
-### Autres considérations {#additional-consideration}
+### Considérations supplémentaires {#additional-consideration}
 
 IPFS est un système distribué pour stocker et accéder aux fichiers, sites Web, applications et données. Il ne dispose pas d'un système d'incitation intégré, mais peut être utilisé avec n'importe quelle solution d'incitation orientée contrat ci-dessus pour une persistance à plus long terme. Une autre façon de maintenir les données sur IPFS est de travailler avec un service d'alerte, qui va « épingler » vos données pour vous. Vous pouvez même exécuter votre propre nœud IPFS et contribuer au réseau pour persister gratuitement vos données et/ou celles d'autres !
 
@@ -58,18 +58,18 @@ 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) _
+- [IPFS Scan](https://ipfs-scan.io) _(explorateur d'épinglage IPFS)_
+- [4EVERLAND](https://www.4everland.org/) _(service d'épinglage IPFS)_
 - [Filebase](https://filebase.com) _(Service d'épinglage IPFS)_
 - [Spheron Network](https://spheron.network/) _(service d'épinglage IPFS/Filecoin)_
 
 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}
+## Rétention des données {#data-retention}
 
 Afin de conserver des données, les systèmes doivent disposer d'une sorte de mécanisme pour s'assurer que les données sont bien conservées.
 
-### Mécanisme de défi {#challenge-mechanism}
+### Mécanisme de contestation {#challenge-mechanism}
 
 Un des moyens les plus populaires pour s'assurer que les données sont conservées, est d'utiliser un certain type de défi cryptographique à relever par les nœuds afin de s'assurer qu'ils disposent toujours des données. Un simple moyen est de regarder la preuve d'accès d'Arweav. Ils lancent un défi aux nœuds pour voir s'ils disposent des données du bloc le plus récent et d'un bloc aléatoire dans le passé. Si le nœud ne peut pas trouver la réponse, il est pénalisé.
 
@@ -98,7 +98,7 @@ Outils décentralisés sans KYC :
 
 ### 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/) soit sur une [**Preuve d'enjeu (PoS)**](/developers/docs/consensus-mechanisms/pos/).
+La plupart de ces outils ont leur propre version d'un [mécanisme de consensus](/developers/docs/consensus-mechanisms/), mais ils sont généralement basés soit sur la [**preuve de travail (PoW)**](/developers/docs/consensus-mechanisms/pow/), soit sur la [**preuve d'enjeu (PoS)**](/developers/docs/consensus-mechanisms/pos/).
 
 Preuve de travail (PoW) :
 
@@ -114,103 +114,103 @@ Preuve d'enjeu (PoS) :
 
 ## Outils connexes {#related-tools}
 
-**IPFS - _Le système de fichier InterPlanetary est un système de stockage décentralisé et de référencement de fichiers pour Ethereum_**
+**IPFS – _InterPlanetary File System est un système de stockage et de référencement de fichiers décentralisé pour Ethereum._**
 
 - [Ipfs.io](https://ipfs.io/)
 - [Documentation](https://docs.ipfs.io/)
 - [GitHub](https://github.com/ipfs/ipfs)
 
-**Storj DCS - _Stockage décentralisé d'objet cloud sécurisé, privé et compatible S3 pour les développeurs._**
+**Storj DCS – _Stockage d'objets cloud décentralisé, sécurisé, privé et compatible S3 pour les développeurs._**
 
 - [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é._**
+**Sia - _Utilise la cryptographie pour créer un marché de stockage cloud sans nécessité de confiance, permettant aux acheteurs et vendeurs d'échanger directement._**
 
-- [Skynet.net](https://siasky.net/)
-- [Documentation](https://siasky.net/docs/)
-- [GitHub](https://github.com/SkynetLabs/)
+- [Skynet.net](https://sia.tech/)
+- [Documentation](https://docs.sia.tech/)
+- [GitHub](https://github.com/SiaFoundation/)
 
-**Filecoin - _Filecoin a été créé par la même équipe derrière IPFS. C'est une couche d'incitation au sommet des idéaux IPFS._**
+**Filecoin - _Filecoin a été créé par la même équipe à l'origine d'IPFS._** C'est une couche d'incitation au sommet des idéaux IPFS._\*\*
 
 - [Filecoin.io](https://filecoin.io/)
 - [Documentation](https://docs.filecoin.io/)
 - [GitHub](https://github.com/filecoin-project/)
 
-**Arweave - _Arweave est une plateforme dStorage pour stocker des données._**
+**Arweave - _Arweave est une plateforme dStorage pour le stockage de données._**
 
 - [Arweave.org](https://www.arweave.org/)
 - [Documentation](https://docs.arweave.org/info/)
 - [Arweave](https://github.com/ArweaveTeam/arweave/)
 
-**Züs - _Züs est une plateforme dStorage basée sur la Preuve d'enjeu avec des fragments et des blobbers._**
+**Züs – _Züs est une plateforme dStorage à preuve d'enjeu avec fragmentation et « blobbers »._**
 
 - [zus.network](https://zus.network/)
-- [Documentation](https://0chaindocs.gitbook.io/zus-docs)
+- [Documentation](https://docs.zus.network/zus-docs/)
 - [GitHub](https://github.com/0chain/)
 
-**Réseau Crust - _Crust est une plateforme dStorage basée sur IPFS_**
+**Crust Network – _Crust est une plateforme dStorage qui s'appuie 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_**
+**Swarm – _Une plateforme de stockage distribuée et un service de distribution de contenu pour la pile web3 d'Ethereum._**
 
 - [EthSwarm.org](https://www.ethswarm.org/)
-- [Documentation](https://docs.ethswarm.org/docs/)
+- [Documentation](https://docs.ethswarm.org/)
 - [GitHub](https://github.com/ethersphere/)
 
-**OrbitDB - _Base de données décentralisée P2P construite sur IPFS_**
+**OrbitDB – _Une base de données décentralisée pair-à-pair (P2P) qui s'appuie sur IPFS._**
 
 - [OrbitDB.org](https://orbitdb.org/)
 - [Documentation](https://github.com/orbitdb/field-manual/)
 - [GitHub](https://github.com/orbitdb/orbit-db/)
 
-**Aleph.im - _Projet cloud décentralisé (base de données, stockage de fichiers, calcul et DID). Un mélange unique de technologie hors chaîne et en chaîne P2P. Compatibilité avec IPFS et multi-chaînes._**
+**Aleph.im - _Projet de cloud décentralisé (base de données, stockage de fichiers, calcul et DID)._** Un mélange unique de technologie hors chaîne et en chaîne P2P. Compatibilité avec IPFS et multi-chaînes._\*\*
 
-- [Aleph.im](https://aleph.im/)
-- [Documentation](https://aleph.im/#/developers/)
+- [Aleph.im](https://aleph.cloud/)
+- [Documentation](https://docs.aleph.cloud/)
 - [GitHub](https://github.com/aleph-im/)
 
-**Ceramic - _Stockage de base de données IPFS contrôlé par l'utilisateur pour des applications riches en données et engageantes._**
+**Ceramic – _Stockage de base de données IPFS contrôlé par l'utilisateur pour des applications riches en données et attrayantes._**
 
 - [Ceramic.network](https://ceramic.network/)
-- [Documentation](https://developers.ceramic.network/learn/welcome/)
+- [Documentation](https://developers.ceramic.network/)
 - [GitHub](https://github.com/ceramicnetwork/js-ceramic/)
 
-**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 - _Stockage décentralisé compatible S3 et service d'épinglage IPFS géo-redondant._** Tous les fichiers téléversés sur IPFS via Filebase sont automatiquement épinglés à l'infrastructure Filebase avec une triple réplication à 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 - _Une plateforme de cloud computing Web 3.0 qui intègre des fonctionnalités de base de stockage, de calcul et de réseau, est compatible S3 et fournit un stockage de données synchrone sur des réseaux de stockage décentralisés tels qu'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 - _Une plateforme « blockchain-as-a-service » avec des nœuds IPFS sur simple clic_**
 
 - [Kaleido](https://kaleido.io/)
 - [Documentation](https://docs.kaleido.io/kaleido-services/ipfs/)
 - [GitHub](https://github.com/kaleido-io)
 
-**Spheron Network - _Spheron est une plateforme-en-tant-que-service (PaaS) conçue pour les dApps cherchant à lancer leurs applications sur un infra décentralisé avec les meilleures performances. Elle fournit des capacités de calcul, de stockage décentralisé, CDN & de l'hébergement web prêt à l'emploi._**
+**Spheron Network - _Spheron est une plateforme en tant que service (PaaS) conçue pour les dApps qui cherchent à lancer leurs applications sur une infrastructure décentralisée avec des performances optimales._** Elle fournit des capacités de calcul, un stockage décentralisé, un CDN et un hébergement web prêts à l'emploi._\*\*
 
 - [spheron.network](https://spheron.network/)
 - [Documentation](https://docs.spheron.network/)
 - [GitHub](https://github.com/spheronFdn)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#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_
-- [Cinq mythes répandus à propos du stockage décentralisé](https://www.storj.io/blog/busting-five-common-myths-about-decentralized-storage) - _Storj_
+- [Qu'est-ce que le stockage décentralisé ?](https://coinmarketcap.com/academy/article/what-is-decentralized-storage-a-deep-dive-by-filecoin) - _CoinMarketCap_
+- [Cinq mythes courants sur le stockage décentralisé démystifiés](https://www.storj.io/blog/busting-five-common-myths-about-decentralized-storage) - _Storj_
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
 ## Sujets connexes {#related-topics}
 
-- [Infrastructures de développement](/developers/docs/frameworks/)
+- [Frameworks de développement](/developers/docs/frameworks/)
diff --git a/public/content/translations/fr/developers/docs/transactions/index.md b/public/content/translations/fr/developers/docs/transactions/index.md
index 9fbfe0ec72e..b2dda281c81 100644
--- a/public/content/translations/fr/developers/docs/transactions/index.md
+++ b/public/content/translations/fr/developers/docs/transactions/index.md
@@ -1,20 +1,21 @@
 ---
 title: Transactions
-description: 'Présentation des transactions Ethereum : leur fonctionnement, leur structure de données et comment les envoyer via une application.'
+description: "Présentation des transactions Ethereum : leur fonctionnement, leur structure de données et comment les envoyer via une application."
 lang: fr
 ---
 
-Les transactions sont des instructions signées cryptographiquement depuis des comptes. Un compte va initier une transaction pour mettre à jour l'état du réseau Ethereum. La transaction la plus simple consiste à transférer de l'ETH d'un compte à un autre.
+Les transactions sont des instructions signées cryptographiquement provenant des comptes. Un compte va initier une transaction pour mettre à jour l'état du réseau Ethereum. La transaction la plus simple consiste à transférer de l'ETH d'un compte à un autre.
 
 ## Prérequis {#prerequisites}
 
-Pour vous aider à mieux comprendre cet article, nous vous recommandons de commencer par lire les pages [Comptes](/developers/docs/accounts/) et notre [Introduction à Ethereum](/developers/docs/intro-to-ethereum/).
+Pour vous aider à mieux comprendre cette page, nous vous recommandons de lire d'abord [Comptes](/developers/docs/accounts/) et notre [introduction à Ethereum](/developers/docs/intro-to-ethereum/).
 
 ## Qu'est-ce qu'une transaction ? {#whats-a-transaction}
 
 Une transaction Ethereum est une action initiée par un compte externe, c'est-à-dire un compte géré par un être humain et non par un contrat. Par exemple, si Marc envoie 1 ETH à Alice, le compte de Marc doit être débité et celui d'Alice doit être crédité. Cette action, qui modifie l'état, se produit dans le cadre d'une transaction.
 
-![Diagramme montrant un changement d'état de cause de la transaction](./tx.png) _Schéma adapté à partir du document [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Diagramme montrant une transaction qui entraîne un changement d'état](./tx.png)
+_Diagramme adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 Les transactions, qui modifient l'état de l'EVM, doivent être diffusées sur l'ensemble du réseau. N'importe quel nœud peut diffuser une demande pour qu'une transaction soit exécutée sur l'EVM. Un validateur exécutera ensuite la transaction et diffusera au reste du réseau le changement d'état qui en résultera.
 
@@ -22,17 +23,17 @@ Les transactions requièrent des frais et doivent être incluses dans un bloc va
 
 Une transaction soumise comprend les informations suivantes :
 
-- `depuis` - l'adresse de l'expéditeur qui signera la transaction. Il s'agira d'un compte externe, car les comptes contractuels ne vous permettront pas d'envoyer des transactions
-- `to` : l'adresse de réception (S'il s'agit d'un compte externe, la transaction va transférer la valeur. S'il s'agit d'un compte de contrat, la transaction exécutera le code du contrat.)
-- `signature` : identifiant de l'expéditeur. Cette signature est générée lorsque la clé privée de l'expéditeur signe la transaction, et confirme que l'expéditeur a autorisé cette transaction.
-- `nonce` -, il s'agit d'une machine à travers laquelle un nombre maximum d'essais consécutifs est réalisé, il qualifie aussi le numéro de transactions dans la liste des transactions sortantes depuis votre adresse
-- `valeur` - montants de l'Ether (ETH) à transférer de l'expéditeur au destinataire (libellé en WEI parallèlement à la valeur de l'Ether, qui atteint les 1e+18wei)
-- `input data` – champ facultatif permettant d'inclure des données arbitraires
-- `gasLimit` : Quantité maximum d’unités de gaz pouvant être consommée par la transaction. La [machine virtuelle d'Ethereum (EVM)](/developers/docs/evm/opcodes) donne une estimation de la quantité de gaz (unité virtuelle) nécessaire à une opération, ce qui permet de représenter les coûts informatiques d'une opération sur le réseau
-- `maxPriorityFeePerGas` : la quantité maximale de gaz à inclure comme pourboire pour le validateur
-- `maxFeePerGas` : montant maximum de gaz prêt à être payé pour la transaction (y compris `baseFeePerGas` et `maxPriorityFeePerGas`)
+- `from` – l'adresse de l'expéditeur, qui signera la transaction. Il s'agira d'un compte externe, car les comptes contractuels ne vous permettront pas d'envoyer des transactions
+- `to` – l'adresse de réception (s'il s'agit d'un compte externe, la transaction transférera de la valeur). S'il s'agit d'un compte de contrat, la transaction exécutera le code du contrat.)
+- `signature` – l'identifiant de l'expéditeur. Cette signature est générée lorsque la clé privée de l'expéditeur signe la transaction, et confirme que l'expéditeur a autorisé cette transaction.
+- `nonce` - un compteur à incrémentation séquentielle qui indique le numéro de la transaction du compte
+- `value` – montant d'ETH à transférer de l'expéditeur au destinataire (exprimé en WEI, où 1 ETH équivaut à 1e+18 wei)
+- `input data` – champ facultatif pour inclure des données arbitraires
+- `gasLimit` – la quantité maximale d'unités de gaz qui peut être consommée par la transaction. L'[EVM](/developers/docs/evm/opcodes) spécifie les unités de gaz requises par chaque étape de calcul
+- `maxPriorityFeePerGas` - le prix maximum du gaz consommé à inclure comme pourboire pour le validateur
+- `maxFeePerGas` - les frais maximum par unité de gaz que l'on est prêt à payer pour la transaction (incluant `baseFeePerGas` et `maxPriorityFeePerGas`)
 
-Le gaz est une référence au calcul nécessaire au traitement de la transaction par un validateur. Les utilisateurs doivent payer des frais pour ce calcul. `gasLimit` et `gasPrice` déterminent les frais de transaction maximum payés au validateur. [Plus d'infos sur le gaz](/developers/docs/gas/)
+Le gaz est une référence au calcul nécessaire au traitement de la transaction par un validateur. Les utilisateurs doivent payer des frais pour ce calcul. Les paramètres `gasLimit` et `maxPriorityFeePerGas` déterminent les frais de transaction maximums payés au validateur. [En savoir plus sur le gaz](/developers/docs/gas/).
 
 L'objet de transaction ressemblera un peu à ceci :
 
@@ -41,10 +42,10 @@ L'objet de transaction ressemblera un peu à ceci :
   from: "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8",
   to: "0xac03bb73b6a9e108530aff4df5077c2b3d481e5a",
   gasLimit: "21000",
-  maxFeePerGas: "300"
-  maxPriorityFeePerGas: "10"
+  maxFeePerGas: "300",
+  maxPriorityFeePerGas: "10",
   nonce: "0",
-  value: "10000000000",
+  value: "10000000000"
 }
 ```
 
@@ -52,7 +53,7 @@ Un objet de transaction doit être signé avec la clé privée de l'expéditeur.
 
 Un client Ethereum comme Geth gérera ce processus de signature.
 
-Exemple d'appel [JSON-RPC](/developers/docs/apis/json-rpc) :
+Exemple d'appel [JSON-RPC](/developers/docs/apis/json-rpc) :
 
 ```json
 {
@@ -99,22 +100,26 @@ Exemple de réponse :
 }
 ```
 
-- `raw` est la transaction signée sous forme de [préfixe de longueur récursive (RLP)](/developers/docs/data-structures-and-encoding/rlp)
-- `tx` est la transaction signée sous la forme JSON
+- le `raw` est la transaction signée sous forme codée en [Préfixe de longueur récursive (RLP)](/developers/docs/data-structures-and-encoding/rlp)
+- le `tx` est la transaction signée sous forme JSON
 
 Grâce au hachage de la signature, il est possible de prouver de façon cryptographique que la transaction provient de l'expéditeur et qu'elle a été soumise au réseau.
 
 ### Le champ de données {#the-data-field}
 
-La grande majorité des transactions accèdent à un contrat provenant d'un compte externe. La plupart des contrats sont écrits en Solidity et interprètent leur champ de données conformément à l'[interface binaire-programme (ABI)](/glossary/#abi).
+La grande majorité des transactions accèdent à un contrat provenant d'un compte externe.
+La plupart des contrats sont écrits en Solidity et interprètent leur champ de données conformément à l'[interface binaire d'application (ABI)](/glossary/#abi).
 
-Les quatre premiers octets indiquent la fonction à appeler, en utilisant les hachages de son nom et de ses arguments. Vous pouvez parfois identifier la fonction depuis le sélecteur à l'aide de [cette base de données](https://www.4byte.directory/signatures/).
+Les quatre premiers octets indiquent la fonction à appeler, en utilisant les hachages de son nom et de ses arguments.
+Vous pouvez parfois identifier la fonction à partir du sélecteur en utilisant [cette base de données](https://www.4byte.directory/signatures/).
 
-Le reste des calldata est constitué des arguments, [encodés comme indiqué dans les spécifications ABI](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding).
+Le reste des données d'appel (calldata) correspond aux arguments, [codés comme spécifié dans les spécifications de l'ABI](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding).
 
-Par exemple, prenons [cette transaction](https://etherscan.io/tx/0xd0dcbe007569fcfa1902dae0ab8b4e078efe42e231786312289b1eee5590f6a1). Utilisez **Cliquer pour en voir plus** pour voir les calldata.
+Par exemple, regardons [cette transaction](https://etherscan.io/tx/0xd0dcbe007569fcfa1902dae0ab8b4e078efe42e231786312289b1eee5590f6a1).
+Utilisez **Cliquer pour en voir plus** pour voir les données d'appel (calldata).
 
-Le sélecteur de fonction est `0xa9059cbb`. Il existe plusieurs [fonctions connues avec cette signature](https://www.4byte.directory/signatures/?bytes4_signature=0xa9059cbb). Dans ce cas, [le code source du contrat](https://etherscan.io/address/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#code) a été chargé sur Etherscan, nous savons donc que la fonction est `transfer(address,uint256)`.
+Le sélecteur de fonction est `0xa9059cbb`. Il existe plusieurs [fonctions connues avec cette signature](https://www.4byte.directory/signatures/?bytes4_signature=0xa9059cbb).
+Dans ce cas [le code source du contrat](https://etherscan.io/address/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#code) a été téléversé sur Etherscan, nous savons donc que la fonction est `transfer(address,uint256)`.
 
 Le reste des données est :
 
@@ -123,9 +128,11 @@ Le reste des données est :
 000000000000000000000000000000000000000000000000000000003b0559f4
 ```
 
-Selon les spécifications ABI, les valeurs entières (comme les adresses, qui sont des entiers de 20 octets) apparaissent dans l'ABI sous forme de mots de 32 octets, complétées de zéros au début. Nous savons donc que l'adresse `to` est [`4f6742badb049791cd9a37ea913f2bac38d01279`](https://etherscan.io/address/0x4f6742badb049791cd9a37ea913f2bac38d01279). La valeur `value` est 0x3b0559f4 = 990206452.
+Selon les spécifications ABI, les valeurs entières (comme les adresses, qui sont des entiers de 20 octets) apparaissent dans l'ABI sous forme de mots de 32 octets, complétées de zéros au début.
+Nous savons donc que l'adresse `to` est [`4f6742badb049791cd9a37ea913f2bac38d01279`](https://etherscan.io/address/0x4f6742badb049791cd9a37ea913f2bac38d01279).
+La `value` est 0x3b0559f4 = 990206452.
 
-## Type de transaction {#types-of-transactions}
+## Types de transactions {#types-of-transactions}
 
 Sur Ethereum, il existe plusieurs types de transactions :
 
@@ -135,9 +142,9 @@ Sur Ethereum, il existe plusieurs types de transactions :
 
 ### À propos du gaz {#on-gas}
 
-Comme mentionné, les transactions ont un coût en [gaz](/developers/docs/gas/) pour être exécutées. Les transactions simples de transfert requièrent 21 000 unités de gaz.
+Comme mentionné, les transactions coûtent du [gaz](/developers/docs/gas/) pour être exécutées. Les transactions simples de transfert requièrent 21 000 unités de gaz.
 
-Ainsi, pour envoyer 1 ETH à Alice avec un `baseFeePerGas` de 190 gwei et `maxPriorityFeePerGas` de 10 gwei, Bob devra payer les frais suivants :
+Donc, pour que Bob envoie 1 ETH à Alice avec un `baseFeePerGas` de 190 gwei et un `maxPriorityFeePerGas` de 10 gwei, Bob devra payer les frais suivants :
 
 ```
 (190 + 10) * 21000 = 4 200 000 gwei
@@ -145,77 +152,83 @@ Ainsi, pour envoyer 1 ETH à Alice avec un `baseFeePerGas` de 190 gwei et `maxPr
 0,0042 ETH
 ```
 
-Le compte de Bob sera débité de **-1,0042 ETH** (1 ETH pour Alice + 0,0042 ETH en frais de gaz)
+Le compte de Bob sera débité de **-1,0042 ETH** (1 ETH pour Alice + 0,0042 ETH de frais de gaz)
 
-Celui d'Alice sera crédité de **+1,0 ETH**.
+Le compte d'Alice sera crédité de **+1,0 ETH**
 
-Les frais de base seront brûlés **-0.00399 ETH**
+Les frais de base seront brûlés **-0,00399 ETH**
 
-Le validateur conserve le pourboire de **+0,000210 ETH**
+Le validateur conserve le pourboire **+0,000210 ETH**
 
-
-![Diagramme montrant comment le gaz non utilisé est remboursé](./gas-tx.png) _Schéma adapté à partir du document [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+![Diagramme montrant comment le gaz non utilisé est remboursé](./gas-tx.png)
+_Diagramme adapté de [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
 
 Tout gaz non utilisé dans une transaction est remboursé sur le compte de l'utilisateur.
 
-### Interactions avec des contracts intelligents {#smart-contract-interactions}
+### Interactions avec les contrats intelligents {#smart-contract-interactions}
 
 Du gaz est nécessaire pour toute transaction qui implique un contrat intelligent.
 
-Les contrats intelligents peuvent également contenir des fonctions connues sous le nom de fonctions [`view`](https://docs.soliditylang.org/en/latest/contracts.html#view-functions) ou [`pure`](https://docs.soliditylang.org/en/latest/contracts.html#pure-functions), qui n'altèrent pas l'état du contrat. Ainsi, appeler ces fonctions à partir d'un EOA ne nécessitera aucun gaz. L'appel RPC sous-jacent pour ce scénario est [`eth_call`](/developers/docs/apis/json-rpc#eth_call).
+Les contrats intelligents peuvent également contenir des fonctions connues sous le nom de fonctions `view` (https://docs.soliditylang.org/en/latest/contracts.html#view-functions) ou `pure` (https://docs.soliditylang.org/en/latest/contracts.html#pure-functions), qui ne modifient pas l'état du contrat. Ainsi, appeler ces fonctions à partir d'un EOA ne nécessitera aucun gaz. L'appel RPC sous-jacent pour ce scénario est [`eth_call`](/developers/docs/apis/json-rpc#eth_call).
 
-Contrairement à l'utilisation de `eth_call`, ces fonctions `view` ou `pure` sont également fréquemment appelées en interne (c'est-à-dire à partir du contrat lui-même ou d'un autre contrat), ce qui entraîne un coût en gaz.
+Contrairement à l'accès via `eth_call`, ces fonctions `view` ou `pure` sont également couramment appelées en interne (c'est-à-dire depuis le contrat lui-même ou depuis un autre contrat), ce qui coûte du gaz.
 
 ## Cycle de vie des transactions {#transaction-lifecycle}
 
 Voici ce qui se passe une fois qu'une transaction a été soumise :
 
-1. Le hash de la transaction vient d'être généré grâce aux fonctions de hachage (suite d'opérations mathématiques et cryptographiques) : `0x97d99bc7729211111a21b12c933c949d4f31684f1d6954ff477d0477538ff017`
+1. Un hachage de transaction est généré par cryptographie :
+   `0x97d99bc7729211111a21b12c933c949d4f31684f1d6954ff477d0477538ff017`
 2. La transaction est ensuite diffusée sur le réseau et ajoutée à un pool de transactions composé de toutes les autres transactions réseau en attente.
 3. Un validateur doit sélectionner votre transaction et l'inclure dans un bloc pour la vérifier et la considérer comme « réussie ».
-4. Au fur et à mesure que le temps passe, le bloc contenant votre transaction sera mis à niveau vers « justifié » puis « finalisé ». Grâce à ces mises à niveau, vous êtes davantage assuré que votre transaction a été réussie et qu'elle ne sera jamais altérée. Une fois qu'un bloc est "finalisé", il ne peut plus être modifié par une attaque au niveau du réseau qui coûterait plusieurs milliards de dollars.
+4. Au fur et à mesure que le temps passe, le bloc contenant votre transaction sera mis à niveau vers « justifié » puis «
+   finalisé ». Ces mises à niveau garantissent davantage
+   que votre transaction a été réussie et ne sera jamais modifiée. Une fois qu'un bloc est « finalisé », il ne peut être modifié que
+   par une attaque au niveau du réseau qui coûterait plusieurs milliards de dollars.
 
-## Démonstration visuelle {#a-visual-demo}
+## Une démo visuelle {#a-visual-demo}
 
 Regardez Austin vous guider à travers les transactions, le gaz et le minage.
 
 <YouTube id="er-0ihqFQB0" />
 
-## Enveloppe de transaction saisie {#typed-transaction-envelope}
+## Enveloppe de transaction typée {#typed-transaction-envelope}
 
-Ethereum avait à l'origine un unique format pour les transactions. Chaque transaction contenait une nonce, le prix du gaz, la limite de gaz, l'adresse de destination, la valeur, les données, v, r et s. Il s'agit de champs d'application [d'un RLP](/developers/docs/data-structures-and-encoding/rlp/), qui pourraient ressembler à ceci :
+Ethereum avait à l'origine un unique format pour les transactions. Chaque transaction contenait une nonce, le prix du gaz, la limite de gaz, l'adresse de destination, la valeur, les données, v, r et s. Ces champs sont [codés en RLP](/developers/docs/data-structures-and-encoding/rlp/), pour ressembler à quelque chose comme ceci :
 
 `RLP([nonce, gasPrice, gasLimit, to, value, data, v, r, s])`
 
-Ethereum a évolué pour prendre en charge plusieurs types de transactions afin de permettre l'implémentation de nouvelles fonctionnalités telles que les listes d'accès [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) sans affecter les formats de transactions existants.
+Ethereum a évolué pour prendre en charge plusieurs types de transactions afin de permettre l'implémentation de nouvelles fonctionnalités telles que les listes d'accès et l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) sans affecter les anciens formats de transaction.
 
-[EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) spécifie la façon dont cela est géré. Les transactions sont interprétées comme :
+C'est l'[EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) qui permet ce comportement. Les transactions sont interprétées comme :
 
 `TransactionType || TransactionPayload`
 
 Où les champs sont définis comme :
 
-- `TransactionType` : un nombre compris entre 0 et 0x7f, pour un total de 128 types de transactions possibles.
-- `TransactionPayload` : une table arbitraire d'octets définie par le type de transaction.
+- `TransactionType` - un nombre entre 0 et 0x7f, pour un total de 128 types de transactions possibles.
+- `TransactionPayload` - un tableau d'octets arbitraire défini par le type de transaction.
 
-En fonction de la valeur `TransactionType`, une transaction peut être classée comme :
+En fonction de la valeur de `TransactionType`, une transaction peut être classée comme suit :
 
-1. **Transactions de type 0 (Legacy) :** Le format de transaction original utilisé depuis le lancement d'Ethereum. Ils n'incluent pas les fonctionnalités de l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), telles que les calculs dynamiques des frais de gaz ou les listes d'accès pour les contrats intelligents. Les transactions originelles n'ont pas de préfixe spécifique indiquant leur type dans leur forme sérialisée, et commencent par l'octet `0xf8` lorsqu'elles utilisent le codage [Recursive Length Prefix (RLP)](/developers/docs/data-structures-and-encoding/rlp). La valeur TransactionType pour ces transactions est `0x0`.
+1. **Transactions de type 0 (héritées) :** le format de transaction original utilisé depuis le lancement d'Ethereum. Elles n'incluent pas de fonctionnalités de l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) telles que les calculs dynamiques des frais de gaz ou les listes d'accès pour les contrats intelligents. Les transactions héritées n'ont pas de préfixe spécifique indiquant leur type sous leur forme sérialisée. Elles commencent par l'octet `0xf8` lors de l'utilisation du codage par [préfixe de longueur récursive (RLP)](/developers/docs/data-structures-and-encoding/rlp). La valeur de TransactionType pour ces transactions est `0x0`.
 
-2. **Transactions de type 1 :** Introduites dans [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) dans le cadre de la [mise à jour Berlin](/ethereum-forks/#berlin) d'Ethereum, ces transactions incluent un paramètre `accessList`. Cette liste spécifie les adresses et les clés de stockage auxquelles la transaction s'attend à accéder, contribuant ainsi potentiellement à réduire les coûts de [gaz](/developers/docs/gas/) pour les transactions complexes impliquant des contrats intelligents. Les variations du marché des frais EIP-1559 ne sont pas incluses dans les transactions de type 1. Les transactions de type 1 incluent également un paramètre `yParity`, qui peut être soit `0x0`, soit `0x1`, indiquant la parité de la valeur y de la signature secp256k1. Elles sont identifiées en commençant par l'octet `0x01`, et leur valeur TransactionType est `0x1`.
+2. **Transactions de type 1 :** Introduites dans l'[EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) dans le cadre de la [mise à niveau Berlin](/ethereum-forks/#berlin) d'Ethereum, ces transactions incluent un paramètre `accessList`. Cette liste spécifie les adresses et les clés de stockage auxquelles la transaction s'attend à accéder, ce qui peut potentiellement aider à réduire les coûts de [gaz](/developers/docs/gas/) pour les transactions complexes impliquant des contrats intelligents. Les variations du marché des frais EIP-1559 ne sont pas incluses dans les transactions de type 1. Les transactions de type 1 incluent également un paramètre `yParity`, qui peut être `0x0` ou `0x1`, indiquant la parité de la valeur y de la signature secp256k1. Elles sont identifiées en commençant par l'octet `0x01`, et leur valeur de TransactionType est `0x1`.
 
-3. **Transactions de type 2**, communément appelées transactions EIP-1559, sont des transactions introduites dans [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), lors de la [mise à jour London](/ethereum-forks/#london) d'Ethereum. Elles sont devenues le type de transaction standard sur le réseau Ethereum. Ces transactions introduisent un nouveau mécanisme de marché des frais qui améliore la prévisibilité en séparant les frais de transaction en frais de base et en frais prioritaires. Elles commencent par l'octet `0x02` et incluent des champs tels que `maxPriorityFeePerGas` et `maxFeePerGas`. Les transactions de Type 2 sont désormais la norme en raison de leur flexibilité et de leur efficacité. Elles sont particulièrement appréciées pendant les périodes de forte congestion du réseau car elles permettent aux utilisateurs de gérer les frais de transaction de manière plus prévisible. La valeur TransactionType pour ces transactions est `0x02`.
+3. Les **transactions de type 2**, communément appelées transactions EIP-1559, sont des transactions introduites dans l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), lors de la [mise à niveau London](/ethereum-forks/#london) d'Ethereum. Elles sont devenues le type de transaction standard sur le réseau Ethereum. Ces transactions introduisent un nouveau mécanisme de marché des frais qui améliore la prévisibilité en séparant les frais de transaction en frais de base et en frais prioritaires. Elles commencent par l'octet `0x02` et incluent des champs tels que `maxPriorityFeePerGas` et `maxFeePerGas`. Les transactions de Type 2 sont désormais la norme en raison de leur flexibilité et de leur efficacité. Elles sont particulièrement appréciées pendant les périodes de forte congestion du réseau car elles permettent aux utilisateurs de gérer les frais de transaction de manière plus prévisible. La valeur de TransactionType pour ces transactions est `0x2`.
 
+4. Les **transactions de type 3 (Blob)** ont été introduites dans l'[EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) dans le cadre de la [mise à niveau Dencun](/ethereum-forks/#dencun) d'Ethereum. Ces transactions sont conçues pour gérer les données de type « blob » (Binary Large Objects) de manière plus efficace, ce qui profite particulièrement aux rollups de couche 2 en offrant un moyen de publier des données sur le réseau Ethereum à moindre coût. Les transactions Blob incluent des champs supplémentaires tels que `blobVersionedHashes`, `maxFeePerBlobGas`, et `blobGasPrice`. Elles commencent par l'octet `0x03`, et leur valeur de TransactionType est `0x3`. Les transactions « blob » constituent une amélioration significative de la disponibilité des données et des capacités d'évolutivité d’Ethereum.
 
+5. **Les transactions de type 4** ont été introduites dans l'[EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) dans le cadre de la [mise à niveau Pectra](/roadmap/pectra/) d'Ethereum. Ces transactions sont conçues pour être compatibles avec l'abstraction de compte. Elles permettent aux EOA de se comporter temporairement comme des comptes de contrat intelligent sans compromettre leur fonctionnalité d'origine. Elles incluent un paramètre `authorization_list`, qui spécifie le contrat intelligent auquel l'EOA délègue son autorité. Après la transaction, le champ de code de l'EOA aura l'adresse du contrat intelligent délégué.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [EIP-2718 : Enveloppe de Transaction Saisie](https://eips.ethereum.org/EIPS/eip-2718)
+- [EIP-2718 : Enveloppe de transaction typée](https://eips.ethereum.org/EIPS/eip-2718)
 
 _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_
 
 ## Sujets connexes {#related-topics}
 
 - [Comptes](/developers/docs/accounts/)
-- [Machine Virtuelle d'Ethereum (EVM)](/developers/docs/evm/)
+- [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/)
 - [Gaz](/developers/docs/gas/)
diff --git a/public/content/translations/fr/developers/docs/web2-vs-web3/index.md b/public/content/translations/fr/developers/docs/web2-vs-web3/index.md
index a584528ae96..b495276a151 100644
--- a/public/content/translations/fr/developers/docs/web2-vs-web3/index.md
+++ b/public/content/translations/fr/developers/docs/web2-vs-web3/index.md
@@ -1,10 +1,10 @@
 ---
-title: Web2 et Web3
-description:
+title: Web2 vs Web3
+description: "Comparez les services Web2 centralisés avec les applications Web3 décentralisées basées sur la technologie blockchain Ethereum."
 lang: fr
 ---
 
-Web2 fait référence à la version d'Internet que la plupart d'entre nous connaissent aujourd'hui. Un Internet dominé par les sociétés qui fournissent des services en échange de vos données personnelles. Dans le contexte d'Ethereum, Web3 fait référence aux applications décentralisées qui s'exécutent sur la blockchain. Ce sont des applications qui permettent à quiconque de participer sans monétiser ses données personnelles.
+Web2 fait référence à la version d'Internet que la plupart d'entre nous connaissent aujourd'hui. Un Internet dominé par les sociétés qui fournissent des services en échange de vos données personnelles. Dans le contexte Ethereum, le Web3 fait référence aux applications décentralisées qui s'exécutent sur la blockchain. Ce sont des applications qui permettent à quiconque de participer sans monétiser ses données personnelles.
 
 Vous recherchez une ressource plus conviviale pour les débutants ? Consultez notre [introduction au Web3](/web3/).
 
@@ -19,15 +19,15 @@ De nombreux développeurs Web3 ont choisi de construire des dApps en raison de l
 
 ## Comparaisons pratiques {#practical-comparisons}
 
-| Web2                                                                                                                              | Web3                                                                                                                              |
-| --------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| Twitter peut censurer n'importe quel compte ou tweet.                                                                             | Les tweets Web3 ne pourraient pas être censurés, car le contrôle est décentralisé.                                                |
-| Un service de paiement peut décider de ne pas autoriser les paiements pour certains types de travaux.                             | Les applications de paiement Web3 ne requièrent aucune donnée personnelle et ne peuvent pas empêcher les paiements.               |
+| Web2                                                                                                                                                                 | Web3                                                                                                                                                              |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Twitter peut censurer n'importe quel compte ou tweet.                                                                                                | Les tweets Web3 ne pourraient pas être censurés, car le contrôle est décentralisé.                                                                |
+| Un service de paiement peut décider de ne pas autoriser les paiements pour certains types de travaux.                                                | Les applications de paiement Web3 ne requièrent aucune donnée personnelle et ne peuvent pas empêcher les paiements.                               |
 | Les serveurs des applications de travail à la tâche (ou gig-économie) pourraient fermer et affecter les revenus des travailleurs. | Les serveurs Web3 ne peuvent pas fermer. Ils utilisent Ethereum, un réseau décentralisé de milliers d'ordinateurs, comme backend. |
 
 Cela ne signifie pas pour autant que tous les services doivent être transformés en dApps. Ces exemples illustrent simplement les principales différences entre les services Web2 et Web3.
 
-## Limitation du Web3 {#web3-limitations}
+## Limites du Web3 {#web3-limitations}
 
 Le Web3 affiche actuellement quelques limitations :
 
@@ -36,27 +36,27 @@ Le Web3 affiche actuellement quelques limitations :
 - Accessibilité – le manque d’intégration dans les navigateurs Web modernes rend le web3 moins accessible à la plupart des utilisateurs.
 - Coût : La plupart des dApps réussies publient de très petites portions de leur code sur la blockchain car c'est coûteux.
 
-## Centralisation et décentralisation {#centralization-vs-decentralization}
+## Centralisation ou décentralisation {#centralization-vs-decentralization}
 
 Dans le tableau ci-dessous, nous répertorions certains des avantages et inconvénients des réseaux numériques centralisés et décentralisés.
 
-| Systèmes centralisés                                                                                                                                                                                                                                                             | Systèmes décentralisés                                                                                                                                                                                                                                                                   |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Faible diamètre de réseau (tous les participants sont connectés à une autorité centrale). L'information se propage rapidement, car la propagation est gérée par une autorité centrale avec de nombreuses ressources informatiques.                                               | Les participants les plus éloignés du réseau peuvent potentiellement être très éloignés les uns des autres. Les informations diffusées d'un côté du réseau peuvent prendre beaucoup de temps pour atteindre l'autre côté.                                                                |
-| Généralement plus performants (débit plus élevé, moins de ressources informatiques totales dépensées) et plus faciles à implémenter.                                                                                                                                             | Habituellement moins performants (débit plus faible, plus de ressources informatiques totales dépensées) et plus complexes à implémenter.                                                                                                                                                |
-| En cas de conflits de données, la résolution est claire et facile : la source de vérité est l'autorité centrale.                                                                                                                                                                 | Un protocole (souvent complexe) est nécessaire pour le règlement des litiges. si les pairs font des déclarations contradictoires sur l'état des données sur lesquelles les participants sont censés être synchronisés.                                                                   |
-| Point de défaillance unique : les acteurs malveillants peuvent démanteler le réseau en ciblant l'autorité centrale.                                                                                                                                                              | Aucun point de défaillance unique : le réseau peut toujours fonctionner même si une grande partie des participants sont attaqués/retirés.                                                                                                                                                |
+| Systèmes centralisés                                                                                                                                                                                                                                                                                                             | Systèmes décentralisés                                                                                                                                                                                                                                                                                                   |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Faible diamètre de réseau (tous les participants sont connectés à une autorité centrale). L'information se propage rapidement, car la propagation est gérée par une autorité centrale avec de nombreuses ressources informatiques.                                            | Les participants les plus éloignés du réseau peuvent potentiellement être très éloignés les uns des autres. Les informations diffusées d'un côté du réseau peuvent prendre beaucoup de temps pour atteindre l'autre côté.                                                                |
+| Généralement plus performants (débit plus élevé, moins de ressources informatiques totales dépensées) et plus faciles à implémenter.                                                                                                                                                          | Habituellement moins performants (débit plus faible, plus de ressources informatiques totales dépensées) et plus complexes à implémenter.                                                                                                                                             |
+| En cas de conflits de données, la résolution est claire et facile : la source de vérité est l'autorité centrale.                                                                                                                                                                                 | Un protocole (souvent complexe) est nécessaire pour le règlement des litiges. si les pairs font des déclarations contradictoires sur l'état des données sur lesquelles les participants sont censés être synchronisés.                                                |
+| Point de défaillance unique : les acteurs malveillants peuvent démanteler le réseau en ciblant l'autorité centrale.                                                                                                                                                                              | Aucun point de défaillance unique : le réseau peut toujours fonctionner même si une grande partie des participants sont attaqués/retirés.                                                                                                                                                |
 | La coordination entre les participants au réseau est beaucoup plus facile et est gérée par une autorité centrale. L'autorité centrale peut contraindre les participants au réseau à adopter des mises à niveau, des mises à niveau de protocole, etc. avec très peu de friction. | La coordination est souvent difficile, car aucun agent n'a le dernier mot sur les décisions prises au niveau du réseau, les mises à niveau des protocoles, etc. Dans le pire des cas, le réseau est enclin à se fracturer lorsqu'il y a des désaccords sur les changements de protocole. |
-| L'autorité centrale peut censurer les données, en empêchant potentiellement certaines parties du réseau d'interagir avec le reste du réseau.                                                                                                                                     | La censure est beaucoup plus difficile, car les informations ont de nombreux moyens de se propager sur le réseau.                                                                                                                                                                        |
-| La participation au réseau est contrôlée par l'autorité centrale.                                                                                                                                                                                                                | Tout le monde peut participer au réseau. Il n’y a pas de "gardiens". Idéalement, les coûts de participation sont très faibles.                                                                                                                                                           |
+| L'autorité centrale peut censurer les données, en empêchant potentiellement certaines parties du réseau d'interagir avec le reste du réseau.                                                                                                                                                                     | La censure est beaucoup plus difficile, car les informations ont de nombreux moyens de se propager sur le réseau.                                                                                                                                                                                        |
+| La participation au réseau est contrôlée par l'autorité centrale.                                                                                                                                                                                                                                                | Tout le monde peut participer au réseau. Il n’y a pas de "gardiens". Idéalement, les coûts de participation sont très faibles.                                                                                                                                           |
 
 Notez qu'il s'agit là de modèles généraux qui ne sont pas nécessairement valables pour tous les réseaux. En outre, en réalité, le degré de centralisation ou de décentralisation d'un réseau repose sur un spectre. Aucun réseau n'est entièrement centralisé ni entièrement décentralisé.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Qu'est-ce que le Web3 ?](/web3/) - _ethereum.org_
-- [L'Architecture d'une application Web 3.0](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
-- [The Meaning of Decentralization](https://medium.com/@VitalikButerin/the-meaning-of-decentralization-a0c92b76a274) _- Vitalik Buterin, 6 février 2017 _
-- [Pourquoi la décentralisation est importante](https://medium.com/s/story/why-decentralization-matters-5e3f79f7638e) _- Chris Dixon, 18 février 2018_
-- [Qu'est-ce que le Web 3.0 et pourquoi c'est important](https://medium.com/fabric-ventures/what-is-web-3-0-why-it-matters-934eb07f3d2b) _ - Max Mersch et Richard Muirhead, 31 décembre 2019_
-- [Pourquoi nous avons besoin du Web 3.0](https://medium.com/@gavofyork/why-we-need-web-3-0-5da4f2bf95ab) _12 Sep 2018 - Gavin Wood_
+- [Qu'est-ce que le Web3 ?](/web3/) - _ethereum.org_
+- [L'architecture d'une application Web 3.0](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
+- [La signification de la décentralisation](https://medium.com/@VitalikButerin/the-meaning-of-decentralization-a0c92b76a274) _6 février 2017 - Vitalik Buterin_
+- [Pourquoi la décentralisation est importante](https://onezero.medium.com/why-decentralization-matters-5e3f79f7638e) _18 février 2018 - Chris Dixon_
+- [Qu'est-ce que le Web 3.0 et pourquoi est-ce important](https://medium.com/fabric-ventures/what-is-web-3-0-why-it-matters-934eb07f3d2b) _31 décembre 2019 - Max Mersch et Richard Muirhead_
+- [Pourquoi nous avons besoin du Web 3.0](https://gavofyork.medium.com/why-we-need-web-3-0-5da4f2bf95ab) _12 septembre 2018 - Gavin Wood_
diff --git a/public/content/translations/fr/developers/docs/wrapped-eth/index.md b/public/content/translations/fr/developers/docs/wrapped-eth/index.md
index ae9c00f3a4d..0ebe1ff42df 100644
--- a/public/content/translations/fr/developers/docs/wrapped-eth/index.md
+++ b/public/content/translations/fr/developers/docs/wrapped-eth/index.md
@@ -1,6 +1,6 @@
 ---
 title: Qu'est-ce que l'Ether symbolique (WETH)
-description: Une introduction à l'Ether symbolique (WETH) — un système compatible ERC20 pour l'ether (ETH).
+description: "Une introduction à l'Ether symbolique (WETH) — un système compatible ERC20 pour l'ether (ETH)."
 lang: fr
 ---
 
@@ -35,19 +35,16 @@ Vous pouvez échanger le WETH contre de l'ETH en utilisant le contrat intelligen
 <ExpandableCard title="Do you pay to wrap/unwrap ETH?" eventCategory="/wrapped-eth" eventName="clicked Do you pay to wrap/unwrap ETH?">
 
 Vous payez des frais de gas pour encapsuler ou désencapsuler des ETH en utilisant le smart contract WETH.
-
 </ExpandableCard>
 
 <ExpandableCard title="Is WETH safe?" eventCategory="/wrapped-eth" eventName="clicked Is WETH safe?">
 
 Le WETH est généralement considéré comme sûr car il est basé sur un contrat intelligent simple et éprouvé. Le contrat intelligent WETH a également été formellement vérifié, ce qui constitue la norme de sécurité la plus élevée pour les contrats intelligents sur Ethereum.
-
 </ExpandableCard>
 
 <ExpandableCard title="Why am I seeing different WETH tokens?" eventCategory="/wrapped-eth" eventName="clicked Why am I seeing different WETH tokens?">
 
 Outre la [version canonique de WETH](https://etherscan.io/token/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2) décrite sur cette page, il existe d'autres variantes en circulation. Il peut s'agir de tokens personnalisés créés par des développeurs d'applications ou de versions émises sur d'autres blockchains, qui peuvent se comporter différemment ou avoir des propriétés de sécurité différentes. **Vérifiez toujours les informations sur le jeton pour savoir avec quelle implémentation de WETH vous interagissez.**
-
 </ExpandableCard>
 
 <ExpandableCard title="What are the WETH contracts on other networks?" eventCategory="/wrapped-eth" eventName="clicked What are the WETH contracts on other networks?">
@@ -55,7 +52,6 @@ Outre la [version canonique de WETH](https://etherscan.io/token/0xc02aaa39b223fe
 - [Réseau principal d'Ethereum](https://etherscan.io/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
 - [Arbitrum](https://arbiscan.io/token/0x82af49447d8a07e3bd95bd0d56f35241523fbab1)
 - [Optimism](https://optimistic.etherscan.io/token/0x4200000000000000000000000000000000000006)
-
 </ExpandableCard>
 
 ## En savoir plus {#further-reading}
diff --git a/public/content/translations/fr/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md b/public/content/translations/fr/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
index e8ae60a4b66..48c48d0b28c 100644
--- a/public/content/translations/fr/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
+++ b/public/content/translations/fr/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md
@@ -1,33 +1,32 @@
 ---
-title: Introduction à Ethereum pour développeurs Python, partie 1
-description: Une introduction au développement Ethereum, particulièrement utile aux personnes disposant de connaissances en langage de programmation Python
+title: "Introduction à Ethereum pour les développeurs Python, partie 1"
+description: "Une introduction au développement Ethereum, particulièrement utile pour ceux qui connaissent le langage de programmation Python."
 author: Marc Garreau
 lang: fr
-tags:
-  - "python"
-  - "web3.py"
+tags: [ "Python", "web3.py" ]
 skill: beginner
 published: 2020-09-08
 source: Snake charmers
 sourceUrl: https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/
 ---
 
-Vous avez donc entendu parler d'Ethereum et êtes prêts à passer de l'autre côté du miroir ? Cet article couvrira rapidement certaines fonctionnalités de base propres aux blockchains, puis vous permettra d'interagir avec une simulation de nœud Ethereum - lecture des données de blocs, vérification des soldes de comptes et envoi de transactions. En cours de route, nous soulignerons les différences entre les méthodes classiques de création d'application et ce nouveau paradigme décentralisé.
+Alors, vous avez entendu parler de ce truc qu'est Ethereum et vous êtes prêt à vous aventurer dans le terrier du lapin ? Cet article couvrira rapidement quelques notions de base de la blockchain, puis vous fera interagir avec un nœud Ethereum simulé – lecture de données de blocs, vérification des soldes de compte et envoi de transactions. Chemin faisant, nous soulignerons les différences entre les manières traditionnelles de créer des applications et ce nouveau paradigme décentralisé.
 
-## Prérequis (simple) {#soft-prerequisites}
+## Prérequis (non stricts) {#soft-prerequisites}
 
-Ce post se veut accessible à une large catégorie de développeurs. L'emploi d'[outils Python](/developers/docs/programming-languages/python/) sera réalisé, mais ils ne serviront qu'à véhiculer les idées – Ne vous inquiétez pas si vous n'êtes pas développeur Python. Toutefois, je vais faire quelques hypothèses sur ce que vous savez déjà, afin que nous puissions rapidement passer aux sujets spécifiques à Ethereum.
+Cet article se veut accessible à un large éventail de développeurs. Nous utiliserons des [outils Python](/developers/docs/programming-languages/python/), mais ils ne sont qu'un prétexte pour présenter les idées. Pas de problème si vous n'êtes pas un développeur Python. Je vais toutefois partir de quelques hypothèses sur ce que vous savez déjà, afin que nous puissions rapidement passer aux éléments spécifiques à Ethereum.
 
-Hypothèses:
+Hypothèses :
 
-- Vous êtes en mesure d'utiliser un terminal,
-- Vous avez déjà écrit quelques lignes de code Python,
-- La version 3.6 ou supérieure de Python est installée sur votre machine (l'utilisation d'un [environnement virtuel](https://realpython.com/effective-python-environment/#virtual-environments) est fortement recommandée), et
-- vous avez déjà utilisé `pip`, l'installateur de paquets de Python. Encore une fois, si l'un de ces éléments n'est pas vrai, ou si vous ne prévoyez pas de reproduire le code de cet article, vous resterez capable de comprendre son contenu sans grande difficulté.
+- Vous savez utiliser un terminal,
+- Vous avez écrit quelques lignes de code Python,
+- Python version 3.6 ou supérieure est installé sur votre machine (l'utilisation d'un [environnement virtuel](https://realpython.com/effective-python-environment/#virtual-environments) est fortement encouragée), et
+- vous avez utilisé `pip`, le programme d'installation de paquets de Python.
+  Encore une fois, si l'un de ces points ne s'applique pas à vous, ou si vous ne prévoyez pas de reproduire le code de cet article, vous devriez tout de même pouvoir suivre sans problème.
 
-## Blockchains, en bref {#blockchains-briefly}
+## Les blockchains, en bref {#blockchains-briefly}
 
-Il y a de nombreuses façons de décrire Ethereum, mais son cœur repose sur la Blockchain. Les Blockchains sont constituées d'une série de blocs, alors commençons par là. En termes simples, chaque bloc de la blockchain Ethereum n'est qu'un ensemble de métadonnées et de transactions. Dans le format JSON, cela ressemble à ceci :
+Il y a de nombreuses façons de décrire Ethereum, mais au cœur de celui-ci se trouve une blockchain. Les blockchains sont constituées d'une série de blocs, alors commençons par là. En termes simples, chaque bloc de la blockchain Ethereum n'est qu'un ensemble de métadonnées et une liste de transactions. Au format JSON, cela ressemble à ceci :
 
 ```json
 {
@@ -39,108 +38,108 @@ Il y a de nombreuses façons de décrire Ethereum, mais son cœur repose sur la
 }
 ```
 
-Chaque [bloc](/developers/docs/blocks/) possède une référence du bloc l'ayant précédé ; le `parentHash` est simplement le hash du bloc précédent.
+Chaque [bloc](/developers/docs/blocks/) possède une référence au bloc qui le précède ; le `parentHash` est simplement le hachage du bloc précédent.
 
-<FeaturedText>Note : le réseau Ethereum utilise régulièrement <a href="https://wikipedia.org/wiki/Hash_function">des fonctions de hachage</a> pour produire des valeurs de taille fixe (« hashes »). Les hachages (« hashes ») jouent un rôle important dans le réseau Ethereum, vous pouvez les considérer comme des identifiants uniques pour le moment.</FeaturedText>
+<FeaturedText>Remarque : Ethereum utilise régulièrement des <a href="https://wikipedia.org/wiki/Hash_function">fonctions de hachage</a> pour produire des valeurs de taille fixe (« hachages »). Les hachages jouent un rôle important dans Ethereum, mais pour l'instant, vous pouvez simplement les considérer comme des identifiants uniques.</FeaturedText>
 
-![Un diagramme décrivant la blockchain ainsi que les données internes de chaque bloc](./blockchain-diagram.png)
+![Un diagramme représentant une blockchain, y compris les données à l'intérieur de chaque bloc](./blockchain-diagram.png)
 
-_Une blockchain est essentiellement une liste liée ; chaque bloc a une référence au bloc précédent._
+_Une blockchain est essentiellement une liste chaînée ; chaque bloc a une référence au bloc précédent._
 
-Cette structure de données n'est pas nouvelle, mais les règles (c'est-à-dire les protocoles « peer-to-peer ») qui régissent le réseau le sont. Il n’y a pas d’autorité centrale; le réseau d'utilisateurs (pairs) doit collaborer pour pérenniser le réseau et s'affronter pour décider quelles transactions inclure dans le bloc suivant. Donc, quand vous voulez envoyer de l'argent à un ami, vous devrez diffuser cette transaction sur le réseau, puis attendre qu'elle soit incluse dans un bloc à venir.
+Cette structure de données n'a rien de nouveau, mais les règles (c'est-à-dire les protocoles pair-à-pair) qui régissent le réseau le sont. Il n'y a pas d'autorité centrale ; le réseau de pairs doit collaborer pour maintenir le réseau, et rivaliser pour décider quelles transactions inclure dans le bloc suivant. Ainsi, lorsque vous voulez envoyer de l'argent à un ami, vous devez diffuser cette transaction sur le réseau, puis attendre qu'elle soit incluse dans un prochain bloc.
 
-La seule façon pour la chaîne de blocs de vérifier que l'argent a vraiment été envoyé d'un utilisateur à un autre est d'utiliser une devise native à (à savoir créée et régie par) la blockchain. Sur le réseau Ethereum, cette devise est appelée « ether », et la blockchain Ethereum contient le seul enregistrement officiel des soldes de compte.
+La seule façon pour la blockchain de vérifier que de l'argent a bien été envoyé d'un utilisateur à un autre est d'utiliser une devise native (c'est-à-dire, créée et régie par) de cette blockchain. Dans Ethereum, cette devise s'appelle l'ether, et la blockchain Ethereum contient le seul enregistrement officiel des soldes des comptes.
 
 ## Un nouveau paradigme {#a-new-paradigm}
 
-Cette nouvelle pile de technologies décentralisées a créé de nouveaux outils de développement. De tels outils existent dans de nombreux langages de programmation, mais nous allons les explorer via le language Python. Encore une fois : même si Python n’est pas votre langage de choix, il ne devrait pas être difficile de le comprendre.
+Cette nouvelle pile technologique décentralisée a donné naissance à de nouveaux outils pour les développeurs. De tels outils existent dans de nombreux langages de programmation, mais nous allons les explorer à travers le prisme de Python. Pour le répéter : même si Python n'est pas votre langage de prédilection, vous ne devriez pas avoir de mal à suivre.
 
-Les développeurs Python qui veulent interagir avec le réseau Ethereum sont encouragés à utiliser [Web3.py](https://web3py.readthedocs.io/). Web3.py est une bibliothèque qui simplifie grandement la façon dont vous vous connectez à un nœud Ethereum, et par la suite envoyer et recevoir des données.
+Les développeurs Python qui souhaitent interagir avec Ethereum se tourneront probablement vers [Web3.py](https://web3py.readthedocs.io/). Web3.py est une bibliothèque qui simplifie grandement la connexion à un nœud Ethereum, ainsi que l'envoi et la réception de données depuis celui-ci.
 
-<FeaturedText>Note : Les notions de « noeud Ethereum » et de « client Ethereum » sont utilisées de façon interchangeable. Dans les deux cas, il se réfère au logiciel qu'un participant au réseau Ethereum exécute. Ce logiciel peut lire les données de bloc, recevoir des mises à jour lorsque de nouveaux blocs sont ajoutés à la chaîne, diffuser de nouvelles transactions, et encore bien davantage. Techniquement, le client est le logiciel , le nœud est l'ordinateur qui exécute le logiciel.</FeaturedText>
+<FeaturedText>Remarque : Les termes « nœud Ethereum » et « client Ethereum » sont utilisés de manière interchangeable. Dans les deux cas, cela fait référence au logiciel qu'un participant du réseau Ethereum exécute. Ce logiciel peut lire les données des blocs, recevoir des mises à jour lorsque de nouveaux blocs sont ajoutés à la chaîne, diffuser de nouvelles transactions, et plus encore. Techniquement, le client est le logiciel, le nœud est l'ordinateur qui exécute le logiciel.</FeaturedText>
 
-[Les clients Ethereum](/developers/docs/nodes-and-clients/) peuvent être configurés pour être accessibles par [IPC](https://wikipedia.org/wiki/Inter-process_communication), HTTP ou Websockets, donc Web3. devra respecter cette configuration. Web3.py fait référence à ces options de connexion en tant que **fournisseurs**. Il vous faudra choisir l'un des trois fournisseurs pour lier l'instance Web3.py à votre nœud.
+Les [clients Ethereum](/developers/docs/nodes-and-clients/) peuvent être configurés pour être joignables par [IPC](https://wikipedia.org/wiki/Inter-process_communication), HTTP ou Websockets, donc Web3.py devra refléter cette configuration. Web3.py désigne ces options de connexion sous le nom de **fournisseurs**. Il vous faudra choisir l'un des trois fournisseurs pour lier l'instance Web3.py à votre nœud.
 
-![Un diagramme montrant comment web3.py utilise IPC pour connecter votre application à un nœud Ethereum](./web3py-and-nodes.png)
+![Un diagramme montrant comment web3.py utilise l'IPC pour connecter votre application à un nœud Ethereum](./web3py-and-nodes.png)
 
-_Configurez le noeud Ethereum et Web3.py afin qu'ils communiquent via le même protocole, par exemple via IPC dans ce diagramme._
+_Configurez le nœud Ethereum et Web3.py pour qu'ils communiquent via le même protocole, par exemple, l'IPC dans ce diagramme._
 
-Une fois que Web3.py est correctement configuré, vous pouvez commencer à interagir avec la blockchain. Voici quelques exemples d'utilisation de Web3.py pour avoir un aperçu de ce qui va se passer :
+Une fois que Web3.py est correctement configuré, vous pouvez commencer à interagir avec la blockchain. Voici quelques exemples d'utilisation de Web3.py en guise d'aperçu de ce qui suit :
 
 ```python
-# read block data:
+# lire les données du bloc :
 w3.eth.get_block('latest')
 
-# send a transaction:
+# envoyer une transaction :
 w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
 ```
 
 ## Installation {#installation}
 
-Dans ce qui suit, nous allons juste travailler au sein de l'interpréteur Python. Nous n'allons pas créer de répertoires, fichiers, classes ou fonctions.
+Dans ce tutoriel, nous travaillerons uniquement dans un interpréteur Python. Nous ne créerons ni répertoires, ni fichiers, ni classes ou fonctions.
 
-<FeaturedText>Note : dans les exemples ci-dessous, les commandes qui commencent par `$` sont censées être exécutées dans le terminal. (Ne tapez pas le `$`, cela signifie simplement que c'est le début de la ligne.)</FeaturedText>
+<FeaturedText>Remarque : dans les exemples ci-dessous, les commandes qui commencent par `$` sont destinées à être exécutées dans le terminal. (Ne tapez pas le `$`, il indique simplement le début de la ligne.)</FeaturedText>
 
-Tout d'abord, installez [IPython](https://ipython.org/) pour avoir un environnement convivial à explorer. IPython propose entre autres une fonctionnalité d'auto-completion en appuyant sur la touche TAB, ce qui facilite la navigation dans Web3.py.
+Tout d'abord, installez [IPython](https://ipython.org/) pour disposer d'un environnement convivial pour l'exploration. IPython offre, entre autres fonctionnalités, la complétion par tabulation, ce qui facilite grandement la découverte des possibilités de Web3.py.
 
 ```bash
 pip install ipython
 ```
 
-Web3.py est publié sous le nom `web3`. Installez-le comme suit :
+Web3.py est publié sous le nom `web3`. Installez-le comme suit :
 
 ```bash
 pip install web3
 ```
 
-Encore une chose : nous allons simuler une blockchain plus tard, ce qui requiert quelques dépendances supplémentaires. Vous pouvez les installer via :
+Encore une chose : nous allons simuler une blockchain plus tard, ce qui requiert quelques dépendances supplémentaires. Vous pouvez les installer via :
 
 ```bash
 pip install 'web3[tester]'
 ```
 
-C'est tout !
+Vous êtes fin prêt !
 
-Note : Le package `web3[tester]` marche jusqu'a Python 3.10.xx
+Remarque : Le package `web3[tester]` fonctionne jusqu'à Python 3.10.xx
 
-## Lancer un sandbox {#spin-up-a-sandbox}
+## Lancer un bac à sable {#spin-up-a-sandbox}
 
-Ouvrez un nouvel environnement Python en exécutant `ipython` dans votre terminal. Ceci est comparable à l'exécution de `python`=, mais apporte plus d'avantages.
+Ouvrez un nouvel environnement Python en exécutant `ipython` dans votre terminal. C'est comparable à l'exécution de `python`, mais avec beaucoup plus de fonctionnalités.
 
 ```bash
 ipython
 ```
 
-Cela affichera quelques informations sur les versions de Python et de IPython que vous utilisez, puis vous devriez voir une invite de saisie :
+Cela affichera quelques informations sur les versions de Python et de IPython que vous utilisez, puis vous devriez voir une invite de saisie :
 
 ```python
 In [1]:
 ```
 
-Vous regardez un shell Python interactif. Essentiellement, il s'agit d'un bac à sable pour jouer. Si vous êtes arrivés jusqu’ici, il est temps d’importer Web3.py :
+Vous avez maintenant devant vous un shell Python interactif. Essentiellement, c'est un bac à sable dans lequel vous pouvez expérimenter. Si vous êtes arrivé jusqu’ici, il est temps d’importer Web3.py :
 
 ```python
 In [1]: from web3 import Web3
 ```
 
-## Introduction du module Web3 {#introducing-the-web3-module}
+## Présentation du module Web3 {#introducing-the-web3-module}
 
-En plus d'être une passerelle vers Ethereum, le module [Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api) offre quelques fonctions pratiques. Examinons-en quelques-unes.
+En plus d'être une passerelle vers Ethereum, le module [Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api) offre quelques fonctions utilitaires. Explorons-en quelques-unes.
 
-Dans une application Ethereum, vous devrez généralement convertir des libellés de devises. Le module Web3 fournit quelques méthodes juste pour cela : [fromWei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.from_wei) et [toWei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.to_wei).
+Dans une application Ethereum, vous aurez souvent besoin de convertir des dénominations de monnaie. Le module Web3 fournit quelques méthodes d'assistance à cet effet : [from_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.from_wei) et [to_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.to_wei).
 
 <FeaturedText>
-Remarque : les ordinateurs sont notoirement peu efficaces pour la gestion des nombres décimaux. Pour contourner cela, les développeurs stockent souvent les montants en dollar en centimes. Par exemple, un article avec un prix de 5,99 $ peut être stocké dans la base de données comme 599.
+Note: Computers are notoriously bad at handling decimal math. To get around this, developers often store dollar amounts in cents. For example, an item with a price of $5.99 may be stored in the database as 599.
 
-Un schéma similaire est utilisé lors de la gestion des transactions en <b>ether</b>. Cependant, au lieu de deux décimaux, l'ether en a 18 ! La plus petite dénomination d'ether s'appelle <b>wei</b>, c'est la valeur spécifiée lors de l'envoi des transactions.
+Un modèle similaire est utilisé lors du traitement des transactions en <b>ether</b>. Cependant, au lieu de deux décimales, l'ether en a 18 ! La plus petite dénomination d'ether s'appelle <b>wei</b>, c'est donc la valeur spécifiée lors de l'envoi de transactions.
 
 1 ether = 1000000000000000000 wei
 
-1 wei = 0,00000000000001 ether
+1 wei = 0,000000000000000001 ether
 
 </FeaturedText>
 
-Essayez de convertir certaines valeurs depuis et vers le wei. Notez qu'il y a [des noms pour un grand nombre de dénominations](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations) entre ether et wei. L'une des plus connues est le **gwei**, car c'est souvent la façon dont les frais de transaction sont représentés.
+Essayez de convertir certaines valeurs depuis et vers le wei. Notez qu'[il existe des noms pour la plupart des dénominations](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations) entre l'ether et le wei. L'un des plus connus est le **gwei**, car c'est souvent ainsi que les frais de transaction sont représentés.
 
 ```python
 In [2]: Web3.to_wei(1, 'ether')
@@ -150,49 +149,50 @@ In [3]: Web3.from_wei(500000000, 'gwei')
 Out[3]: Decimal('0.5')
 ```
 
-Les autres méthodes utilitaires du module Web3 incluent les convertisseurs de format de données (par exemple, [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)), les méthodes pour gérer les adresses (e. ., [`isAddress`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)), et les fonctions de hachage (par exemple, [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)). Beaucoup d'entre elles seront étudiées plus tard dans la série. Pour afficher toutes les méthodes et propriétés disponibles, utilisez l'auto-complétion de IPython en tapant `Web3`. et en appuyant sur la touche tabulation deux fois après le point.
+D'autres méthodes utilitaires du module Web3 comprennent des convertisseurs de format de données (par ex., [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)), des assistants d'adresse (par ex., [`isAddress`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)), et des fonctions de hachage (par ex., [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)). Beaucoup d'entre elles seront abordées plus tard dans la série. Pour afficher toutes les méthodes et propriétés disponibles, utilisez l'auto-complétion d'IPython en tapant `Web3`. et en appuyant deux fois sur la touche tabulation après le point.
 
-## Parler à la chaîne {#talk-to-the-chain}
+## Discuter avec la chaîne {#talk-to-the-chain}
 
-Ces méthodes sont très intéressantes, mais passons à la blockchain. L'étape suivante est de configurer Web3.py à des fins de communication avec un noeud Ethereum. Ici, nous avons la possibilité d'utiliser les fournisseurs IPC, HTTP, ou Websocket.
+Les méthodes de commodité sont très bien, mais passons à la blockchain. L'étape suivante consiste à configurer Web3.py pour qu'il communique avec un nœud Ethereum. Ici, nous avons la possibilité d'utiliser les fournisseurs IPC, HTTP ou Websocket.
 
-Nous n'allons pas explorer cette voie, mais un exemple de flux de travail complet en utilisant le fournisseur HTTP pourrait ressembler à ceci :
+Nous n'allons pas suivre cette voie, mais un exemple de flux de travail complet utilisant le fournisseur HTTP pourrait ressembler à ceci :
 
-- Télécharger un nœud Ethereum, par exemple [Geth](https://geth.ethereum.org/).
-- Démarrez Geth dans une seule fenêtre de terminal et attendez qu'il synchronise le réseau. Le port HTTP par défaut est `8545`, mais il est configurable.
-- Dites à Web3.py de se connecter au nœud via HTTP, sur `localhost:8545`. `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
+- Téléchargez un nœud Ethereum, par ex., [Geth](https://geth.ethereum.org/).
+- Démarrez Geth dans une fenêtre de terminal et attendez qu'il synchronise le réseau. Le port HTTP par défaut est `8545`, mais il est configurable.
+- Indiquez à Web3.py de se connecter au nœud via HTTP, sur `localhost:8545`.
+  `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
 - Utilisez l'instance `w3` pour interagir avec le nœud.
 
-Bien qu’il s’agisse d’une « vraie » façon de le faire, le processus de synchronisation prend des heures et est inutile si vous voulez juste un environnement de développement. Web3.py expose un quatrième fournisseur à cet effet, l'**EthereumTesterProvider**. Ce fournisseur de testeur est relié à un nœud Ethereum simulé avec des autorisations réduites et des fausses devises pour jouer.
+Bien que ce soit une façon « réelle » de le faire, le processus de synchronisation prend des heures et est inutile si vous voulez juste un environnement de développement. Web3.py expose un quatrième fournisseur à cet effet, l'**EthereumTesterProvider**. Ce fournisseur de test est relié à un nœud Ethereum simulé avec des autorisations assouplies et de la fausse monnaie pour s'exercer.
 
-![Un diagramme montrant l'EthereumTesterProvider reliant votre application web3.py à un nœud Ethereum simulé](./ethereumtesterprovider.png)
+![Un diagramme montrant EthereumTesterProvider reliant votre application web3.py à un nœud Ethereum simulé](./ethereumtesterprovider.png)
 
-_L'EthereumTesterProvider se connecte à un noeud simulé et est pratique pour des environnements de développement rapides._
+_L'EthereumTesterProvider se connecte à un nœud simulé et est pratique pour des environnements de développement rapides._
 
-Ce nœud simulé s'appelle [eth-testeur](https://github.com/ethereum/eth-tester) et nous l'avons installé dans le cadre de la commande `pip install web3[tester]`. Configurer Web3.py pour qu'il utilise ce fournisseur de testeur est aussi simple que :
+Ce nœud simulé s'appelle [eth-tester](https://github.com/ethereum/eth-tester) et nous l'avons installé dans le cadre de la commande `pip install web3[tester]`. Configurer Web3.py pour utiliser ce fournisseur de test est aussi simple que :
 
 ```python
 In [4]: w3 = Web3(Web3.EthereumTesterProvider())
 ```
 
-Maintenant vous êtes prêt à surfer sur la chaîne ! Ce n'est pas une chose que les gens disent. Je viens juste de l'inventer. Faisons un tour rapide.
+Vous êtes maintenant prêt à surfer sur la chaîne ! Personne ne dit ça. Je viens de l'inventer. Faisons un tour rapide.
 
 ## Le tour rapide {#the-quick-tour}
 
-Tout d'abord, une vérification :
+Tout d'abord, une vérification de base :
 
 ```python
 In [5]: w3.is_connected()
 Out[5]: True
 ```
 
-Étant donné que nous utilisons le fournisseur de testeur, ce test n'est pas très important. Toutefois, s'il échoue, il y a des chances que vous ayez mal tapé quelque chose lors de l'instanciation de la variable `w3`. Vérifiez bien que vous avez inclus les parenthèses intérieures, à savoir `Web3.EthereumTesterProvider()`.
+Étant donné que nous utilisons le fournisseur de test, ce test n'est pas très utile, mais s'il échoue, il y a de fortes chances que vous ayez mal saisi quelque chose lors de l'instanciation de la variable `w3`. Vérifiez que vous avez bien inclus les parenthèses intérieures, c'est-à-dire `Web3.EthereumTesterProvider()`.
 
-## Arrêt #1 : Les [comptes](/developers/docs/accounts/) {#tour-stop-1-accounts}
+## Arrêt n°1 : [comptes](/developers/docs/accounts/) {#tour-stop-1-accounts}
 
-Afin de faciliter les tests, le fournisseur de testeur a créé des comptes et les a préchargés avec un ether de test.
+Par commodité, le fournisseur de test a créé des comptes et les a préchargés avec de l'ether de test.
 
-D’abord, observons une liste de ces comptes :
+D'abord, jetons un œil à la liste de ces comptes :
 
 ```python
 In [6]: w3.eth.accounts
@@ -201,27 +201,27 @@ Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
  '0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]
 ```
 
-Si vous exécutez cette commande, vous devriez voir une liste de dix chaînes de caractères qui commencent par `0x`. Chacune d'entre elles est une **adresse publique** qui est, à certains égards, similaire au numéro de compte sur un compte bancaire. Vous pourriez fournir cette adresse à quelqu'un qui voudrait vous envoyer des ethers.
+Si vous exécutez cette commande, vous devriez voir une liste de dix chaînes de caractères qui commencent par `0x`. Chacune est une **adresse publique** et est, à certains égards, analogue au numéro de compte d'un compte courant. Vous fourniriez cette adresse à quelqu'un qui voudrait vous envoyer de l'ether.
 
-Comme mentionné, le fournisseur de testeur a préchargé chacun de ces comptes avec des ethers de test. Cherchons maintenant combien d'ethers contient le premier compte :
+Comme mentionné, le fournisseur de test a préchargé chacun de ces comptes avec de l'ether de test. Voyons combien il y en a dans le premier compte :
 
 ```python
 In [7]: w3.eth.get_balance(w3.eth.accounts[0])
 Out[7]: 1000000000000000000000000
 ```
 
-Beaucoup de zéros ! Avant d'aller à la fausse banque et de vous remplir les poches tout le long du trajet, rappellez-vous la leçon de tout à l'heure sur les dénominations monétaires. La valeur en ether est présentée dans sa plus petite dénomination, le wei. Convertissons-la en ether :
+Ça fait beaucoup de zéros ! Avant d'aller rire jusqu'à la fausse banque, rappelez-vous la leçon précédente sur les dénominations de devises. Les valeurs en ether sont représentées dans la plus petite dénomination, le wei. Convertissons cela en ether :
 
 ```python
 In [8]: w3.from_wei(1000000000000000000000000, 'ether')
 Out[8]: Decimal('1000000')
 ```
 
-Un million d'ethers de test — ça reste toujours intéressant.
+Un million d'ethers de test... ce n'est pas si mal.
 
-## Arrêt #2 : Les données de bloc {#tour-stop-2-block-data}
+## Arrêt n°2 : données des blocs {#tour-stop-2-block-data}
 
-Jetons un coup d’œil à l’état de cette blockchain simulée :
+Jetons un coup d’œil à l’état de cette blockchain simulée :
 
 ```python
 In [9]: w3.eth.get_block('latest')
@@ -234,15 +234,15 @@ Out[9]: AttributeDict({
 })
 ```
 
-Beaucoup d'informations sont retournées à propos d'un bloc, mais juste quelques choses à signaler ici :
+Beaucoup d'informations sont retournées à propos d'un bloc, mais il y a juste quelques points à souligner ici :
 
-- Le numéro de bloc est zéro — peu importe depuis combien de temps vous avez configuré le fournisseur de testeur. Contrairement au véritable réseau Ethereum qui mine un nouveau bloc toutes les 12 secondes, cette simulation restera en attente jusqu'à ce que vous lui donniez une tâche à accomplir.
-- `transactions` est une liste vide pour la même raison : nous n’avons rien fait pour le moment. Ce premier bloc est un bloc **vide**, juste conçu pour démarrer la chaîne.
-- Notez que le `parentHash` n'est qu'un amas d'octets vides. Cela signifie qu'il s'agit du premier bloc de la chaîne, également connu sous le nom de **bloc de genèse**.
+- Le numéro de bloc est zéro, peu importe depuis combien de temps vous avez configuré le fournisseur de test. Contrairement au véritable réseau Ethereum, qui ajoute un nouveau bloc toutes les 12 secondes environ, cette simulation attendra que vous lui donniez du travail à faire.
+- `transactions` est une liste vide, pour la même raison : nous n’avons encore rien fait. Ce premier bloc est un **bloc vide**, juste pour démarrer la chaîne.
+- Notez que le `parentHash` n'est qu'un ensemble d'octets vides. Cela signifie qu'il s'agit du premier bloc de la chaîne, également connu sous le nom de **bloc de genèse**.
 
-## Arrêt #3 : Les [transactions](/developers/docs/transactions/) {#tour-stop-3-transactions}
+## Arrêt n°3 : [transactions](/developers/docs/transactions/) {#tour-stop-3-transactions}
 
-Nous sommes coincés au bloc zéro jusqu'à ce qu'il y ait une transaction en attente, alors en voilà une. Envoyez quelques ethers de test d'un compte à un autre :
+Nous sommes bloqués au bloc zéro jusqu'à ce qu'il y ait une transaction en attente, alors créons-en une. Envoyez quelques ethers de test d'un compte à un autre :
 
 ```python
 In [10]: tx_hash = w3.eth.send_transaction({
@@ -253,11 +253,14 @@ In [10]: tx_hash = w3.eth.send_transaction({
 })
 ```
 
-C'est généralement le moment pendant lequel vous devriez attendre pendant plusieurs secondes pour que votre transaction soit réalisée et intégrée dans un nouveau bloc. Le processus complet se déroule comme ceci :
+C'est généralement à ce moment-là que vous devez attendre plusieurs secondes que votre transaction soit incluse dans un nouveau bloc. Le processus complet se déroule comme suit :
 
-1. Soumettez une transaction et attendez le hachage de la transaction. Jusqu'à ce que le bloc contenant la transaction soit créé et diffusé, la transaction sera « en attente. » `tx_hash = w3.eth.send_transaction({ … })`
-2. Attendez que la transaction soit intégrée dans un bloc : `w3.eth.wait_for_transaction_receipt(tx_hash)`
-3. Continuer la logique de l'application. Pour voir la transaction réussie : `w3.eth.get_transaction(tx_hash)`
+1. Soumettez une transaction et conservez le hachage de la transaction. Tant que le bloc contenant la transaction n'est pas créé et diffusé, la transaction est « en attente ».
+   `tx_hash = w3.eth.send_transaction({ … })`
+2. Attendez que la transaction soit incluse dans un bloc :
+   `w3.eth.wait_for_transaction_receipt(tx_hash)`
+3. Poursuivre la logique de l'application. Pour afficher la transaction réussie :
+   `w3.eth.get_transaction(tx_hash)`
 
 Notre environnement simulé ajoutera la transaction dans un nouveau bloc instantanément, de sorte que nous pouvons immédiatement voir la transaction :
 
@@ -274,24 +277,24 @@ Out[11]: AttributeDict({
 })
 ```
 
-Vous verrez ici quelques détails familiers : les champs `from`, `to`, et `value` doivent correspondre aux entrées de notre appel `send_transaction`. L'autre bit rassurant est que cette transaction a été incluse comme la première transaction (`'transactionIndex': 0`) dans le bloc numéro 1.
+Vous verrez ici quelques détails familiers : les champs `from`, `to` et `value` doivent correspondre aux entrées de notre appel `send_transaction`. L'autre élément rassurant est que cette transaction a été incluse comme première transaction (`'transactionIndex': 0`) dans le bloc numéro 1.
 
-Nous pouvons également facilement vérifier la réussite de cette transaction en examinant les soldes des deux comptes concernés. Trois ethers sont supposés être passés de l'un à l'autre.
+Nous pouvons également vérifier facilement le succès de cette transaction en consultant les soldes des deux comptes concernés. Trois ethers auraient dû passer de l'un à l'autre.
 
 ```python
-Entrée [12] : w3.eth.get_balance(w3.eth.accounts[0])
-Sortie [12]: 999996999979000000000000
+In [12]: w3.eth.get_balance(w3.eth.accounts[0])
+Out[12]: 999996999979000000000000
 
-Entrée [13] : w3.eth.get_balance(w3.eth.accounts[1])
-Sortie [13] : 1000003000000000000000000
+In [13]: w3.eth.get_balance(w3.eth.accounts[1])
+Out[13]: 1000003000000000000000000
 ```
 
-Ce dernier semble bon ! Le solde est passé de 1 000 000 à 1 000 003 ethers. Mais qu'est-il arrivé au premier compte ? Il semble avoir perdu un peu plus que trois ethers. Hélas, rien dans la vie n'est gratuit et l'utilisation du réseau public Ethereum exige que vous compensiez vos pairs pour leur rôle de soutien. Une petite commission de transaction a été déduite du compte qui a soumis la transaction - cette commission correspond à la quantité de gaz brûlé (21 000 unités de gaz pour un transfert ETH) multipliée par une commission de base qui varie en fonction de l'activité du réseau plus un pourboire qui va au validateur qui inclut la transaction dans un bloc.
+Ce dernier semble bon ! Le solde est passé de 1 000 000 à 1 000 003 ethers. Mais qu'est-il arrivé au premier compte ? Il semble avoir perdu un peu plus de trois ethers. Hélas, rien dans la vie n'est gratuit, et l'utilisation du réseau public Ethereum exige que vous dédommagiez vos pairs pour leur rôle de soutien. De faibles frais de transaction ont été déduits du compte qui a soumis la transaction. Ces frais correspondent à la quantité de gaz brûlé (21 000 unités de gaz pour un transfert d'ETH) multipliée par des frais de base qui varient en fonction de l'activité du réseau, plus un pourboire qui va au validateur qui inclut la transaction dans un bloc.
 
-En savoir plus sur les[gaz](/developers/docs/gas/#post-london)
+En savoir plus sur le [gaz](/developers/docs/gas/#post-london)
 
-<FeaturedText>Remarque : sur le réseau public, les commissions de transaction sont variables en fonction de la demande du réseau et de la rapidité avec laquelle vous souhaitez que soit traitée une transaction. Si vous êtes intéressé par la façon dont les frais sont calculés, vous pouvez consulter mon précédent article sur <a href="https://medium.com/ethereum-grid/ethereum-101-how-are-transactions-included-in-a-block-9ae5f491853f">la manière dont les transactions sont incluses dans un bloc</a>.</FeaturedText>
+<FeaturedText>Remarque : sur le réseau public, les frais de transaction sont variables en fonction de la demande du réseau et de la rapidité avec laquelle vous souhaitez qu'une transaction soit traitée. Si vous souhaitez obtenir une répartition de la manière dont les frais sont calculés, consultez mon article précédent sur la <a href="https://medium.com/ethereum-grid/ethereum-101-how-are-transactions-included-in-a-block-9ae5f491853f">façon dont les transactions sont incluses dans un bloc</a>.</FeaturedText>
 
-## Et respirez... {#and-breathe}
+## Et respirez {#and-breathe}
 
-Nous y sommes depuis un bon moment et il semble donc intéressant de faire une pause. Le terrier du lapin est toujours ouvert et nous continuerons à l'explorer dans la deuxième partie de cette série. Quelques concepts à venir : la connexion à un vrai nœud, les contrats intelligents et les jetons. Vous avez des questions complémentaires ? Faites-le moi savoir ! Vos commentaires influenceront notre chemin à partir d’ici. Vos demandes sont les bienvenues sur [Twitter](https://twitter.com/wolovim).
+Cela fait un moment que nous y sommes, c'est donc le bon moment pour faire une pause. Le terrier du lapin se poursuit, et nous continuerons à l'explorer dans la deuxième partie de cette série. Quelques concepts à venir : la connexion à un nœud réel, les contrats intelligents et les jetons. Vous avez d'autres questions ? Faites-le moi savoir ! Vos commentaires influenceront la suite des événements. Les demandes sont les bienvenues via [Twitter](https://twitter.com/wolovim).
diff --git a/public/content/translations/fr/developers/tutorials/all-you-can-cache/index.md b/public/content/translations/fr/developers/tutorials/all-you-can-cache/index.md
index 56ee481b339..5c3f3cb026d 100644
--- a/public/content/translations/fr/developers/tutorials/all-you-can-cache/index.md
+++ b/public/content/translations/fr/developers/tutorials/all-you-can-cache/index.md
@@ -1,42 +1,39 @@
 ---
-title: "Tout ce qui se cache"
-description: Apprenez comment créer et utiliser un contrat de mise en cache pour des transactions moins chères sur le rollup
+title: "Mise en cache à volonté"
+description: "Apprenez comment créer et utiliser un contrat de mise en cache pour des transactions de rollup moins chères"
 author: Ori Pomerantz
-tags:
-  - "Couche 2"
-  - "mise en cache"
-  - "stockage"
+tags: [ "couche 2", "mise en cache", "stockage" ]
 skill: intermediate
 published: 2022-09-15
 lang: fr
 ---
 
-Lors de l'utilisation de rollups, le coût d'un octet dans la transaction est bien plus élevé que le coût d'un emplacement de stockage. Par conséquent, il est logique de mettre en cache autant d'informations que possible sur la blockchain.
+Lors de l'utilisation de rollups, le coût d'un octet dans la transaction est bien plus élevé que le coût d'un emplacement de stockage. Par conséquent, il est logique de mettre en cache autant d'informations que possible en chaîne.
 
-Dans cet article, vous apprendrez comment créer et utiliser un contrat de mise en cache afin que toute valeur de paramètre susceptible d'être utilisée plusieurs fois soit mise en cache et disponible à l'utilisation (après la première fois) avec un nombre plus réduit d'octets, enfin vous apprendrez comment écrire du code qui utilise cette technique de mise en cache.
+Dans cet article, vous apprendrez à créer et à utiliser un contrat de mise en cache de telle manière que toute valeur de paramètre susceptible d'être utilisée plusieurs fois soit mise en cache et disponible à l'utilisation (après la première fois) avec un nombre d'octets beaucoup plus faible, et comment écrire du code hors chaîne qui utilise ce cache.
 
-Si vous souhaitez ignorer l'article et simplement voir le code source, vous le trouverez [ici](https://github.com/qbzzt/20220915-all-you-can-cache). Le logiciel de développement utilisé est [Foundry](https://book.getfoundry.sh/getting-started/installation).
+Si vous voulez sauter l'article et voir directement le code source, [il est ici](https://github.com/qbzzt/20220915-all-you-can-cache). La pile de développement est [Foundry](https://getfoundry.sh/introduction/installation/).
 
 ## Conception générale {#overall-design}
 
-Pour simplifier, nous supposerons que tous les paramètres de transaction sont de type `uint256`, d'une longueur de 32 octets. Lorsque nous recevons une transaction, nous analyserons chaque paramètre de la manière suivante :
+Par souci de simplicité, nous supposerons que tous les paramètres de transaction sont de type `uint256` et longs de 32 octets. Lorsque nous recevons une transaction, nous analysons chaque paramètre comme ceci :
 
 1. Si le premier octet est `0xFF`, prenez les 32 octets suivants comme valeur de paramètre et écrivez-la dans le cache.
 
-2. Si le premier octet est `0xFE`, prenez les 32 octets suivants comme valeur de paramètre, mais _ne_ l'écrivez pas dans le cache.
+2. Si le premier octet est `0xFE`, prenez les 32 octets suivants comme valeur de paramètre, mais ne l'écrivez _pas_ dans le cache.
 
-3. Pour toute autre valeur, prenez les quatre premiers bits comme le nombre d'octets supplémentaires, et les quatre bits de fin comme les bits les plus significatifs de la clé de la mise en cache. Voici quelques exemples :
+3. Pour toute autre valeur, prenez les quatre bits de poids fort comme le nombre d'octets supplémentaires, et les quatre bits de poids faible comme les bits les plus significatifs de la clé du cache. Voici quelques exemples :
 
-   | Octets dans les données d'appel | Clé de la mise en cache |
-   |:------------------------------- | -----------------------:|
-   | 0x0F                            |                    0x0F |
-   | 0x10,0x10                       |                    0x10 |
-   | 0x12,0xAC                       |                  0x02AC |
-   | 0x2D,0xEA, 0xD6                 |                0x0DEAD6 |
+   | Octets dans les données d'appel | Clé du cache |
+   | :------------------------------ | -----------: |
+   | 0x0F                            |         0x0F |
+   | 0x10,0x10                       |         0x10 |
+   | 0x12,0xAC                       |       0x02AC |
+   | 0x2D,0xEA, 0xD6                 |     0x0DEAD6 |
 
 ## Manipulation du cache {#cache-manipulation}
 
-La mise en cache est implémentée dans [`Cache.sol`](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol). Revenons dessus ligne par ligne.
+Le cache est implémenté dans [`Cache.sol`](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol). Revenons dessus ligne par ligne.
 
 ```solidity
 // SPDX-License-Identifier: UNLICENSED
@@ -49,93 +46,93 @@ contract Cache {
     bytes1 public constant DONT_CACHE = 0xFE;
 ```
 
-Ces constantes sont utilisées pour gérer les cas spéciaux où nous fournissons toutes les informations et souhaitons ou non les écrire dans la mise en cache. Écrire dans le cache nécessite deux opérations [`SSTORE`](https://www.evm.codes/#55) dans des emplacements de stockage précédemment libres, au coût de 22100 gaz chacune, cela est donc facultatif.
+Ces constantes sont utilisées pour interpréter les cas spéciaux où nous fournissons toutes les informations et souhaitons ou non les écrire dans le cache. L'écriture dans le cache nécessite deux opérations [`SSTORE`](https://www.evm.codes/#55) dans des emplacements de stockage précédemment inutilisés, au coût de 22 100 gaz chacune, nous rendons donc cela facultatif.
 
 ```solidity
 
     mapping(uint => uint) public val2key;
 ```
 
-Une [correspondance](https://www.geeksforgeeks.org/solidity-mappings/) entre les valeurs et leurs clés. Ces informations sont nécessaires pour encoder les valeurs avant d'envoyer la transaction.
+Une [correspondance](https://www.geeksforgeeks.org/solidity/solidity-mappings/) entre les valeurs et leurs clés. Ces informations sont nécessaires pour encoder les valeurs avant d'envoyer la transaction.
 
 ```solidity
-    // Location n has the value for key n+1, because we need to preserve
-    // zero as "not in the cache".
+    // L'emplacement n a la valeur pour la clé n+1, car nous devons préserver
+    // zéro comme « pas dans le cache ».
     uint[] public key2val;
 ```
 
-Nous pouvons utiliser un tableau pour le mappage des clés aux valeurs car nous attribuons les clés, et pour simplifier, nous le faisons de manière séquentielle.
+Nous pouvons utiliser un tableau pour la correspondance des clés aux valeurs car nous attribuons les clés, et par souci de simplicité, nous le faisons de manière séquentielle.
 
 ```solidity
     function cacheRead(uint _key) public view returns (uint) {
-        require(_key <= key2val.length, "Reading uninitialize cache entry");
+        require(_key <= key2val.length, "Lecture d'une entrée de cache non initialisée");
         return key2val[_key-1];
     }  // cacheRead
 ```
 
-Lire une valeur dans le cache.
+Lire une valeur à partir du cache.
 
 ```solidity
-    // Write a value to the cache if it's not there already
-    // Only public to enable the test to work
+    // Écrire une valeur dans le cache si elle n'y est pas déjà
+    // Uniquement public pour permettre au test de fonctionner
     function cacheWrite(uint _value) public returns (uint) {
-        // If the value is already in the cache, return the current key
+        // Si la valeur est déjà dans le cache, retourner la clé actuelle
         if (val2key[_value] != 0) {
             return val2key[_value];
         }
 ```
 
-Il n'y a aucun intérêt à mettre la même valeur dans le cache plus d'une fois. Si la valeur est déjà présente, renvoyez simplement la clé existante.
+Il n'y a aucun intérêt à mettre la même valeur dans le cache plus d'une fois. Si la valeur est déjà présente, il suffit de retourner la clé existante.
 
 ```solidity
-        // Since 0xFE is a special case, the largest key the cache can
-        // hold is 0x0D followed by 15 0xFF's. If the cache length is already that
-        // large, fail.
+        // Puisque 0xFE est un cas spécial, la plus grande clé que le cache peut
+        // contenir est 0x0D suivie de 15 0xFF. Si la longueur du cache est déjà aussi
+        // grande, on échoue.
         //                              1 2 3 4 5 6 7 8 9 A B C D E F
         require(key2val.length+1 < 0x0DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
-            "cache overflow");
+            "dépassement du cache");
 ```
 
-Je ne pense pas que nous aurons un cache aussi grand (environ 1.8\*10<sup>37</sup> valeurs, ce qui nécessiterait environ 10<sup>27</sup> To de stockage). Cependant, je suis assez vieux pour me rappeler que ["640 ko sera toujours suffisant"](https://quoteinvestigator.com/2011/09/08/640k-enough/). Ce test est très peu coûteux.
+Je ne pense pas que nous aurons jamais un cache aussi grand (environ 1,8\*10<sup>37</sup> entrées, ce qui nécessiterait environ 10<sup>27</sup> To de stockage). Cependant, je suis assez vieux pour me souvenir du fameux [« 640 Ko devraient suffire à tout le monde »](https://quoteinvestigator.com/2011/09/08/640k-enough/). Ce test est très peu coûteux.
 
 ```solidity
-        // Write the value using the next key
+        // Écrire la valeur en utilisant la clé suivante
         val2key[_value] = key2val.length+1;
 ```
 
-Ajoutez la recherche inversée (trouver la clé en fonction de la valeur).
+Ajoutez la recherche inversée (de la valeur à la clé).
 
 ```solidity
         key2val.push(_value);
 ```
 
-Ajoutez la recherche directe (trouver la valeur en fonction de la clé). Comme nous attribuons des valeurs de manière séquentielle, nous pouvons simplement l'ajouter après la dernière valeur du tableau.
+Ajoutez la recherche directe (de la clé à la valeur). Comme nous attribuons des valeurs de manière séquentielle, nous pouvons simplement l'ajouter après la dernière valeur du tableau.
 
 ```solidity
         return key2val.length;
-    }  // cacheWrite
+    }  // écritureCache
 ```
 
-Renvoyez la nouvelle longueur de `key2val`, qui est la cellule où la nouvelle valeur est stockée.
+Retourner la nouvelle longueur de `key2val`, qui est la cellule où la nouvelle valeur est stockée.
 
 ```solidity
     function _calldataVal(uint startByte, uint length)
         private pure returns (uint)
 ```
 
-Cette fonction lit une valeur à partir du calldata d'une longueur arbitraire (jusqu'à 32 octets, la taille d'un mot).
+Cette fonction lit une valeur à partir des données d'appel, de longueur arbitraire (jusqu'à 32 octets, la taille d'un mot).
 
 ```solidity
     {
         uint _retVal;
 
         require(length < 0x21,
-            "_calldataVal length limit is 32 bytes");
+            "la limite de longueur de _calldataVal est de 32 octets");
         require(length + startByte <= msg.data.length,
-            "_calldataVal trying to read beyond calldatasize");
+            "_calldataVal tente de lire au-delà de calldatasize");
 ```
 
-Cette fonction est interne, donc si le reste du code est écrit correctement, ces tests ne sont pas nécessaires. Cependant, ils ne coûtent pas grand-chose, donc autant les inclure.
+Cette fonction est interne, donc si le reste du code est écrit correctement, ces tests ne sont pas nécessaires. Cependant, ils ne coûtent pas cher, alors autant les avoir.
 
 ```solidity
         assembly {
@@ -143,56 +140,56 @@ Cette fonction est interne, donc si le reste du code est écrit correctement, ce
         }
 ```
 
-Ce code est en [Yul](https://docs.soliditylang.org/en/v0.8.16/yul.html). Il lit une valeur de 32 octets à partir du calldata. Cela fonctionne même si le calldata s'arrête avant `startByte+32` car l'espace non initialisé dans l'EVM est considéré comme nul.
+Ce code est en [Yul](https://docs.soliditylang.org/en/v0.8.16/yul.html). Il lit une valeur de 32 octets à partir des données d'appel. Cela fonctionne même si les données d'appel s'arrêtent avant `startByte+32`, car l'espace non initialisé dans l'EVM est considéré comme étant nul.
 
 ```solidity
         _retVal = _retVal >> (256-length*8);
 ```
 
-Nous n'avons pas nécessairement besoin d'une valeur de 32 octets. Cela élimine les octets en trop.
+Nous n'avons pas nécessairement besoin d'une valeur de 32 octets. Cela permet de se débarrasser des octets excédentaires.
 
 ```solidity
         return _retVal;
     } // _calldataVal
 
 
-    // Read a single parameter from the calldata, starting at _fromByte
+    // Lire un seul paramètre depuis calldata, en commençant à _fromByte
     function _readParam(uint _fromByte) internal
         returns (uint _nextByte, uint _parameterValue)
     {
 ```
 
-Lire un seul paramètre à partir du calldata. Notez que nous devons retourner non seulement la valeur que nous avons lue, mais également l'emplacement de l'octet suivant, car les paramètres peuvent avoir une longueur allant d'un octet à 33 octets.
+Lire un seul paramètre à partir des données d'appel. Notez que nous devons retourner non seulement la valeur que nous avons lue, mais aussi l'emplacement de l'octet suivant, car les paramètres peuvent avoir une longueur allant de 1 à 33 octets.
 
 ```solidity
-        // The first byte tells us how to interpret the rest
+        // Le premier octet nous indique comment interpréter le reste
         uint8 _firstByte;
 
         _firstByte = uint8(_calldataVal(_fromByte, 1));
 ```
 
-Solidity s'efforce de réduire le nombre de bugs en interdisant les [conversions implicites](https://docs.soliditylang.org/en/v0.8.16/types.html#implicit-conversions) car potentiellement dangereuses. Une réduction, par exemple de 256 bits à 8 bits, doit être explicitement indiquée.
+Solidity essaie de réduire le nombre de bogues en interdisant les [conversions de type implicites](https://docs.soliditylang.org/en/v0.8.16/types.html#implicit-conversions) potentiellement dangereuses. Une conversion descendante, par exemple de 256 bits à 8 bits, doit être explicite.
 
 ```solidity
 
-        // Read the value, but do not write it to the cache
+        // Lire la valeur, mais ne pas l'écrire dans le cache
         if (_firstByte == uint8(DONT_CACHE))
             return(_fromByte+33, _calldataVal(_fromByte+1, 32));
 
-        // Read the value, and write it to the cache
+        // Lire la valeur et l'écrire dans le cache
         if (_firstByte == uint8(INTO_CACHE)) {
             uint _param = _calldataVal(_fromByte+1, 32);
             cacheWrite(_param);
             return(_fromByte+33, _param);
         }
 
-        // If we got here it means that we need to read from the cache
+        // Si nous arrivons ici, cela signifie que nous devons lire depuis le cache
 
-        // Number of extra bytes to read
+        // Nombre d'octets supplémentaires à lire
         uint8 _extraBytes = _firstByte / 16;
 ```
 
-Prendre le [nibble](https://fr.wikipedia.org/wiki/Nibble) inférieur et le combiner avec les autres octets pour lire la valeur depuis le cache.
+Prenez le [quartet](https://fr.wikipedia.org/wiki/Quartet_\(informatique\)) inférieur et combinez-le avec les autres octets pour lire la valeur du cache.
 
 ```solidity
         uint _key = (uint256(_firstByte & 0x0F) << (8*_extraBytes)) +
@@ -203,17 +200,17 @@ Prendre le [nibble](https://fr.wikipedia.org/wiki/Nibble) inférieur et le combi
     }  // _readParam
 
 
-    // Read n parameters (functions know how many parameters they expect)
+    // Lire n paramètres (les fonctions savent combien de paramètres elles attendent)
     function _readParams(uint _paramNum) internal returns (uint[] memory) {
 ```
 
-Nous pourrions obtenir le nombre de paramètres que nous avons à partir du calldata en lui-même, mais les fonctions qui nous appellent connaissent le nombre de paramètres qu'elles attendent. Il est plus facile de les laisser faire.
+Nous pourrions obtenir le nombre de paramètres à partir des données d'appel elles-mêmes, mais les fonctions qui nous appellent savent combien de paramètres elles attendent. Il est plus simple de les laisser nous le dire.
 
 ```solidity
-        // The parameters we read
+        // Les paramètres que nous lisons
         uint[] memory params = new uint[](_paramNum);
 
-        // Parameters start at byte 4, before that it's the function signature
+        // Les paramètres commencent à l'octet 4, avant cela se trouve la signature de la fonction
         uint _atByte = 4;
 
         for(uint i=0; i<_paramNum; i++) {
@@ -221,14 +218,14 @@ Nous pourrions obtenir le nombre de paramètres que nous avons à partir du call
         }
 ```
 
-Lisez les paramètres jusqu'à obtenir le nombre requis. Si nous dépassons la fin du calldata, `_readParams` annulera l'appel.
+Lisez les paramètres jusqu'à ce que vous ayez le nombre requis. Si nous dépassons la fin des données d'appel, `_readParams` annulera l'appel.
 
 ```solidity
 
         return(params);
     }   // readParams
 
-    // For testing _readParams, test reading four parameters
+    // Pour tester _readParams, on teste la lecture de quatre paramètres
     function fourParam() public
         returns (uint256,uint256,uint256,uint256)
     {
@@ -238,45 +235,45 @@ Lisez les paramètres jusqu'à obtenir le nombre requis. Si nous dépassons la f
     }    // fourParam
 ```
 
-Un grand avantage de Foundry est qu'il permet d'écrire des tests en Solidity ([voir le test du cache ci-dessous](#testing-the-cache)). Cela facilite grandement les tests unitaires. Voici une fonction qui lit quatre paramètres et les renvoie afin que le test puisse vérifier s'ils étaient corrects.
+Un grand avantage de Foundry est qu'il permet d'écrire des tests en Solidity ([voir Tester le cache ci-dessous](#testing-the-cache)). Cela facilite grandement les tests unitaires. Il s'agit d'une fonction qui lit quatre paramètres et les retourne pour que le test puisse vérifier s'ils étaient corrects.
 
 ```solidity
-    // Get a value, return bytes that will encode it (using the cache if possible)
+    // Obtenir une valeur, retourner les octets qui l'encoderont (en utilisant le cache si possible)
     function encodeVal(uint _val) public view returns(bytes memory) {
 ```
 
-`encodeVal` est une fonction qui appelle du code hors chaîne pour aider à créer des données d'appel qui utilisent le cache. Elle reçoit une seule valeur et renvoie les octets qui l'encodent. Cette fonction est une `lecture`, donc elle ne nécessite pas de transaction et lorsqu'elle est appelée de manière externe, elle ne coûte aucun gaz.
+`encodeVal` est une fonction que le code hors chaîne appelle pour aider à créer des données d'appel qui utilisent le cache. Elle reçoit une seule valeur et retourne les octets qui l'encodent. Cette fonction est une `vue`, elle ne nécessite donc pas de transaction et, lorsqu'elle est appelée de l'extérieur, ne coûte pas de gaz.
 
 ```solidity
         uint _key = val2key[_val];
 
-        // The value isn't in the cache yet, add it
+        // La valeur n'est pas encore dans le cache, on l'ajoute
         if (_key == 0)
             return bytes.concat(INTO_CACHE, bytes32(_val));
 ```
 
-Dans l'[EVM](/developers/docs/evm/), toute zone de stockage non initialisée est considérée comme valant zéro. Ainsi, si nous recherchons la clé d'une valeur qui n'existe pas, nous obtenons zéro. Dans ce cas, les octets qui l'encodent sont dans `INTO_CACHE` (afin qu'elle soit mise en cache la prochaine fois), suivis de la valeur réelle.
+Dans l'[EVM](/developers/docs/evm/), tout le stockage non initialisé est supposé être nul. Donc, si nous cherchons la clé d'une valeur qui n'est pas là, nous obtenons un zéro. Dans ce cas, les octets qui l'encodent sont `INTO_CACHE` (afin qu'elle soit mise en cache la prochaine fois), suivis de la valeur réelle.
 
 ```solidity
-        // If the key is <0x10, return it as a single byte
+        // Si la clé est <0x10, on la retourne comme un seul octet
         if (_key < 0x10)
             return bytes.concat(bytes1(uint8(_key)));
 ```
 
-Les simples octets sont les plus simples. Nous utilisons simplement [bytes.concat](https://docs.soliditylang.org/en/v0.8.16/types.html#the-functions-bytes-concat-and-string-concat) pour convertir un type `bytes` en un tableau d'octets de n'importe quelle longueur. Malgré le nom, cela fonctionne quand même lorsqu'un seul argument est fourni.
+Les octets uniques sont les plus simples. Nous utilisons simplement [`bytes.concat`](https://docs.soliditylang.org/en/v0.8.16/types.html#the-functions-bytes-concat-and-string-concat) pour transformer un type `bytes<n>` en un tableau d'octets de n'importe quelle longueur. Malgré son nom, cela fonctionne bien lorsqu'on ne lui fournit qu'un seul argument.
 
 ```solidity
-        // Two byte value, encoded as 0x1vvv
+        // Valeur sur deux octets, encodée comme 0x1vvv
         if (_key < 0x1000)
             return bytes.concat(bytes2(uint16(_key) | 0x1000));
 ```
 
-Lorsque nous avons une valeur inférieure à 16<sup>3,</sup> nous pouvons l'exprimer en seulement deux octets. Nous convertissons d'abord `_key`, qui est une valeur de 256 bits, en une valeur de 16 bits et utilisons un calcul logique pour ajouter le nombre d'octets au premier octet. Ensuite, nous le convertissons en une valeur `bytes2`, qui peut être convertie en `bytes`.
+Lorsque nous avons une clé inférieure à 16<sup>3</sup>, nous pouvons l'exprimer en deux octets. Nous convertissons d'abord `_key`, qui est une valeur de 256 bits, en une valeur de 16 bits et utilisons un OU logique pour ajouter le nombre d'octets supplémentaires au premier octet. Ensuite, nous la convertissons en une valeur `bytes2`, qui peut être convertie en `bytes`.
 
 ```solidity
-        // There is probably a clever way to do the following lines as a loop,
-        // but it's a view function so I'm optimizing for programmer time and
-        // simplicity.
+        // Il existe probablement une manière astucieuse de faire les lignes suivantes en boucle,
+        // mais c'est une fonction de vue, donc j'optimise le temps du programmeur et
+        // la simplicité.
 
         if (_key < 16*256**2)
             return bytes.concat(bytes3(uint24(_key) | (0x2 * 16 * 256**2)));
@@ -291,14 +288,14 @@ Lorsque nous avons une valeur inférieure à 16<sup>3,</sup> nous pouvons l'expr
             return bytes.concat(bytes16(uint128(_key) | (0xF * 16 * 256**15)));
 ```
 
-Les autres possibilités (3 octets, 4 octets, etc.) sont gérées de la même manière, mais avec des tailles de champ différentes.
+Les autres valeurs (3 octets, 4 octets, etc.) sont traitées de la même manière, mais avec des tailles de champ différentes.
 
 ```solidity
-        // If we get here, something is wrong.
-        revert("Error in encodeVal, should not happen");
+        // Si nous arrivons ici, quelque chose ne va pas.
+        revert("Erreur dans encodeVal, ne devrait pas se produire");
 ```
 
-Si nous en arrivons là, cela signifie que nous avons obtenu une valeur qui n'est pas inférieure à 16 * 256<sup>15</sup>. Mais `cacheWrite` limite les clés donc nous ne pouvons même pas atteindre 14\*256<sup>16</sup> (ce qui aurait un premier octet de 0xFE, donc cela ressemblerait à `DONT_CACHE`). Mais cela ne nous coûte pas beaucoup d'ajouter un test au cas où un futur programmeur introduirait un bug.
+Si nous arrivons ici, cela signifie que nous avons obtenu une clé qui n'est pas inférieure à 16\*256<sup>15</sup>. Mais `cacheWrite` limite les clés, donc nous ne pouvons même pas atteindre 14\*256<sup>16</sup> (ce qui donnerait un premier octet de 0xFE, et ressemblerait donc à `DONT_CACHE`). Mais cela ne coûte pas cher d'ajouter un test au cas où un futur programmeur introduirait un bogue.
 
 ```solidity
     } // encodeVal
@@ -308,7 +305,7 @@ Si nous en arrivons là, cela signifie que nous avons obtenu une valeur qui n'es
 
 ### Tester le cache {#testing-the-cache}
 
-L'un des avantages de Foundry est qu'[il vous permet d'écrire des tests en Solidity](https://book.getfoundry.sh/forge/tests), ce qui facilite l'écriture de tests de type. Les tests pour la classe `Cache` se trouvent [ici](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/Cache.t.sol). Comme le code de test est répétitif, comme c'est souvent le cas avec les tests, cet article n'explique que les parties utiles.
+L'un des avantages de Foundry est qu'[il permet d'écrire des tests en Solidity](https://getfoundry.sh/forge/tests/overview/), ce qui facilite l'écriture de tests unitaires. Les tests pour la classe `Cache` sont [ici](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/Cache.t.sol). Le code de test étant répétitif, comme c'est souvent le cas, cet article n'explique que les parties intéressantes.
 
 ```solidity
 // SPDX-License-Identifier: UNLICENSED
@@ -317,17 +314,17 @@ pragma solidity ^0.8.13;
 import "forge-std/Test.sol";
 
 
-// Need to run `forge test -vv` for the console.
+// Il faut lancer `forge test -vv` pour la console.
 import "forge-std/console.sol";
 ```
 
-Il s'agit simplement d'un passe-partout nécessaire pour utiliser le package de test et `console.log`.
+Ceci est juste du code standard nécessaire pour utiliser le paquet de test et `console.log`.
 
 ```solidity
 import "src/Cache.sol";
 ```
 
-Nous avons besoin de connaître le contrat que nous testons.
+Nous devons connaître le contrat que nous testons.
 
 ```solidity
 contract CacheTest is Test {
@@ -344,7 +341,7 @@ La fonction `setUp` est appelée avant chaque test. Dans ce cas, nous créons si
     function testCaching() public {
 ```
 
-Les tests sont des fonctions dont les noms commencent par `test`. Cette fonction vérifie la fonctionnalité de base du cache, en écrivant des valeurs puis en les lisant à nouveau.
+Les tests sont des fonctions dont le nom commence par `test`. Cette fonction vérifie la fonctionnalité de base du cache, en écrivant des valeurs et en les relisant.
 
 ```solidity
         for(uint i=1; i<5000; i++) {
@@ -355,15 +352,15 @@ Les tests sont des fonctions dont les noms commencent par `test`. Cette fonction
             assertEq(cache.cacheRead(i), i*i);
 ```
 
-C'est ainsi que vous effectuez les tests réels en utilisant [ les fonctions `assert...`](https://book.getfoundry.sh/reference/forge-std/std-assertions). Dans ce cas, nous vérifions que la valeur que nous avons écrite est celle que nous avons lue. Nous pouvons ignorer le résultat de `cache.cacheWrite` car nous savons que les valeurs de cache sont assignées linéairement.
+C'est ainsi que vous effectuez les tests réels, en utilisant les [`fonctions assert...`](https://getfoundry.sh/reference/forge-std/std-assertions/). Dans ce cas, nous vérifions que la valeur que nous avons écrite est bien celle que nous avons lue. Nous pouvons ignorer le résultat de `cache.cacheWrite` car nous savons que les clés de cache sont attribuées de manière linéaire.
 
 ```solidity
         }
     }    // testCaching
 
 
-    // Cache the same value multiple times, ensure that the key stays
-    // the same
+    // Mettre en cache la même valeur plusieurs fois, s'assurer que la clé reste
+    // la même
     function testRepeatCaching() public {
         for(uint i=1; i<100; i++) {
             uint _key1 = cache.cacheWrite(i);
@@ -372,7 +369,7 @@ C'est ainsi que vous effectuez les tests réels en utilisant [ les fonctions `as
         }
 ```
 
-Tout d'abord, nous écrivons chaque valeur deux fois dans le cache et nous nous assurons que les valeurs sont les mêmes (ce qui signifie que la deuxième écriture ne s'est pas réellement produite).
+D'abord, nous écrivons chaque valeur deux fois dans le cache et nous nous assurons que les clés sont les mêmes (ce qui signifie que la deuxième écriture n'a pas vraiment eu lieu).
 
 ```solidity
         for(uint i=1; i<100; i+=3) {
@@ -382,16 +379,16 @@ Tout d'abord, nous écrivons chaque valeur deux fois dans le cache et nous nous
     }    // testRepeatCaching
 ```
 
-En théorie, il pourrait y avoir un bug qui n'affecte pas les écritures consécutives dans le cache. Ici, nous effectuons donc quelques écritures qui ne sont pas consécutives et vérifions que les valeurs ne sont toujours pas réécrites.
+En théorie, il pourrait y avoir un bogue qui n'affecte pas les écritures consécutives dans le cache. Ici, nous effectuons donc des écritures non consécutives et nous voyons que les valeurs ne sont toujours pas réécrites.
 
 ```solidity
-    // Read a uint from a memory buffer (to make sure we get back the parameters
-    // we sent out)
+    // Lire un uint à partir d'un tampon mémoire (pour s'assurer de récupérer les paramètres
+    // que nous avons envoyés)
     function toUint256(bytes memory _bytes, uint256 _start) internal pure
         returns (uint256)
 ```
 
-Lire un mot de 256 bits à partir de la `mémoire tampon de bytes`. Cette fonction utilitaire nous permet de vérifier que nous obtenons les résultats corrects lorsque nous exécutons un appel de fonction qui utilise le cache.
+Lire un mot de 256 bits à partir d'un tampon `bytes memory`. Cette fonction utilitaire nous permet de vérifier que nous recevons les résultats corrects lorsque nous exécutons un appel de fonction qui utilise le cache.
 
 ```solidity
     {
@@ -403,18 +400,18 @@ Lire un mot de 256 bits à partir de la `mémoire tampon de bytes`. Cette foncti
         }
 ```
 
-Yul ne prend pas en charge les structures de données plus avancées que `uint256`, ainsi lorsque vous faites référence à une structure de données plus sophistiquée, telle que la mémoire tampon `_bytes`, vous obtenez l'adresse de cette structure. Solidity stocke les valeurs de `bytes memory` sous la forme d'un mot de 32 octets qui contient la longueur, suivie des octets réels. Par conséquent, pour obtenir l'octet numéro `_start`, nous devons calculer `_bytes+32+_start`.
+Yul ne prend pas en charge les structures de données au-delà de `uint256`, donc lorsque vous faites référence à une structure de données plus sophistiquée, telle que le tampon mémoire `_bytes`, vous obtenez l'adresse de cette structure. Solidity stocke les valeurs `bytes memory` sous la forme d'un mot de 32 octets qui contient la longueur, suivi des octets réels. Pour obtenir l'octet numéro `_start`, nous devons donc calculer `_bytes+32+_start`.
 
 ```solidity
 
         return tempUint;
     }     // toUint256
 
-    // Function signature for fourParams(), courtesy of
+    // Signature de la fonction pour fourParams(), grâce à
     // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d
     bytes4 constant FOUR_PARAMS = 0x3edc1e6d;
 
-    // Just some constant values to see we're getting the correct values back
+    // Juste quelques valeurs constantes pour voir si nous obtenons les bonnes valeurs en retour
     uint256 constant VAL_A = 0xDEAD60A7;
     uint256 constant VAL_B =     0xBEEF;
     uint256 constant VAL_C =     0x600D;
@@ -427,7 +424,7 @@ Quelques constantes dont nous avons besoin pour les tests.
     function testReadParam() public {
 ```
 
-Utilisez `fourParams()`, une fonction qui utilise `readParams`, pour tester si nous pouvons lire correctement les paramètres.
+Appelez `fourParams()`, une fonction qui utilise `readParams`, pour tester que nous pouvons lire les paramètres correctement.
 
 ```solidity
         address _cacheAddr = address(cache);
@@ -436,23 +433,23 @@ Utilisez `fourParams()`, une fonction qui utilise `readParams`, pour tester si n
         bytes memory _callOutput;
 ```
 
-Nous ne pouvons pas utiliser le mécanisme ABI normal pour appeler une fonction en utilisant le cache, nous devons donc utiliser le mécanisme [`<address>.call()`](https://docs.soliditylang.org/en/v0.8.16/types.html#members-of-addresses) de bas niveau. Ce mécanisme prend une `mémoire bytes` en entrée et renvoie celle-ci (ainsi qu'une valeur booléenne) en sortie.
+Nous ne pouvons pas utiliser le mécanisme ABI normal pour appeler une fonction en utilisant le cache, nous devons donc utiliser le mécanisme de bas niveau [`<address>.call()`](https://docs.soliditylang.org/en/v0.8.16/types.html#members-of-addresses). Ce mécanisme prend un `bytes memory` en entrée et le retourne (ainsi qu'une valeur booléenne) en sortie.
 
 ```solidity
-        // First call, the cache is empty
+        // Premier appel, le cache est vide
         _callInput = bytes.concat(
             FOUR_PARAMS,
 ```
 
-Il est utile que le même contrat prenne en charge à la fois les fonctions mises en cache (pour les appels directement à partir de transactions) et les fonctions non mises en cache (pour les appels à partir d'autres contrats intelligents). Pour ce faire, nous devons continuer à nous appuyer sur le mécanisme Solidity pour appeler la bonne fonction, au lieu de tout mettre dans une [`fonction de repli`](https://docs.soliditylang.org/en/v0.8.16/contracts.html#fallback-function). Cela rend la composabilité beaucoup plus facile. Un seul octet serait suffisant pour identifier la fonction dans la plupart des cas, nous gaspillons donc trois octets (16\*3=48 gaz). Cependant, au moment où j'écris cela, ces 48 gaz coûtent 0,07 cent, ce qui est un coût raisonnable pour un code plus simple et moins sujet aux bugs.
+Il est utile que le même contrat prenne en charge à la fois les fonctions mises en cache (pour les appels directement depuis les transactions) et les fonctions non mises en cache (pour les appels depuis d'autres contrats intelligents). Pour ce faire, nous devons continuer à nous appuyer sur le mécanisme de Solidity pour appeler la bonne fonction, au lieu de tout mettre dans [une fonction de repli (`fallback`)](https://docs.soliditylang.org/en/v0.8.16/contracts.html#fallback-function). Cela rend la composabilité beaucoup plus facile. Un seul octet suffirait pour identifier la fonction dans la plupart des cas, nous gaspillons donc trois octets (16\*3=48 gaz). Cependant, au moment où j'écris ces lignes, ces 48 gaz coûtent 0,07 centime, ce qui est un coût raisonnable pour un code plus simple et moins sujet aux bogues.
 
 ```solidity
-            // First value, add it to the cache
+            // Première valeur, on l'ajoute au cache
             cache.INTO_CACHE(),
             bytes32(VAL_A),
 ```
 
-La première valeur : un indicateur indiquant qu'il s'agit d'une valeur qui doit être écrite en entier dans le cache, suivie de ses 32 octets. Les trois autres valeurs sont similaires, sauf que `VAL_B` n'est pas écrite dans le cache et que `VAL_C` est à la fois le troisième paramètre et le quatrième.
+La première valeur : un indicateur signalant qu'il s'agit d'une valeur complète qui doit être écrite dans le cache, suivi des 32 octets de la valeur. Les trois autres valeurs sont similaires, sauf que `VAL_B` n'est pas écrit dans le cache et que `VAL_C` est à la fois le troisième et le quatrième paramètre.
 
 ```solidity
              .
@@ -468,14 +465,14 @@ C'est ici que nous appelons réellement le contrat `Cache`.
         assertEq(_success, true);
 ```
 
-Nous nous attendons à ce que l'appel soit réussi.
+Nous nous attendons à ce que l'appel réussisse.
 
 ```solidity
         assertEq(cache.cacheRead(1), VAL_A);
         assertEq(cache.cacheRead(2), VAL_C);
 ```
 
-Nous commençons avec un cache vide, puis ajoutons `VAL_A` suivi de `VAL_C`. Nous nous attendrions à ce que le premier ait la valeur 1 et le second la valeur 2.
+Nous commençons avec un cache vide, puis nous ajoutons `VAL_A` suivi de `VAL_C`. Nous nous attendons à ce que le premier ait la clé 1 et le second la clé 2.
 
 ```
         assertEq(toUint256(_callOutput,0), VAL_A);
@@ -484,32 +481,31 @@ Nous commençons avec un cache vide, puis ajoutons `VAL_A` suivi de `VAL_C`. Nou
         assertEq(toUint256(_callOutput,96), VAL_C);
 ```
 
-Le résultat est composé des quatre paramètres. Ici, nous vérifions qu'il est correct.
+La sortie correspond aux quatre paramètres. Ici, nous vérifions qu'elle est correcte.
 
 ```solidity
-        // Second call, we can use the cache
+        // Deuxième appel, nous pouvons utiliser le cache
         _callInput = bytes.concat(
             FOUR_PARAMS,
 
-            // First value in the Cache
+            // Première valeur dans le cache
             bytes1(0x01),
 ```
 
-Les clés de cache inférieures à 16 ne représentent qu'un octet.
+Les clés de cache inférieures à 16 ne représentent qu'un seul octet.
 
 ```solidity
-            // Second value, don't add it to the cache
+            // Deuxième valeur, ne pas l'ajouter au cache
             cache.DONT_CACHE(),
             bytes32(VAL_B),
 
-            // Third and fourth values, same value
+            // Troisième et quatrième valeurs, même valeur
             bytes1(0x02),
             bytes1(0x02)
         );
         .
         .
         .
-    }   // testReadParam
 ```
 
 Les tests après l'appel sont identiques à ceux après le premier appel.
@@ -518,7 +514,7 @@ Les tests après l'appel sont identiques à ceux après le premier appel.
     function testEncodeVal() public {
 ```
 
-Cette fonction est similaire à `testReadParam`, à la différence près que nous utilisons `encodeVal()` au lieu d'écrire explicitement les paramètres.
+Cette fonction est similaire à `testReadParam`, sauf qu'au lieu d'écrire les paramètres explicitement, nous utilisons `encodeVal()`.
 
 ```solidity
         .
@@ -538,23 +534,23 @@ Cette fonction est similaire à `testReadParam`, à la différence près que nou
     }   // testEncodeVal
 ```
 
-Le seul test supplémentaire dans `testEncodeVal()` consiste à vérifier que la longueur de `_callInput` est correcte. Pour le premier appel, elle est de 4+33\*4. Pour le deuxième, où chaque valeur est déjà dans le cache, elle est de 4+1\*4.
+Le seul test supplémentaire dans `testEncodeVal()` consiste à vérifier que la longueur de `_callInput` est correcte. Pour le premier appel, elle est de 4+33*4. Pour le second, où chaque valeur est déjà dans le cache, elle est de 4+1*4.
 
 ```solidity
-    // Test encodeVal when the key is more than a single byte
-    // Maximum three bytes because filling the cache to four bytes takes
-    // too long.
+    // Tester encodeVal lorsque la clé fait plus d'un seul octet
+    // Maximum trois octets, car remplir le cache jusqu'à quatre octets prend
+    // trop de temps.
     function testEncodeValBig() public {
-        // Put a number of values in the cache.
-        // To keep things simple, use key n for value n.
+        // Mettre un certain nombre de valeurs dans le cache.
+        // Pour rester simple, utiliser la clé n pour la valeur n.
         for(uint i=1; i<0x1FFF; i++) {
             cache.cacheWrite(i);
         }
 ```
 
-La fonction `testEncodeVal` ci-dessus ne stocke que quatre valeurs dans le cache, donc [la partie de la fonction qui traite des valeurs multi-octets](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol#L144-L171) n'est pas vérifiée. Mais ce code est compliqué et particulièrement sujet aux erreurs.
+La fonction `testEncodeVal` ci-dessus n'écrit que quatre valeurs dans le cache, donc [la partie de la fonction qui traite les valeurs multi-octets](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol#L144-L171) n'est pas vérifiée. Mais ce code est compliqué et sujet aux erreurs.
 
-La première partie de cette fonction est une boucle qui écrit toutes les valeurs de 1 à 0x1FFF dans le cache en ordre, afin que nous puissions encoder ces valeurs et savoir où elles iront.
+La première partie de cette fonction est une boucle qui écrit toutes les valeurs de 1 à 0x1FFF dans le cache, dans l'ordre, afin que nous puissions encoder ces valeurs et savoir où elles vont.
 
 ```solidity
         .
@@ -563,14 +559,14 @@ La première partie de cette fonction est une boucle qui écrit toutes les valeu
 
         _callInput = bytes.concat(
             FOUR_PARAMS,
-            cache.encodeVal(0x000F),   // One byte        0x0F
-            cache.encodeVal(0x0010),   // Two bytes     0x1010
-            cache.encodeVal(0x0100),   // Two bytes     0x1100
-            cache.encodeVal(0x1000)    // Three bytes 0x201000
+            cache.encodeVal(0x000F),   // Un octet        0x0F
+            cache.encodeVal(0x0010),   // Deux octets     0x1010
+            cache.encodeVal(0x0100),   // Deux octets     0x1100
+            cache.encodeVal(0x1000)    // Trois octets 0x201000
         );
 ```
 
-Testez des valeurs d'un octet, de deux octets et de trois octets. Nous n'allons pas au-delà car cela prendrait trop de temps pour écrire suffisamment d'entrées dans la pile (au moins 0x10000000, soit environ un quart de milliard).
+Testez les valeurs d'un, deux et trois octets. Nous ne testons pas au-delà car cela prendrait trop de temps pour écrire suffisamment d'entrées dans la pile (au moins 0x10000000, soit environ un quart de milliard).
 
 ```solidity
         .
@@ -580,11 +576,11 @@ Testez des valeurs d'un octet, de deux octets et de trois octets. Nous n'allons
     }    // testEncodeValBig
 
 
-    // Test what with an excessively small buffer we get a revert
+    // Tester qu'avec un tampon excessivement petit, nous obtenons une annulation
     function testShortCalldata() public {
 ```
 
-Testez ce qui se passe dans le cas anormal où il n'y a pas suffisamment de paramètres.
+Testez ce qui se passe dans le cas anormal où il n'y a pas assez de paramètres.
 
 ```solidity
         .
@@ -595,10 +591,10 @@ Testez ce qui se passe dans le cas anormal où il n'y a pas suffisamment de para
     }   // testShortCalldata
 ```
 
-Puisqu'il revient, le résultat que nous devrions obtenir est `false`.
+Puisqu'il y a annulation, le résultat que nous devrions obtenir est `false`.
 
 ```
-    // Call with cache keys that aren't there
+    // Appeler avec des clés de cache qui ne sont pas là
     function testNoCacheKey() public {
         .
         .
@@ -606,52 +602,52 @@ Puisqu'il revient, le résultat que nous devrions obtenir est `false`.
         _callInput = bytes.concat(
             FOUR_PARAMS,
 
-            // First value, add it to the cache
+            // Première valeur, l'ajouter au cache
             cache.INTO_CACHE(),
             bytes32(VAL_A),
 
-            // Second value
+            // Deuxième valeur
             bytes1(0x0F),
             bytes2(0x1234),
             bytes11(0xA10102030405060708090A)
         );
 ```
 
-Cette fonction obtient quatre paramètres parfaitement légitimes, à l'exception du fait que le cache est vide, il n'y a donc aucune valeur à lire.
+Cette fonction reçoit quatre paramètres parfaitement légitimes, sauf que le cache est vide, donc il n'y a aucune valeur à lire.
 
 ```solidity
         .
         .
         .
-    // Test what with an excessively long buffer everything works file
+    // Tester qu'avec un tampon excessivement long tout fonctionne
     function testLongCalldata() public {
         address _cacheAddr = address(cache);
         bool _success;
         bytes memory _callInput;
         bytes memory _callOutput;
 
-        // First call, the cache is empty
+        // Premier appel, le cache est vide
         _callInput = bytes.concat(
             FOUR_PARAMS,
 
-            // First value, add it to the cache
+            // Première valeur, l'ajouter au cache
             cache.INTO_CACHE(), bytes32(VAL_A),
 
-            // Second value, add it to the cache
+            // Deuxième valeur, l'ajouter au cache
             cache.INTO_CACHE(), bytes32(VAL_B),
 
-            // Third value, add it to the cache
+            // Troisième valeur, l'ajouter au cache
             cache.INTO_CACHE(), bytes32(VAL_C),
 
-            // Fourth value, add it to the cache
+            // Quatrième valeur, l'ajouter au cache
             cache.INTO_CACHE(), bytes32(VAL_D),
 
-            // And another value for "good luck"
+            // Et une autre valeur pour la « bonne chance »
             bytes4(0x31112233)
         );
 ```
 
-Cette fonction envoie cinq valeurs. Nous savons que la cinquième valeur est ignorée car ce n'est pas une entrée de cache valide, ce qui aurait provoqué un rejet si elle n'avait pas été incluse.
+Cette fonction envoie cinq valeurs. Nous savons que la cinquième valeur est ignorée car ce n'est pas une entrée de cache valide, ce qui aurait provoqué une annulation si elle n'avait pas été incluse.
 
 ```solidity
         (_success, _callOutput) = _cacheAddr.call(_callInput);
@@ -665,13 +661,13 @@ Cette fonction envoie cinq valeurs. Nous savons que la cinquième valeur est ign
 
 ```
 
-## Exemple d'application {#a-sample-app}
+## Un exemple d'application {#a-sample-app}
 
-Écrire des tests en Solidity c'est très bien, mais en fin de compte, une DApp doit être capable de traiter les demandes venant de la chaîne pour être utile. Cet article montre comment utiliser la mise en cache dans une DApp avec `WORM`, qui signifie « Écrire Une Fois, Lire Plusieurs fois » (en anglais "Write Once, Read Many"). Si une clé n'a pas encore été assignée, vous pouvez y écrire une valeur. Si la clé a déjà été assignée, cela annule l'écriture.
+Écrire des tests en Solidity est très bien, mais au final, une dapp doit être capable de traiter des requêtes provenant de l'extérieur de la chaîne pour être utile. Cet article montre comment utiliser la mise en cache dans une dapp avec `WORM`, qui signifie « Write Once, Read Many » (Écrire une fois, lire plusieurs fois). Si une clé n'est pas encore écrite, vous pouvez y écrire une valeur. Si la clé est déjà écrite, vous obtenez une annulation.
 
 ### Le contrat {#the-contract}
 
-[Voici le contrat](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/WORM.sol). Cela répète en grande partie ce que nous avons déjà fait avec `Cache` et `CacheTest`, nous nous concentrons donc uniquement sur les parties intéressantes.
+[Voici le contrat](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/WORM.sol). Il répète en grande partie ce que nous avons déjà fait avec `Cache` et `CacheTest`, nous ne couvrirons donc que les parties intéressantes.
 
 ```solidity
 import "./Cache.sol";
@@ -688,29 +684,29 @@ La manière la plus simple d'utiliser `Cache` est de l'hériter dans notre propr
     }    // writeEntryCached
 ```
 
-Cette fonction est similaire à `fourParam` dans `CacheTest` ci-dessus. Comme nous ne suivons pas les spécifications ABI, il est préférable de ne pas déclarer de paramètres dans la fonction.
+Cette fonction est similaire à `fourParam` dans `CacheTest` ci-dessus. Comme nous ne suivons pas les spécifications de l'ABI, il est préférable de ne déclarer aucun paramètre dans la fonction.
 
 ```solidity
-    // Make it easier to call us
-    // Function signature for writeEntryCached(), courtesy of
+    // Pour faciliter les appels
+    // Signature de la fonction pour writeEntryCached(), grâce à
     // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3
     bytes4 constant public WRITE_ENTRY_CACHED = 0xe4e4f2d3;
 ```
 
-Le code externe qui appelle `writeEntryCached` devra construire manuellement les données d'appel, au lieu d'utiliser `worm.writeEntryCached`, car nous ne suivons pas les spécifications ABI. Avoir cette valeur constante rend plus facile son écriture.
+Le code externe qui appelle `writeEntryCached` devra construire manuellement les données d'appel, au lieu d'utiliser `worm.writeEntryCached`, car nous ne suivons pas les spécifications de l'ABI. Avoir cette valeur constante facilite simplement son écriture.
 
-Notez que même si nous définissons `WRITE_ENTRY_CACHED` comme une variable d'état, pour la lire de l'extérieur, il est nécessaire d'utiliser la fonction getter pour cela, `worm.WRITE_ENTRY_CACHED()`.
+Notez que même si nous définissons `WRITE_ENTRY_CACHED` comme une variable d'état, pour la lire de l'extérieur, il est nécessaire d'utiliser sa fonction d'accès, `worm.WRITE_ENTRY_CACHED()`.
 
 ```solidity
     function readEntry(uint key) public view
         returns (uint _value, address _writtenBy, uint _writtenAtBlock)
 ```
 
-La fonction de lecture est en `lecture`, elle ne nécessite donc pas de transaction et ne coûte pas de gaz. En conséquence, il n'y a aucun avantage à utiliser le cache pour le paramètre. Avec les fonctions de type en lecture, il est préférable d'utiliser le mécanisme standard qui est plus simple.
+La fonction de lecture est une `vue`, elle ne nécessite donc pas de transaction et ne coûte pas de gaz. Par conséquent, il n'y a aucun avantage à utiliser le cache pour le paramètre. Avec les fonctions de vue, il est préférable d'utiliser le mécanisme standard qui est plus simple.
 
-### Code de test {#the-testing-code}
+### Le code de test {#the-testing-code}
 
-[Voici le code de test pour le contrat](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/WORM.t.sol). Encore une fois, regardons uniquement ce qui est intéressant.
+[Voici le code de test du contrat](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/WORM.t.sol). Encore une fois, ne regardons que ce qui est intéressant.
 
 ```solidity
     function testWReadWrite() public {
@@ -720,27 +716,27 @@ La fonction de lecture est en `lecture`, elle ne nécessite donc pas de transact
         worm.writeEntry(0xDEAD, 0xBEEF);
 ```
 
-[Ceci (`vm.expectRevert`)](https://book.getfoundry.sh/cheatcodes/expect-revert#expectrevert) est la façon dont nous spécifions dans un test Foundry que le prochain appel devrait échouer, et la raison de cet échec. Cela s'applique lorsque nous utilisons la syntaxe `<contract>.<nom de la fonction>()` plutôt que de construire les données d'appel et d'appeler le contrat en utilisant l'interface de bas niveau (`<contract>.call()`, etc.).
+[Ceci (`vm.expectRevert`)](https://book.getfoundry.sh/cheatcodes/expect-revert#expectrevert) est la façon dont nous spécifions dans un test Foundry que l'appel suivant doit échouer, ainsi que la raison de l'échec. Cela s'applique lorsque nous utilisons la syntaxe `<contract>.<function name>()` plutôt que de construire les données d'appel et d'appeler le contrat en utilisant l'interface de bas niveau (`<contract>.call()`, etc.).
 
 ```solidity
     function testReadWriteCached() public {
         uint cacheGoat = worm.cacheWrite(0x60A7);
 ```
 
-Ici, nous utilisons le fait que `cacheWrite` renvoie la clé du cache. Ce n'est pas quelque chose que nous prévoyons d'utiliser en production, car `cacheWrite` modifie l'état, et ne peut donc être appelé que lors d'une transaction. Les transactions n'ont pas de valeurs de retour, si elles ont des résultats, ces résultats sont censés être émis sous forme d'événements. Ainsi, la valeur de retour de `cacheWrite` n'est accessible qu'à partir du code sur la chaîne, et le code sur la chaîne n'a pas besoin de mise en cache des paramètres.
+Ici, nous utilisons le fait que `cacheWrite` retourne la clé du cache. Ce n'est pas quelque chose que nous nous attendrions à utiliser en production, car `cacheWrite` modifie l'état, et ne peut donc être appelé que lors d'une transaction. Les transactions n'ont pas de valeurs de retour ; si elles ont des résultats, ces derniers sont censés être émis sous forme d'événements. La valeur de retour de `cacheWrite` n'est donc accessible qu'à partir du code en chaîne, et le code en chaîne n'a pas besoin de mise en cache des paramètres.
 
 ```solidity
         (_success,) = address(worm).call(_callInput);
 ```
 
-C'est ainsi que nous indiquons à Solidity que, bien que `<contract address>.call()` ait deux valeurs de retour, nous ne nous préoccupons que de la première.
+C'est ainsi que nous indiquons à Solidity que, bien que `<contract address>.call()` ait deux valeurs de retour, nous ne nous intéressons qu'à la première.
 
 ```solidity
         (_success,) = address(worm).call(_callInput);
         assertEq(_success, false);
 ```
 
-Puisque nous utilisons la fonction de bas niveau `<address>.call()`, nous ne pouvons pas utiliser `vm.expectRevert()` et devons regarder la valeur de résultat booléen que nous obtenons de l'appel.
+Puisque nous utilisons la fonction de bas niveau `<address>.call()`, nous ne pouvons pas utiliser `vm.expectRevert()` et devons regarder la valeur de succès booléenne que nous obtenons de l'appel.
 
 ```solidity
     event EntryWritten(uint indexed key, uint indexed value);
@@ -756,21 +752,21 @@ Puisque nous utilisons la fonction de bas niveau `<address>.call()`, nous ne pou
         (_success,) = address(worm).call(_callInput);
 ```
 
-C'est ainsi que nous vérifions que le code [émet correctement un événement](https://book.getfoundry.sh/cheatcodes/expect-emit) dans Foundry.
+C'est la manière de vérifier que le code [émet un événement correctement](https://getfoundry.sh/reference/cheatcodes/expect-emit/) dans Foundry.
 
 ### Le client {#the-client}
 
-Une chose que vous n'obtenez pas avec les tests Solidity, c'est du code JavaScript que vous pouvez couper et coller dans votre propre application. Pour écrire ce code, j'ai déployé WORM sur [Optimism Goerli](https://community.optimism.io/docs/useful-tools/networks/#optimism-goerli), le nouveau réseau de test d'[Optimism](https://www.optimism.io/). Il se trouve à l'adresse [`0xd34335b1d818cee54e3323d3246bd31d94e6a78a`](https://goerli-optimism.etherscan.io/address/0xd34335b1d818cee54e3323d3246bd31d94e6a78a).
+Une chose que vous n'obtenez pas avec les tests Solidity, c'est du code JavaScript que vous pouvez copier et coller dans votre propre application. Pour écrire ce code, j'ai déployé WORM sur [Optimism Goerli](https://community.optimism.io/docs/useful-tools/networks/#optimism-goerli), le nouveau réseau de test d'[Optimism](https://www.optimism.io/). Il se trouve à l'adresse [`0xd34335b1d818cee54e3323d3246bd31d94e6a78a`](https://goerli-optimism.etherscan.io/address/0xd34335b1d818cee54e3323d3246bd31d94e6a78a).
 
-[Vous pouvez voir le code JavaScript pour le client ici](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/javascript/index.js). Pour l'utiliser :
+[Vous pouvez voir le code JavaScript pour le client ici](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/javascript/index.js). Pour l'utiliser :
 
-1. Clonez le dépôt git :
+1. Clonez le dépôt git :
 
    ```sh
    git clone https://github.com/qbzzt/20220915-all-you-can-cache.git
    ```
 
-2. Installez les packages nécessaires :
+2. Installez les paquets nécessaires :
 
    ```sh
    cd javascript
@@ -785,10 +781,10 @@ Une chose que vous n'obtenez pas avec les tests Solidity, c'est du code JavaScri
 
 4. Modifiez `.env` selon votre configuration :
 
-   | Paramètre             | Valeur                                                                                                                                                                                          |
-   | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-   | MNEMONIC              | La mnémonique d'un compte qui dispose de suffisamment d'ETH pour payer une transaction. [Vous pouvez obtenir de l'ETH gratuit pour le réseau Optimism Goerli ici](https://optimismfaucet.xyz/). |
-   | OPTIMISM_GOERLI_URL | URL vers Optimism Goerli. Le point de terminaison public, `https://goerli.optimism.io`, est à débit limité mais suffisant pour ce dont nous avons besoin ici                                    |
+   | Paramètre                                                     | Valeur                                                                                                                                                                                                                          |
+   | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+   | MNEMONIC                                                      | La mnémonique d'un compte qui dispose de suffisamment d'ETH pour payer une transaction. [Vous pouvez obtenir de l'ETH gratuit pour le réseau Optimism Goerli ici](https://optimismfaucet.xyz/). |
+   | OPTIMISM_GOERLI_URL | URL vers Optimism Goerli. Le point de terminaison public, `https://goerli.optimism.io`, a un débit limité mais suffisant pour ce dont nous avons besoin ici.                                    |
 
 5. Exécutez `index.js`.
 
@@ -796,9 +792,9 @@ Une chose que vous n'obtenez pas avec les tests Solidity, c'est du code JavaScri
    node index.js
    ```
 
-   Cet exemple d'application écrit d'abord une entrée dans WORM, affichant les données d'appel et un lien vers la transaction sur Etherscan. Ensuite, elle lit cette entrée, affiche la clé qu'elle utilise et les valeurs de l'entrée (valeur, numéro de bloc et auteur).
+   Cet exemple d'application écrit d'abord une entrée dans WORM, en affichant les données d'appel et un lien vers la transaction sur Etherscan. Ensuite, il relit cette entrée et affiche la clé qu'il utilise et les valeurs de l'entrée (valeur, numéro de bloc et auteur).
 
-La plupart des clients sont du JavaScript Dapp normal. Donc, encore une fois, nous ne passerons en revue que les parties intéressantes.
+La plupart du client est du JavaScript de Dapp normal. Donc, encore une fois, nous ne passerons en revue que les parties intéressantes.
 
 ```javascript
 .
@@ -807,20 +803,20 @@ La plupart des clients sont du JavaScript Dapp normal. Donc, encore une fois, no
 const main = async () => {
     const func = await worm.WRITE_ENTRY_CACHED()
 
-    // Need a new key every time
+    // Il faut une nouvelle clé à chaque fois
     const key = await worm.encodeVal(Number(new Date()))
 ```
 
-Un emplacement donné ne peut être écrit qu'une seule fois, donc nous utilisons l'horodatage pour nous assurer que nous ne réutilisons pas les emplacements.
+Un emplacement donné ne peut être écrit qu'une seule fois, nous utilisons donc l'horodatage pour nous assurer de ne pas réutiliser les emplacements.
 
 ```javascript
 const val = await worm.encodeVal("0x600D")
 
-// Write an entry
+// Écrire une entrée
 const calldata = func + key.slice(2) + val.slice(2)
 ```
 
-Ethers s'attend à ce que les données d'appel soient une chaîne hexadécimale, `0x` suivie d'un nombre pair de chiffres hexadécimaux. Comme `key` et `val` commencent tous les deux par `0x`, nous devons supprimer ces en-têtes.
+Ethers s'attend à ce que les données d'appel soient une chaîne hexadécimale, `0x` suivi d'un nombre pair de chiffres hexadécimaux. Comme `key` et `val` commencent tous les deux par `0x`, nous devons supprimer ces en-têtes.
 
 ```javascript
 const tx = await worm.populateTransaction.writeEntryCached()
@@ -829,14 +825,14 @@ tx.data = calldata
 sentTx = await wallet.sendTransaction(tx)
 ```
 
-Comme pour le code de test Solidity, nous ne pouvons normalement pas appeler une fonction de mise en cache. Au lieu de cela, nous devons utiliser un mécanisme de bas niveau.
+Comme pour le code de test Solidity, nous ne pouvons pas appeler une fonction mise en cache normalement. À la place, nous devons utiliser un mécanisme de plus bas niveau.
 
 ```javascript
     .
     .
     .
-    // Read the entry just written
-    const realKey = '0x' + key.slice(4)  // remove the FF flag
+    // Lire l'entrée qui vient d'être écrite
+    const realKey = '0x' + key.slice(4)  // supprimer l'indicateur FF
     const entryRead = await worm.readEntry(realKey)
     .
     .
@@ -847,21 +843,24 @@ Pour lire les entrées, nous pouvons utiliser le mécanisme normal. Il n'est pas
 
 ## Conclusion {#conclusion}
 
-Le code dans cet article est une preuve de concept, le but étant de rendre l'idée facile à comprendre. Pour un système exploitable, vous devriez peut-être mettre en œuvre certaines fonctionnalités supplémentaires :
+Le code de cet article est une preuve de concept, le but est de rendre l'idée facile à comprendre. Pour un système prêt pour la production, vous pourriez vouloir implémenter des fonctionnalités supplémentaires :
 
-- Gérer les valeurs qui ne sont pas de type `uint256`. Par exemple, les chaines de caractères.
-- Au lieu d'un cache global, peut-être avoir une correspondance entre les utilisateurs et les caches. Différents utilisateurs utilisent différentes valeurs.
+- Gérer les valeurs qui ne sont pas de type `uint256`. Par exemple, des chaînes de caractères.
+- Au lieu d'un cache global, vous pourriez avoir une correspondance entre les utilisateurs et les caches. Différents utilisateurs utilisent des valeurs différentes.
 - Les valeurs utilisées pour les adresses sont distinctes de celles utilisées à d'autres fins. Il pourrait être judicieux d'avoir un cache séparé uniquement pour les adresses.
-- Actuellement, les clés de cache fonctionnent selon un algorithme « premier arrivé, clé la plus petite ». Les seize premières valeurs peuvent être envoyées en un seul octet. Les 4080 valeurs suivantes peuvent être envoyées en deux octets. Le million de valeurs suivant est de trois octets, etc. Un système de production doit conserver les compteurs d'utilisation sur les entrées du cache et les réorganiser de manière à ce que les seize valeurs _les plus courantes_ soient sur un octet, les 4 080 valeurs les plus courantes suivantes sur deux octets, etc.
+- Actuellement, les clés de cache suivent un algorithme « premier arrivé, clé la plus petite ». Les seize premières valeurs peuvent être envoyées en un seul octet. Les 4080 valeurs suivantes peuvent être envoyées sur deux octets. Le million de valeurs suivant est de trois octets, etc. Un système de production devrait conserver des compteurs d'utilisation sur les entrées du cache et les réorganiser de manière à ce que les seize valeurs _les plus courantes_ soient sur un octet, les 4 080 valeurs les plus courantes suivantes sur deux octets, etc.
 
   Cependant, c'est une opération potentiellement dangereuse. Imaginez la séquence d'événements suivante :
 
-  1. Noam Naïf appelle `encodeVal` pour encoder l'adresse à laquelle il souhaite envoyer des tokens. Cette adresse est l'une des premières utilisées dans l'application, donc la valeur encodée est 0x06. Il s'agit d'une fonction en `lecture`, pas d'une transaction, donc elle concerne uniquement Noam et le nœud qu'il utilise, et personne d'autre n'est au courant
+  1. Noam Naïf appelle `encodeVal` pour encoder l'adresse à laquelle il veut envoyer des jetons. Cette adresse est l'une des premières utilisées sur l'application, donc la valeur encodée est 0x06. C'est une fonction `view`, pas une transaction, donc c'est entre Noam et le nœud qu'il utilise, et personne d'autre n'est au courant.
 
-  2. Paulo Proprio exécute l'opération de réorganisation du cache. Très peu de gens utilisent réellement cette adresse, elle est donc maintenant encodée en 0x201122. Une valeur différente, 10<sup>18</sup>, se voit attribuer 0x06.
+  2. Pierre Propriétaire exécute l'opération de réorganisation du cache. Très peu de gens utilisent réellement cette adresse, elle est donc maintenant encodée en 0x201122. Une valeur différente, 10<sup>18</sup>, se voit attribuer 0x06.
 
-  3. Noam Naïf envoie ses tokens à 0x06. Ils vont à l'adresse `0x0000000000000000000000000de0b6b3a7640000`, et comme personne ne connaît la clé privée de cette adresse, ils restent bloqués là. Noam n'est _pas content_.
+  3. Noam Naïf envoie ses jetons à 0x06. Ils vont à l'adresse `0x0000000000000000000000000de0b6b3a7640000`, et comme personne ne connaît la clé privée de cette adresse, ils sont simplement bloqués là. Noam n'est _pas content_.
 
-  Il existe des moyens de résoudre ce problème, ainsi que le problème lié aux transactions qui sont dans le mempool pendant la réorganisation du cache, mais vous devez en être conscient.
+  Il existe des moyens de résoudre ce problème, ainsi que le problème connexe des transactions qui se trouvent dans le mempool pendant la réorganisation du cache, mais vous devez en être conscient.
+
+J'ai fait ici une démonstration de la mise en cache avec Optimism, parce que je suis un employé d'Optimism et que c'est le rollup que je connais le mieux. Mais cela devrait fonctionner avec n'importe quel rollup qui facture un coût minimal pour le traitement interne, de sorte qu'en comparaison, l'écriture des données de transaction sur la L1 soit la principale dépense.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
 
-J'ai démontré la mise en cache ici avec Optimism, car je suis un employé d'Optimism et c'est la rollup que je connais le mieux. Mais cela devrait fonctionner avec n'importe quelle rollup qui facture un coût minimal pour le traitement interne, de sorte qu'en comparaison, l'écriture des données de la transaction sur L1 soit le principal coût.
diff --git a/public/content/translations/fr/developers/tutorials/app-plasma/index.md b/public/content/translations/fr/developers/tutorials/app-plasma/index.md
new file mode 100644
index 00000000000..c28c16f7469
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/app-plasma/index.md
@@ -0,0 +1,1261 @@
+---
+title: "Écrire un plasma spécifique à une application qui préserve la confidentialité"
+description: "Dans ce tutoriel, nous créons une banque semi-secrète pour les dépôts. La banque est un composant centralisé ; elle connaît le solde de chaque utilisateur. Cependant, ces informations ne sont pas stockées sur la chaîne. Au lieu de cela, la banque publie un hachage de l'état. Chaque fois qu'une transaction a lieu, la banque publie le nouveau hachage, ainsi qu'une preuve à divulgation nulle de connaissance qu'elle a une transaction signée qui change l'état de hachage au nouveau. Après avoir lu ce tutoriel, vous comprendrez non seulement comment utiliser les preuves à divulgation nulle de connaissance, mais aussi pourquoi vous les utilisez et comment le faire en toute sécurité."
+author: Ori Pomerantz
+tags:
+  [
+    "preuve à divulgation nulle de connaissance",
+    "serveur",
+    "hors-chaîne",
+    "confidentialité"
+  ]
+skill: advanced
+lang: fr
+published: 2025-10-15
+---
+
+## Introduction {#introduction}
+
+Contrairement aux [rollups](/developers/docs/scaling/zk-rollups/), les [plasmas](/developers/docs/scaling/plasma) utilisent le réseau principal Ethereum pour l'intégrité, mais pas pour la disponibilité. Dans cet article, nous écrivons une application qui se comporte comme un plasma, avec Ethereum garantissant l'intégrité (pas de changements non autorisés) mais pas la disponibilité (un composant centralisé peut tomber en panne et désactiver tout le système).
+
+L'application que nous écrivons ici est une banque qui préserve la confidentialité. Différentes adresses ont des comptes avec des soldes, et elles peuvent envoyer de l'argent (ETH) à d'autres comptes. La banque publie les hachages de l'état (comptes et soldes) et des transactions, mais garde les soldes réels hors chaîne où ils peuvent rester privés.
+
+## Conception {#design}
+
+Ce n'est pas un système prêt pour la production, mais un outil pédagogique. En tant que tel, il est écrit avec plusieurs hypothèses simplificatrices.
+
+- Pool de comptes fixe. Il y a un nombre spécifique de comptes, et chaque compte appartient à une adresse prédéterminée. Cela rend le système beaucoup plus simple car il est difficile de gérer des structures de données de taille variable dans les preuves à divulgation nulle de connaissance. Pour un système prêt pour la production, nous pouvons utiliser la [racine de Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/) comme hachage d'état et fournir des preuves de Merkle pour les soldes requis.
+
+- Stockage en mémoire. Sur un système de production, nous devons écrire tous les soldes des comptes sur le disque pour les préserver en cas de redémarrage. Ici, ce n'est pas grave si les informations sont simplement perdues.
+
+- Transferts uniquement. Un système de production nécessiterait un moyen de déposer des actifs dans la banque et de les retirer. Mais le but ici est simplement d'illustrer le concept, donc cette banque est limitée aux transferts.
+
+### Preuves à divulgation nulle de connaissance {#zero-knowledge-proofs}
+
+À un niveau fondamental, une preuve à divulgation nulle de connaissance montre que le prouveur connaît certaines données, _Données<sub>privées</sub>_, de telle sorte qu'il existe une relation _Relation_ entre certaines données publiques, _Données<sub>publiques</sub>_, et _Données<sub>privées</sub>_. Le vérificateur connaît la _Relation_ et les _Données<sub>publiques</sub>_.
+
+Pour préserver la confidentialité, nous avons besoin que les états et les transactions soient privés. Mais pour garantir l'intégrité, nous avons besoin que le [hachage cryptographique](https://en.wikipedia.org/wiki/Cryptographic_hash_function) des états soit public. Pour prouver aux personnes qui soumettent des transactions que ces transactions ont bien eu lieu, nous devons également publier les hachages de transaction.
+
+Dans la plupart des cas, _Données<sub>privées</sub>_ est l'entrée du programme de preuve à divulgation nulle de connaissance, et _Données<sub>publiques</sub>_ est la sortie.
+
+Ces champs dans _Données<sub>privées</sub>_ :
+
+- _État<sub>n</sub>_, l'ancien état
+- _État<sub>n+1</sub>_, le nouvel état
+- _Transaction_, une transaction qui passe de l'ancien état au nouveau. Cette transaction doit inclure ces champs :
+  - _Adresse de destination_ qui reçoit le transfert
+  - _Montant_ transféré
+  - _Nonce_ pour garantir que chaque transaction ne puisse être traitée qu'une seule fois.
+    L'adresse source n'a pas besoin de figurer dans la transaction, car elle peut être récupérée à partir de la signature.
+- _Signature_, une signature qui est autorisée à effectuer la transaction. Dans notre cas, la seule adresse autorisée à effectuer une transaction est l'adresse source. Parce que notre système à divulgation nulle de connaissance fonctionne comme il le fait, nous avons également besoin de la clé publique du compte, en plus de la signature Ethereum.
+
+Voici les champs dans _Données<sub>publiques</sub>_ :
+
+- _Hachage(État<sub>n</sub>)_, le hachage de l'ancien état
+- _Hachage(État<sub>n+1</sub>)_, le hachage du nouvel état
+- _Hachage(Transaction)_, le hachage de la transaction qui fait passer l'état de _État<sub>n</sub>_ à _État<sub>n+1</sub>_.
+
+La relation vérifie plusieurs conditions :
+
+- Les hachages publics sont bien les bons hachages pour les champs privés.
+- La transaction, lorsqu'elle est appliquée à l'ancien état, aboutit au nouvel état.
+- La signature provient de l'adresse source de la transaction.
+
+En raison des propriétés des fonctions de hachage cryptographique, la preuve de ces conditions suffit à garantir l'intégrité.
+
+### Structures de données {#data-structures}
+
+La structure de données principale est l'état détenu par le serveur. Pour chaque compte, le serveur garde une trace du solde du compte et d'un [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce), utilisé pour empêcher les [attaques par rejeu](https://en.wikipedia.org/wiki/Replay_attack).
+
+### Composants {#components}
+
+Ce système nécessite deux composants :
+
+- Le _serveur_ qui reçoit les transactions, les traite et publie les hachages sur la chaîne ainsi que les preuves à divulgation nulle de connaissance.
+- Un _contrat intelligent_ qui stocke les hachages et vérifie les preuves à divulgation nulle de connaissance pour s'assurer que les transitions d'état sont légitimes.
+
+### Flux de données et de contrôle {#flows}
+
+Ce sont les façons dont les différents composants communiquent pour effectuer un transfert d'un compte à un autre.
+
+1. Un navigateur web soumet une transaction signée demandant un transfert du compte du signataire vers un autre compte.
+
+2. Le serveur vérifie que la transaction est valide :
+
+   - Le signataire a un compte à la banque avec un solde suffisant.
+   - Le destinataire a un compte à la banque.
+
+3. Le serveur calcule le nouvel état en soustrayant le montant transféré du solde du signataire et en l'ajoutant au solde du destinataire.
+
+4. Le serveur calcule une preuve à divulgation nulle de connaissance que le changement d'état est valide.
+
+5. Le serveur soumet à Ethereum une transaction qui inclut :
+
+   - Le nouveau hachage d'état
+   - Le hachage de la transaction (afin que l'expéditeur de la transaction puisse savoir qu'elle a été traitée)
+   - La preuve à divulgation nulle de connaissance qui prouve que la transition vers le nouvel état est valide
+
+6. Le contrat intelligent vérifie la preuve à divulgation nulle de connaissance.
+
+7. Si la preuve à divulgation nulle de connaissance est validée, le contrat intelligent effectue ces actions :
+   - Mettre à jour le hachage de l'état actuel avec le nouveau hachage d'état
+   - Émettre une entrée de journal avec le nouveau hachage d'état et le hachage de la transaction
+
+### Outils {#tools}
+
+Pour le code côté client, nous allons utiliser [Vite](https://vite.dev/), [React](https://react.dev/), [Viem](https://viem.sh/) et [Wagmi](https://wagmi.sh/). Ce sont des outils standard de l'industrie ; si vous ne les connaissez pas, vous pouvez utiliser [ce tutoriel](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/).
+
+La majorité du serveur est écrite en JavaScript à l'aide de [Node](https://nodejs.org/en). La partie à divulgation nulle de connaissance est écrite en [Noir](https://noir-lang.org/). Nous avons besoin de la version `1.0.0-beta.10`, donc après avoir [installé Noir comme indiqué](https://noir-lang.org/docs/getting_started/quick_start), exécutez :
+
+```
+noirup -v 1.0.0-beta.10
+```
+
+La blockchain que nous utilisons est `anvil`, une blockchain de test locale qui fait partie de [Foundry](https://getfoundry.sh/introduction/installation).
+
+## Implémentation {#implementation}
+
+Comme il s'agit d'un système complexe, nous allons l'implémenter par étapes.
+
+### Étape 1 - Divulgation nulle de connaissance manuelle {#stage-1}
+
+Pour la première étape, nous signerons une transaction dans le navigateur, puis fournirons manuellement les informations à la preuve à divulgation nulle de connaissance. Le code à divulgation nulle de connaissance s'attend à recevoir ces informations dans `server/noir/Prover.toml` (documenté [ici](https://noir-lang.org/docs/getting_started/project_breakdown#provertoml-1)).
+
+Pour le voir en action :
+
+1. Assurez-vous que [Node](https://nodejs.org/en/download) et [Noir](https://noir-lang.org/install) sont installés. De préférence, installez-les sur un système UNIX tel que macOS, Linux ou [WSL](https://learn.microsoft.com/en-us/windows/wsl/install).
+
+2. Téléchargez le code de l'étape 1 et démarrez le serveur web pour servir le code client.
+
+   ```sh
+   git clone https://github.com/qbzzt/250911-zk-bank.git -b 01-manual-zk
+   cd 250911-zk-bank
+   cd client
+   npm install
+   npm run dev
+   ```
+
+   La raison pour laquelle vous avez besoin d'un serveur web ici est que, pour prévenir certains types de fraude, de nombreux portefeuilles (tels que MetaMask) n'acceptent pas les fichiers servis directement depuis le disque
+
+3. Ouvrez un navigateur avec un portefeuille.
+
+4. Dans le portefeuille, saisissez une nouvelle phrase secrète. Notez que cela supprimera votre phrase secrète existante, donc _assurez-vous d'avoir une sauvegarde_.
+
+   La phrase secrète est `test test test test test test test test test test test junk`, la phrase secrète de test par défaut pour anvil.
+
+5. Accédez au [code côté client](http://localhost:5173/).
+
+6. Connectez-vous au portefeuille et sélectionnez votre compte de destination et le montant.
+
+7. Cliquez sur **Signer** et signez la transaction.
+
+8. Sous l'en-tête **Prover.toml**, vous trouverez du texte. Remplacez `server/noir/Prover.toml` par ce texte.
+
+9. Exécutez la preuve à divulgation nulle de connaissance.
+
+   ```sh
+   cd ../server/noir
+   nargo execute
+   ```
+
+   La sortie devrait être similaire à
+
+   ```
+   ori@CryptoDocGuy:~/noir/250911-zk-bank/server/noir$ nargo execute
+
+   [zkBank] Témoin de circuit résolu avec succès
+   [zkBank] Témoin enregistré dans target/zkBank.gz
+   [zkBank] Sortie du circuit : (0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b, 0x0cfc0a67cb7308e4e9b254026b54204e34f6c8b041be207e64c5db77d95dd82d, 0x450cf9da6e180d6159290554ae3d8787, 0x6d8bc5a15b9037e52fb59b6b98722a85)
+   ```
+
+10. Comparez les deux dernières valeurs au hachage que vous voyez sur le navigateur web pour voir si le message est correctement haché.
+
+#### `server/noir/Prover.toml` {#server-noir-prover-toml}
+
+[Ce fichier](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) montre le format d'information attendu par Noir.
+
+```toml
+message="send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 500 finney (milliEth) 0                             "
+```
+
+Le message est au format texte, ce qui le rend facile à comprendre pour l'utilisateur (ce qui est nécessaire lors de la signature) et à analyser pour le code Noir. Le montant est exprimé en finneys pour permettre des transferts fractionnés d'une part, et être facilement lisible d'autre part. Le dernier nombre est le [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce).
+
+La chaîne de caractères fait 100 caractères de long. Les preuves à divulgation nulle de connaissance ne gèrent pas bien les données de taille variable, il est donc souvent nécessaire de compléter les données.
+
+```toml
+pubKeyX=["0x83",...,"0x75"]
+pubKeyY=["0x35",...,"0xa5"]
+signature=["0xb1",...,"0x0d"]
+```
+
+Ces trois paramètres sont des tableaux d'octets de taille fixe.
+
+```toml
+[[accounts]]
+address="0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+balance=100_000
+nonce=0
+
+[[accounts]]
+address="0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+balance=100_000
+nonce=0
+```
+
+C'est la façon de spécifier un tableau de structures. Pour chaque entrée, nous spécifions l'adresse, le solde (en milliETH alias [finney](https://cryptovalleyjournal.com/glossary/finney/)), et la valeur de nonce suivante.
+
+#### `client/src/Transfer.tsx` {#client-src-transfer-tsx}
+
+[Ce fichier](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/client/src/Transfer.tsx) met en œuvre le traitement côté client et génère le fichier `server/noir/Prover.toml` (celui qui inclut les paramètres de la preuve à divulgation nulle de connaissance).
+
+Voici l'explication des parties les plus intéressantes.
+
+```tsx
+export default attrs =>  {
+```
+
+Cette fonction crée le composant React `Transfer`, que d'autres fichiers peuvent importer.
+
+```tsx
+  const accounts = [
+    "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+    "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+    "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+    "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+    "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
+  ]
+```
+
+Ce sont les adresses de compte, les adresses créées par le `test... phrase secrète `test junk`. Si vous voulez utiliser vos propres adresses, il suffit de modifier cette définition.
+
+```tsx
+  const account = useAccount()
+  const wallet = createWalletClient({
+    transport: custom(window.ethereum!)
+  })
+```
+
+Ces [hooks Wagmi](https://wagmi.sh/react/api/hooks) nous permettent d'accéder à la bibliothèque [viem](https://viem.sh/) et au portefeuille.
+
+```tsx
+  const message = `send ${toAccount} ${ethAmount*1000} finney (milliEth) ${nonce}`.padEnd(100, " ")
+```
+
+C'est le message, complété par des espaces. Chaque fois qu'une des variables [`useState`](https://react.dev/reference/react/useState) change, le composant est redessiné et `message` est mis à jour.
+
+```tsx
+  const sign = async () => {
+```
+
+Cette fonction est appelée lorsque l'utilisateur clique sur le bouton **Signer**. Le message est automatiquement mis à jour, mais la signature nécessite l'approbation de l'utilisateur dans le portefeuille, et nous ne voulons pas la demander sauf si nécessaire.
+
+```tsx
+    const signature = await wallet.signMessage({
+        account: fromAccount,
+        message,
+    })
+```
+
+Demander au portefeuille de [signer le message](https://viem.sh/docs/accounts/local/signMessage).
+
+```tsx
+    const hash = hashMessage(message)
+```
+
+Obtenir le hachage du message. Il est utile de le fournir à l'utilisateur pour le débogage (du code Noir).
+
+```tsx
+    const pubKey = await recoverPublicKey({
+        hash,
+        signature
+    })
+```
+
+[Obtenir la clé publique](https://viem.sh/docs/utilities/recoverPublicKey). Ceci est requis pour la fonction Noir [`ecrecover`](https://github.com/colinnielsen/ecrecover-noir).
+
+```tsx
+    setSignature(signature)
+    setHash(hash)
+    setPubKey(pubKey)
+```
+
+Définir les variables d'état. Cela redessine le composant (après la fin de la fonction `sign`) et montre à l'utilisateur les valeurs mises à jour.
+
+```tsx
+    let proverToml = `
+```
+
+Le texte pour `Prover.toml`.
+
+```tsx
+message="${message}"
+
+pubKeyX=${hexToArray(pubKey.slice(4,4+2*32))}
+pubKeyY=${hexToArray(pubKey.slice(4+2*32))}
+```
+
+Viem nous fournit la clé publique sous la forme d'une chaîne hexadécimale de 65 octets. Le premier octet est `0x04`, un marqueur de version. Il est suivi de 32 octets pour le `x` de la clé publique, puis de 32 octets pour le `y` de la clé publique.
+
+Cependant, Noir s'attend à recevoir cette information sous forme de deux tableaux d'octets, un pour `x` et un pour `y`. Il est plus facile de l'analyser ici, côté client, plutôt que dans le cadre de la preuve à divulgation nulle de connaissance.
+
+Notez que c'est une bonne pratique en matière de preuve à divulgation nulle de connaissance en général. Le code à l'intérieur d'une preuve à divulgation nulle de connaissance est coûteux, donc tout traitement qui peut être effectué en dehors de la preuve à divulgation nulle de connaissance _devrait_ être effectué en dehors de la preuve à divulgation nulle de connaissance.
+
+```tsx
+signature=${hexToArray(signature.slice(2,-2))}
+```
+
+La signature est également fournie sous la forme d'une chaîne hexadécimale de 65 octets. Cependant, le dernier octet n'est nécessaire que pour récupérer la clé publique. Comme la clé publique sera déjà fournie au code Noir, nous n'en avons pas besoin pour vérifier la signature, et le code Noir ne l'exige pas.
+
+```tsx
+${accounts.map(accountInProverToml).reduce((a,b) => a+b, "")}
+`
+```
+
+Fournir les comptes.
+
+```tsx
+    setProverToml(proverToml)
+  }
+
+  return (
+    <>
+        <h2>Transfer</h2>
+```
+
+Ceci est le format HTML (plus précisément, [JSX](https://react.dev/learn/writing-markup-with-jsx)) du composant.
+
+#### `server/noir/src/main.nr` {#server-noir-src-main-nr}
+
+[Ce fichier](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/src/main.nr) est le code réel de la preuve à divulgation nulle de connaissance.
+
+```
+use std::hash::pedersen_hash;
+```
+
+Le [hachage de Pedersen](https://rya-sge.github.io/access-denied/2024/05/07/pedersen-hash-function/) est fourni avec la [bibliothèque standard de Noir](https://noir-lang.org/docs/noir/standard_library/cryptographic_primitives/hashes#pedersen_hash). Les preuves à divulgation nulle de connaissance utilisent couramment cette fonction de hachage. Il est beaucoup plus facile à calculer à l'intérieur de [circuits arithmétiques](https://rareskills.io/post/arithmetic-circuit) par rapport aux fonctions de hachage standard.
+
+```
+use keccak256::keccak256;
+use dep::ecrecover;
+```
+
+Ces deux fonctions sont des bibliothèques externes, définies dans [`Nargo.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Nargo.toml). Elles sont précisément ce pour quoi elles sont nommées, une fonction qui calcule le [hachage keccak256](https://emn178.github.io/online-tools/keccak_256.html) et une fonction qui vérifie les signatures Ethereum et récupère l'adresse Ethereum du signataire.
+
+```
+global ACCOUNT_NUMBER : u32 = 5;
+```
+
+Noir est inspiré de [Rust](https://www.rust-lang.org/). Les variables, par défaut, sont des constantes. C'est ainsi que nous définissons les constantes de configuration globales. Plus précisément, `ACCOUNT_NUMBER` est le nombre de comptes que nous stockons.
+
+Les types de données nommés `u<number>` sont ce nombre de bits, non signés. Les seuls types pris en charge sont `u8`, `u16`, `u32`, `u64` et `u128`.
+
+```
+global FLAT_ACCOUNT_FIELDS : u32 = 2;
+```
+
+Cette variable est utilisée pour le hachage de Pedersen des comptes, comme expliqué ci-dessous.
+
+```
+global MESSAGE_LENGTH : u32 = 100;
+```
+
+Comme expliqué ci-dessus, la longueur du message est fixe. Elle est spécifiée ici.
+
+```
+global ASCII_MESSAGE_LENGTH : [u8; 3] = [0x31, 0x30, 0x30];
+global HASH_BUFFER_SIZE : u32 = 26+3+MESSAGE_LENGTH;
+```
+
+Les [signatures EIP-191](https://eips.ethereum.org/EIPS/eip-191) nécessitent un tampon avec un préfixe de 26 octets, suivi de la longueur du message en ASCII, et enfin du message lui-même.
+
+```
+struct Account {
+    balance: u128,
+    address: Field,
+    nonce: u32,
+}
+```
+
+Les informations que nous stockons sur un compte. [`Field`](https://noir-lang.org/docs/noir/concepts/data_types/fields) est un nombre, généralement jusqu'à 253 bits, qui peut être utilisé directement dans le [circuit arithmétique](https://rareskills.io/post/arithmetic-circuit) qui met en œuvre la preuve à divulgation nulle de connaissance. Ici, nous utilisons le `Field` pour stocker une adresse Ethereum de 160 bits.
+
+```
+struct TransferTxn {
+    from: Field,
+    to: Field,
+    amount: u128,
+    nonce: u32
+}
+```
+
+Les informations que nous stockons pour une transaction de transfert.
+
+```
+fn flatten_account(account: Account) -> [Field; FLAT_ACCOUNT_FIELDS] {
+```
+
+Une définition de fonction. Le paramètre est une information `Account`. Le résultat est un tableau de variables `Field`, dont la longueur est `FLAT_ACCOUNT_FIELDS`
+
+```
+    let flat = [
+        account.address,
+        ((account.balance << 32) + account.nonce.into()).into(),
+    ];
+```
+
+La première valeur dans le tableau est l'adresse du compte. La seconde inclut à la fois le solde et le nonce. Les appels `.into()` changent un nombre vers le type de données dont il a besoin. `account.nonce` est une valeur `u32`, mais pour l'ajouter à `account.balance « 32`, une valeur `u128`, elle doit être un `u128`. C'est le premier `.into()`. Le second convertit le résultat `u128` en un `Field` pour qu'il s'insère dans le tableau.
+
+```
+    flat
+}
+```
+
+Dans Noir, les fonctions ne peuvent retourner une valeur qu'à la fin (il n'y a pas de retour anticipé). Pour spécifier la valeur de retour, vous l'évaluez juste avant le crochet de fermeture de la fonction.
+
+```
+fn flatten_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] {
+```
+
+Cette fonction transforme le tableau de comptes en un tableau `Field`, qui peut être utilisé comme entrée pour un hachage de Petersen.
+
+```
+    let mut flat: [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] = [0; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER];
+```
+
+C'est ainsi que vous spécifiez une variable mutable, c'est-à-dire, _pas_ une constante. Les variables dans Noir doivent toujours avoir une valeur, donc nous initialisons cette variable à tous zéros.
+
+```
+    for i in 0..ACCOUNT_NUMBER {
+```
+
+Ceci est une boucle `for`. Notez que les limites sont des constantes. Les boucles Noir doivent avoir leurs limites connues au moment de la compilation. La raison est que les circuits arithmétiques ne prennent pas en charge le contrôle de flux. Lors du traitement d'une boucle `for`, le compilateur place simplement le code qu'elle contient plusieurs fois, une pour chaque itération.
+
+```
+        let fields = flatten_account(accounts[i]);
+        for j in 0..FLAT_ACCOUNT_FIELDS {
+            flat[i*FLAT_ACCOUNT_FIELDS + j] = fields[j];
+        }
+    }
+
+    flat
+}
+
+fn hash_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> Field {
+    pedersen_hash(flatten_accounts(accounts))
+}
+```
+
+Enfin, nous arrivons à la fonction qui hache le tableau des comptes.
+
+```
+fn find_account(accounts: [Account; ACCOUNT_NUMBER], address: Field) -> u32 {
+    let mut account : u32 = ACCOUNT_NUMBER;
+
+    for i in 0..ACCOUNT_NUMBER {
+        if accounts[i].address == address {
+            account = i;
+        }
+    }
+```
+
+Cette fonction trouve le compte avec une adresse spécifique. Cette fonction serait terriblement inefficace dans un code standard car elle itère sur tous les comptes, même après avoir trouvé l'adresse.
+
+Cependant, dans les preuves à divulgation nulle de connaissance, il n'y a pas de contrôle de flux. Si nous avons besoin de vérifier une condition, nous devons la vérifier à chaque fois.
+
+Une chose similaire se produit avec les instructions `if`. L'instruction `if` dans la boucle ci-dessus est traduite en ces énoncés mathématiques.
+
+_condition<sub>résultat</sub> = accounts[i].address == address_ // un s'ils sont égaux, zéro sinon
+
+_compte<sub>nouveau</sub> = condition<sub>résultat</sub>\*i + (1-condition<sub>résultat</sub>)\*compte<sub>ancien</sub>_
+
+```rust
+    assert (account < ACCOUNT_NUMBER, f"{address} n'a pas de compte");
+
+    account
+}
+```
+
+La fonction [`assert`](https://noir-lang.org/docs/dev/noir/concepts/assert) provoque le plantage de la preuve à divulgation nulle de connaissance si l'assertion est fausse. Dans ce cas, si nous ne pouvons pas trouver un compte avec l'adresse pertinente. Pour signaler l'adresse, nous utilisons une [chaîne de format](https://noir-lang.org/docs/noir/concepts/data_types/strings#format-strings).
+
+```rust
+fn apply_transfer_txn(accounts: [Account; ACCOUNT_NUMBER], txn: TransferTxn) -> [Account; ACCOUNT_NUMBER] {
+```
+
+Cette fonction applique une transaction de transfert et renvoie le nouveau tableau de comptes.
+
+```rust
+    let from = find_account(accounts, txn.from);
+    let to = find_account(accounts, txn.to);
+
+    let (txnFrom, txnAmount, txnNonce, accountNonce) =
+        (txn.from, txn.amount, txn.nonce, accounts[from].nonce);
+```
+
+Nous ne pouvons pas accéder aux éléments de structure à l'intérieur d'une chaîne de format dans Noir, nous créons donc une copie utilisable.
+
+```rust
+    assert (accounts[from].balance >= txn.amount,
+        f"{txnFrom} n'a pas {txnAmount} finney");
+
+    assert (accounts[from].nonce == txn.nonce,
+        f"La transaction a le nonce {txnNonce}, mais le compte est censé utiliser {accountNonce}");
+```
+
+Ce sont deux conditions qui pourraient rendre une transaction invalide.
+
+```rust
+    let mut newAccounts = accounts;
+
+    newAccounts[from].balance -= txn.amount;
+    newAccounts[from].nonce += 1;
+    newAccounts[to].balance += txn.amount;
+
+    newAccounts
+}
+```
+
+Créez le nouveau tableau de comptes, puis renvoyez-le.
+
+```rust
+fn readAddress(messageBytes: [u8; MESSAGE_LENGTH]) -> Field
+```
+
+Cette fonction lit l'adresse du message.
+
+```rust
+{
+    let mut result : Field = 0;
+
+    for i in 7..47 {
+```
+
+L'adresse est toujours longue de 20 octets (alias 40 chiffres hexadécimaux), et commence au caractère #7.
+
+```rust
+        result *= 0x10;
+        if messageBytes[i] >= 48 & messageBytes[i] <= 57 {    // 0-9
+            result += (messageBytes[i]-48).into();
+        }
+        if messageBytes[i] >= 65 & messageBytes[i] <= 70 {    // A-F
+            result += (messageBytes[i]-65+10).into()
+        }
+        if messageBytes[i] >= 97 & messageBytes[i] <= 102 {   // a-f
+            result += (messageBytes[i]-97+10).into()
+        }        
+    }    
+
+    result
+}
+
+fn readAmountAndNonce(messageBytes: [u8; MESSAGE_LENGTH]) -> (u128, u32)
+```
+
+Lire le montant et le nonce du message.
+
+```rust
+{
+    let mut amount : u128 = 0;
+    let mut nonce: u32 = 0;
+    let mut stillReadingAmount: bool = true;
+    let mut lookingForNonce: bool = false;
+    let mut stillReadingNonce: bool = false;
+```
+
+Dans le message, le premier nombre après l'adresse est le montant de finney (alias millième d'un ETH) à transférer. Le deuxième nombre est le nonce. Tout texte entre eux est ignoré.
+
+```rust
+    for i in 48..MESSAGE_LENGTH {
+        if messageBytes[i] >= 48 & messageBytes[i] <= 57 {    // 0-9
+            let digit = (messageBytes[i]-48);
+
+            if stillReadingAmount {
+                amount = amount*10 + digit.into();
+            }
+
+            if lookingForNonce {    // On vient de le trouver
+                stillReadingNonce = true;
+                lookingForNonce = false;
+            }
+
+            if stillReadingNonce {
+                nonce = nonce*10 + digit.into();
+            }
+        } else {
+            if stillReadingAmount {
+                stillReadingAmount = false;
+                lookingForNonce = true;
+            }
+            if stillReadingNonce {
+                stillReadingNonce = false;
+            }
+        }
+    }
+
+    (amount, nonce)
+}
+```
+
+Le renvoi d'un [tuple](https://noir-lang.org/docs/noir/concepts/data_types/tuples) est la manière Noir de renvoyer plusieurs valeurs d'une fonction.
+
+```rust
+fn readTransferTxn(message: str<MESSAGE_LENGTH>) -> TransferTxn 
+{
+    let mut txn: TransferTxn = TransferTxn { from: 0, to: 0, amount:0, nonce:0 };
+    let messageBytes = message.as_bytes();
+
+    txn.to = readAddress(messageBytes);
+    let (amount, nonce) = readAmountAndNonce(messageBytes);
+    txn.amount = amount;
+    txn.nonce = nonce;
+
+    txn
+}
+```
+
+Cette fonction convertit le message en octets, puis convertit les montants en un `TransferTxn`.
+
+```rust
+// L'équivalent de hashMessage de Viem
+// https://viem.sh/docs/utilities/hashMessage#hashmessage
+fn hashMessage(message: str<MESSAGE_LENGTH>) -> [u8;32] {
+```
+
+Nous avons pu utiliser le hachage de Pedersen pour les comptes car ils ne sont hachés qu'à l'intérieur de la preuve à divulgation nulle de connaissance. Cependant, dans ce code, nous devons vérifier la signature du message, qui est générée par le navigateur. Pour cela, nous devons suivre le format de signature Ethereum dans [l'EIP 191](https://eips.ethereum.org/EIPS/eip-191). Cela signifie que nous devons créer un tampon combiné avec un préfixe standard, la longueur du message en ASCII et le message lui-même, et utiliser le keccak256 standard d'Ethereum pour le hacher.
+
+```rust
+    // Préfixe ASCII
+    let prefix_bytes = [
+        0x19, // \x19
+        0x45, // 'E'
+        0x74, // 't'
+        0x68, // 'h'
+        0x65, // 'e'
+        0x72, // 'r'
+        0x65, // 'e'
+        0x75, // 'u'
+        0x6D, // 'm'
+        0x20, // ' '
+        0x53, // 'S'
+        0x69, // 'i'
+        0x67, // 'g'
+        0x6E, // 'n'
+        0x65, // 'e'
+        0x64, // 'd'
+        0x20, // ' '
+        0x4D, // 'M'
+        0x65, // 'e'
+        0x73, // 's'
+        0x73, // 's'
+        0x61, // 'a'
+        0x67, // 'g'
+        0x65, // 'e'
+        0x3A, // ':'
+        0x0A  // '\n'
+    ];
+```
+
+Pour éviter les cas où une application demande à l'utilisateur de signer un message qui peut être utilisé comme une transaction ou à d'autres fins, l'EIP 191 spécifie que tous les messages signés commencent par le caractère 0x19 (qui n'est pas un caractère ASCII valide) suivi de `Ethereum Signed Message:` et d'un saut de ligne.
+
+```rust
+    let mut buffer: [u8; HASH_BUFFER_SIZE] = [0u8; HASH_BUFFER_SIZE];
+    for i in 0..26 {
+        buffer[i] = prefix_bytes[i];
+    }
+
+    let messageBytes : [u8; MESSAGE_LENGTH] = message.as_bytes();
+
+    if MESSAGE_LENGTH <= 9 {
+        for i in 0..1 {
+            buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+        }
+
+        for i in 0..MESSAGE_LENGTH {
+            buffer[i+26+1] = messageBytes[i];
+        }
+    }
+
+    if MESSAGE_LENGTH >= 10 & MESSAGE_LENGTH <= 99 {
+        for i in 0..2 {
+            buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+        }
+
+        for i in 0..MESSAGE_LENGTH {
+            buffer[i+26+2] = messageBytes[i];
+        }
+    }
+
+    if MESSAGE_LENGTH >= 100 {
+        for i in 0..3 {
+            buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+        }
+
+        for i in 0..MESSAGE_LENGTH {
+            buffer[i+26+3] = messageBytes[i];
+        }
+    }
+
+    assert(MESSAGE_LENGTH < 1000, "Les messages dont la longueur est supérieure à trois chiffres ne sont pas pris en charge");
+```
+
+Gérer les longueurs de message jusqu'à 999 et échouer si c'est plus. J'ai ajouté ce code, même si la longueur du message est une constante, car cela facilite sa modification. Sur un système de production, vous supposeriez probablement que `MESSAGE_LENGTH` ne change pas pour une meilleure performance.
+
+```rust
+    keccak256::keccak256(buffer, HASH_BUFFER_SIZE)
+}
+```
+
+Utiliser la fonction standard d'Ethereum `keccak256`.
+
+```rust
+fn signatureToAddressAndHash(
+        message: str<MESSAGE_LENGTH>, 
+        pubKeyX: [u8; 32],
+        pubKeyY: [u8; 32],
+        signature: [u8; 64]
+    ) -> (Field, Field, Field)   // adresse, 16 premiers octets du hachage, 16 derniers octets du hachage        
+{
+```
+
+Cette fonction vérifie la signature, ce qui nécessite le hachage du message. Elle nous fournit ensuite l'adresse qui l'a signé et le hachage du message. Le hachage du message est fourni sous forme de deux valeurs `Field` car elles sont plus faciles à utiliser dans le reste du programme qu'un tableau d'octets.
+
+Nous devons utiliser deux valeurs `Field` car les calculs de champ sont effectués [modulo](https://en.wikipedia.org/wiki/Modulo) un grand nombre, mais ce nombre est généralement inférieur à 256 bits (sinon il serait difficile d'effectuer ces calculs dans l'EVM).
+
+```rust
+    let hash = hashMessage(message);
+
+    let mut (hash1, hash2) = (0,0);
+
+    for i in 0..16 {
+        hash1 = hash1*256 + hash[31-i].into();
+        hash2 = hash2*256 + hash[15-i].into();
+    }
+```
+
+Spécifiez `hash1` et `hash2` comme des variables mutables, et écrivez le hachage dedans octet par octet.
+
+```rust
+    (
+        ecrecover::ecrecover(pubKeyX, pubKeyY, signature, hash), 
+```
+
+Ceci est similaire à la fonction `ecrecover` de [Solidity](https://docs.soliditylang.org/en/v0.8.30/cheatsheet.html#mathematical-and-cryptographic-functions), avec deux différences importantes :
+
+- Si la signature n'est pas valide, l'appel échoue sur un `assert` et le programme est interrompu.
+- Bien que la clé publique puisse être récupérée à partir de la signature et du hachage, il s'agit d'un traitement qui peut être effectué en externe et qui, par conséquent, ne vaut pas la peine d'être fait à l'intérieur de la preuve à divulgation nulle de connaissance. Si quelqu'un essaie de nous tromper ici, la vérification de la signature échouera.
+
+```rust
+        hash1,
+        hash2
+    )
+}
+
+fn main(
+        accounts: [Account; ACCOUNT_NUMBER],
+        message: str<MESSAGE_LENGTH>,
+        pubKeyX: [u8; 32],
+        pubKeyY: [u8; 32],
+        signature: [u8; 64],
+    ) -> pub (
+        Field,  // Hachage de l'ancien tableau de comptes
+        Field,  // Hachage du nouveau tableau de comptes
+        Field,  // 16 premiers octets du hachage du message
+        Field,  // 16 derniers octets du hachage du message
+    )
+```
+
+Enfin, nous atteignons la fonction `main`. Nous devons prouver que nous avons une transaction qui change valablement le hachage des comptes de l'ancienne valeur à la nouvelle. Nous devons également prouver qu'il a ce hachage de transaction spécifique afin que la personne qui l'a envoyé sache que sa transaction a été traitée.
+
+```rust
+{
+    let mut txn = readTransferTxn(message);
+```
+
+Nous avons besoin que `txn` soit mutable car nous ne lisons pas l'adresse d'origine du message, nous la lisons à partir de la signature.
+
+```rust
+    let (fromAddress, txnHash1, txnHash2) = signatureToAddressAndHash(
+        message,
+        pubKeyX,
+        pubKeyY,
+        signature);
+
+    txn.from = fromAddress;
+
+    let newAccounts = apply_transfer_txn(accounts, txn);
+
+    (
+        hash_accounts(accounts),
+        hash_accounts(newAccounts),
+        txnHash1,
+        txnHash2
+    )
+}
+```
+
+### Étape 2 - Ajout d'un serveur {#stage-2}
+
+Dans la deuxième étape, nous ajoutons un serveur qui reçoit et met en œuvre les transactions de transfert du navigateur.
+
+Pour le voir en action :
+
+1. Arrêtez Vite s'il est en cours d'exécution.
+
+2. Téléchargez la branche qui inclut le serveur et assurez-vous que vous avez tous les modules nécessaires.
+
+   ```sh
+   git checkout 02-add-server
+   cd client
+   npm install
+   cd ../server
+   npm install
+   ```
+
+   Il n'est pas nécessaire de compiler le code Noir, c'est le même code que vous avez utilisé pour l'étape 1.
+
+3. Démarrer le serveur.
+
+   ```sh
+   npm run start
+   ```
+
+4. Dans une fenêtre de ligne de commande distincte, exécutez Vite pour servir le code du navigateur.
+
+   ```sh
+   cd client
+   npm run dev
+   ```
+
+5. Accédez au code client sur [http://localhost:5173](http://localhost:5173)
+
+6. Avant de pouvoir émettre une transaction, vous devez connaître le nonce, ainsi que le montant que vous pouvez envoyer. Pour obtenir ces informations, cliquez sur **Mettre à jour les données du compte** et signez le message.
+
+   Nous avons un dilemme ici. D'un côté, nous ne voulons pas signer un message qui peut être réutilisé (une [attaque par rejeu](https://en.wikipedia.org/wiki/Replay_attack)), c'est pourquoi nous voulons un nonce en premier lieu. Cependant, nous n'avons pas encore de nonce. La solution est de choisir un nonce qui ne peut être utilisé qu'une seule fois et que nous avons déjà des deux côtés, comme l'heure actuelle.
+
+   Le problème avec cette solution est que l'heure pourrait ne pas être parfaitement synchronisée. Donc, à la place, nous signons une valeur qui change chaque minute. Cela signifie que notre fenêtre de vulnérabilité aux attaques par rejeu est d'au plus une minute. Considérant qu'en production la requête signée sera protégée par TLS, et que l'autre côté du tunnel - le serveur - peut déjà divulguer le solde et le nonce (il doit les connaître pour fonctionner), c'est un risque acceptable.
+
+7. Une fois que le navigateur a récupéré le solde et le nonce, il affiche le formulaire de transfert. Sélectionnez l'adresse de destination et le montant, puis cliquez sur **Transférer**. Signez cette demande.
+
+8. Pour voir le transfert, soit **Mettez à jour les données du compte**, soit regardez dans la fenêtre où vous exécutez le serveur. Le serveur enregistre l'état à chaque fois qu'il change.
+
+    ```
+    ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+    
+    > server@1.0.0 start
+    > node --experimental-json-modules index.mjs
+    
+    Écoute sur le port 3000
+    Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 36000 finney (milliEth) 0 traitée
+    Nouvel état :
+    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 a 64000 (1)
+    0x70997970C51812dc3A010C7d01b50e0d17dc79C8 a 100000 (0)
+    0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC a 100000 (0)
+    0x90F79bf6EB2c4f870365E785982E1f101E93b906 a 136000 (0)
+    0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 a 100000 (0)
+    Txn send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 7200 finney (milliEth) 1 traitée
+    Nouvel état :
+    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 a 56800 (2)
+    0x70997970C51812dc3A010C7d01b50e0d17dc79C8 a 107200 (0)
+    0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC a 100000 (0)
+    0x90F79bf6EB2c4f870365E785982E1f101E93b906 a 136000 (0)
+    0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 a 100000 (0)
+    Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 3000 finney (milliEth) 2 traitée
+    Nouvel état :
+    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 a 53800 (3)
+    0x70997970C51812dc3A010C7d01b50e0d17dc79C8 a 107200 (0)
+    0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC a 100000 (0)
+    0x90F79bf6EB2c4f870365E785982E1f101E93b906 a 139000 (0)
+    0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 a 100000 (0)
+    ```
+
+#### `server/index.mjs` {#server-index-mjs-1}
+
+[Ce fichier](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/index.mjs) contient le processus serveur, et interagit avec le code Noir à [`main.nr`](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/noir/src/main.nr). Voici une explication des parties intéressantes.
+
+```js
+import { Noir } from '@noir-lang/noir_js'
+```
+
+La bibliothèque [noir.js](https://www.npmjs.com/package/@noir-lang/noir_js) fait l'interface entre le code JavaScript et le code Noir.
+
+```js
+const circuit = JSON.parse(await fs.readFile("./noir/target/zkBank.json"))
+const noir = new Noir(circuit)
+```
+
+Chargez le circuit arithmétique - le programme Noir compilé que nous avons créé à l'étape précédente - et préparez-vous à l'exécuter.
+
+```js
+// Nous ne fournissons des informations sur le compte qu'en réponse à une demande signée
+const accountInformation = async signature => {
+    const fromAddress = await recoverAddress({
+        hash: hashMessage("Get account data " + Math.floor((new Date().getTime())/60000)),
+        signature
+    })
+```
+
+Pour fournir des informations sur le compte, nous n'avons besoin que de la signature. La raison est que nous savons déjà quel sera le message, et donc le hachage du message.
+
+```js
+const processMessage = async (message, signature) => {
+```
+
+Traitez un message et exécutez la transaction qu'il encode.
+
+```js
+    // Obtenir la clé publique
+    const pubKey = await recoverPublicKey({
+        hash,
+        signature
+    })
+```
+
+Maintenant que nous exécutons JavaScript sur le serveur, nous pouvons récupérer la clé publique là-bas plutôt que sur le client.
+
+```js
+    let noirResult
+    try {
+        noirResult = await noir.execute({
+            message,
+            signature: signature.slice(2,-2).match(/.{2}/g).map(x => `0x${x}`),
+            pubKeyX,
+            pubKeyY,
+            accounts: Accounts
+        })
+```
+
+`noir.execute` exécute le programme Noir. Les paramètres sont équivalents à ceux fournis dans [`Prover.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml). Notez que les valeurs longues sont fournies sous forme de tableau de chaînes hexadécimales (`["0x60", "0xA7"]`), et non sous forme de valeur hexadécimale unique (`0x60A7`), comme le fait Viem.
+
+```js
+    } catch (err) {
+        console.log(`Erreur Noir : ${err}`)
+        throw Error("Transaction invalide, non traitée")
+    }
+```
+
+S'il y a une erreur, l'attraper et relayer une version simplifiée au client.
+
+```js
+    Accounts[fromAccountNumber].nonce++
+    Accounts[fromAccountNumber].balance -= amount
+    Accounts[toAccountNumber].balance += amount
+```
+
+Appliquez la transaction. Nous l'avons déjà fait dans le code Noir, mais il est plus facile de le faire à nouveau ici plutôt que d'en extraire le résultat.
+
+```js
+let Accounts = [
+    {
+        address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        balance: 5000,
+        nonce: 0,
+    },
+```
+
+La structure `Accounts` initiale.
+
+### Étape 3 - Contrats intelligents Ethereum {#stage-3}
+
+1. Arrêtez les processus du serveur et du client.
+
+2. Téléchargez la branche avec les contrats intelligents et assurez-vous que vous avez tous les modules nécessaires.
+
+   ```sh
+   git checkout 03-smart-contracts
+   cd client
+   npm install
+   cd ../server
+   npm install
+   ```
+
+3. Exécutez `anvil` dans une fenêtre de ligne de commande séparée.
+
+4. Générez la clé de vérification et le vérificateur de solidité, puis copiez le code du vérificateur dans le projet Solidity.
+
+   ```sh
+   cd noir
+   bb write_vk -b ./target/zkBank.json -o ./target --oracle_hash keccak
+   bb write_solidity_verifier -k ./target/vk -o ./target/Verifier.sol
+   cp target/Verifier.sol ../../smart-contracts/src
+   ```
+
+5. Allez dans les contrats intelligents et définissez les variables d'environnement pour utiliser la blockchain `anvil`.
+
+   ```sh
+   cd ../../smart-contracts
+   export ETH_RPC_URL=http://localhost:8545
+   ETH_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+   ```
+
+6. Déployez `Verifier.sol` et stockez l'adresse dans une variable d'environnement.
+
+   ```sh
+   VERIFIER_ADDRESS=`forge create src/Verifier.sol:HonkVerifier --private-key $ETH_PRIVATE_KEY --optimize --broadcast | awk '/Deployed to:/ {print $3}'`
+   echo $VERIFIER_ADDRESS
+   ```
+
+7. Déployez le contrat `ZkBank`.
+
+   ```sh
+   ZKBANK_ADDRESS=`forge create ZkBank --private-key $ETH_PRIVATE_KEY --broadcast --constructor-args $VERIFIER_ADDRESS 0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b | awk '/Deployed to:/ {print $3}'`
+   echo $ZKBANK_ADDRESS
+   ```
+
+   La valeur `0x199..67b` est le hachage de Pederson de l'état initial de `Comptes`. Si vous modifiez cet état initial dans `server/index.mjs`, vous pouvez exécuter une transaction pour voir le hachage initial rapporté par la preuve à divulgation nulle de connaissance.
+
+8. Lancez le serveur.
+
+   ```sh
+   cd ../server
+   npm run start
+   ```
+
+9. Exécutez le client dans une autre fenêtre de ligne de commande.
+
+   ```sh
+   cd client
+   npm run dev
+   ```
+
+10. Exécutez quelques transactions.
+
+11. Pour vérifier que l'état a changé sur la chaîne, redémarrez le processus du serveur. Voyez que `ZkBank` n'accepte plus les transactions, car la valeur de hachage originale dans les transactions diffère de la valeur de hachage stockée sur la chaîne.
+
+    C'est le type d'erreur attendu.
+
+    ```
+    ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+    > server@1.0.0 start
+    > node --experimental-json-modules index.mjs
+
+    Écoute sur le port 3000
+    Erreur de vérification : ContractFunctionExecutionError : La fonction de contrat "processTransaction" a été annulée pour la raison suivante :
+    Mauvais hachage de l'ancien état
+
+    Appel de contrat :
+        adresse :   0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
+        fonction :  processTransaction(bytes _proof, bytes32[] _publicInputs)
+        args :                        (0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf00000000000000000000000000000000000000000000000b75c020998797da7800000000000000000000000000000000000000000000000
+    ```
+
+#### `server/index.mjs` {#server-index-mjs-2}
+
+Les changements dans ce fichier concernent principalement la création de la preuve réelle et sa soumission sur la chaîne.
+
+```js
+import { exec } from 'child_process'
+import util from 'util'
+
+const execPromise = util.promisify(exec)
+```
+
+Nous devons utiliser [le paquet Barretenberg](https://github.com/AztecProtocol/aztec-packages/tree/next/barretenberg) pour créer la preuve réelle à envoyer sur la chaîne. Nous pouvons utiliser ce paquet soit en exécutant l'interface de ligne de commande (`bb`) soit en utilisant la [bibliothèque JavaScript, `bb.js`](https://www.npmjs.com/package/@aztec/bb.js). La bibliothèque JavaScript est beaucoup plus lente que l'exécution de code nativement, nous utilisons donc [`exec`](https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback) ici pour utiliser la ligne de commande.
+
+Notez que si vous décidez d'utiliser `bb.js`, vous devez utiliser une version compatible avec la version de Noir que vous utilisez. Au moment de la rédaction, la version actuelle de Noir (1.0.0-beta.11) utilise la version 0.87 de `bb.js`.
+
+```js
+const zkBankAddress = process.env.ZKBANK_ADDRESS || "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
+```
+
+L'adresse ici est celle que vous obtenez lorsque vous commencez avec un `anvil` propre et suivez les instructions ci-dessus.
+
+```js
+const walletClient = createWalletClient({ 
+    chain: anvil, 
+    transport: http(), 
+    account: privateKeyToAccount("0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6")
+})
+```
+
+Cette clé privée est l'un des comptes pré-financés par défaut dans `anvil`.
+
+```js
+const generateProof = async (witness, fileID) => {
+```
+
+Générer une preuve en utilisant l'exécutable `bb`.
+
+```js
+    const fname = `witness-${fileID}.gz`    
+    await fs.writeFile(fname, witness)
+```
+
+Écrivez le témoin dans un fichier.
+
+```js
+    await execPromise(`bb prove -b ./noir/target/zkBank.json -w ${fname} -o ${fileID} --oracle_hash keccak --output_format fields`)
+```
+
+Créez réellement la preuve. Cette étape crée également un fichier avec les variables publiques, mais nous n'en avons pas besoin. Nous avons déjà obtenu ces variables de `noir.execute`.
+
+```js
+    const proof = "0x" + JSON.parse(await fs.readFile(`./${fileID}/proof_fields.json`)).reduce((a,b) => a+b, "").replace(/0x/g, "")
+```
+
+La preuve est un tableau JSON de valeurs `Field`, chacune représentée par une valeur hexadécimale. Cependant, nous devons l'envoyer dans la transaction en tant que valeur `bytes` unique, que Viem représente par une grande chaîne hexadécimale. Ici, nous changeons le format en concaténant toutes les valeurs, en supprimant tous les `0x`, puis en en ajoutant un à la fin.
+
+```js
+    await execPromise(`rm -r ${fname} ${fileID}`)
+
+    return proof
+}
+```
+
+Nettoyez et retournez la preuve.
+
+```js
+const processMessage = async (message, signature) => {
+    .
+    .
+    .
+
+    const publicFields = noirResult.returnValue.map(x=>'0x' + x.slice(2).padStart(64, "0"))
+```
+
+Les champs publics doivent être un tableau de valeurs de 32 octets. Cependant, comme nous devions diviser le hachage de la transaction entre deux valeurs `Field`, il apparaît comme une valeur de 16 octets. Ici, nous ajoutons des zéros pour que Viem comprenne qu'il s'agit bien de 32 octets.
+
+```js
+    const proof = await generateProof(noirResult.witness, `${fromAddress}-${nonce}`)
+```
+
+Chaque adresse n'utilise chaque nonce qu'une seule fois, de sorte que nous pouvons utiliser une combinaison de `fromAddress` et `nonce` comme identifiant unique pour le fichier témoin et le répertoire de sortie.
+
+```js
+    try {
+        await zkBank.write.processTransaction([
+            proof, publicFields])
+    } catch (err) {
+        console.log(`Erreur de vérification : ${err}`)
+        throw Error("Impossible de vérifier la transaction sur la chaîne")
+    }
+    .
+    .
+    .
+}
+```
+
+Envoyez la transaction à la chaîne.
+
+#### `smart-contracts/src/ZkBank.sol` {#smart-contracts-src-zkbank-sol}
+
+Ceci est le code sur la chaîne qui reçoit la transaction.
+
+```solidity
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.21;
+
+import {HonkVerifier} from "./Verifier.sol";
+
+contract ZkBank {
+    HonkVerifier immutable myVerifier;
+    bytes32 currentStateHash;
+
+    constructor(address _verifierAddress, bytes32 _initialStateHash) {
+        currentStateHash = _initialStateHash;
+        myVerifier = HonkVerifier(_verifierAddress);
+    }
+```
+
+Le code sur la chaîne doit garder une trace de deux variables : le vérificateur (un contrat séparé créé par `nargo`) et le hachage de l'état actuel.
+
+```solidity
+    event TransactionProcessed(
+        bytes32 indexed transactionHash,
+        bytes32 oldStateHash,
+        bytes32 newStateHash
+    );
+```
+
+Chaque fois que l'état change, nous émettons un événement `TransactionProcessed`.
+
+```solidity
+    function processTransaction(
+        bytes calldata _proof,
+        bytes32[] calldata _publicFields
+    ) public {
+```
+
+Cette fonction traite les transactions. Elle reçoit la preuve (en tant que `bytes`) et les entrées publiques (en tant que tableau `bytes32`), dans le format requis par le vérificateur (pour minimiser le traitement sur la chaîne et donc les coûts de gaz).
+
+```solidity
+        require(_publicInputs[0] == currentStateHash,
+            "Mauvais hachage de l'ancien état");
+```
+
+La preuve à divulgation nulle de connaissance doit être que la transaction passe de notre hachage actuel à un nouveau.
+
+```solidity
+        myVerifier.verify(_proof, _publicFields);
+```
+
+Appeler le contrat vérificateur pour vérifier la preuve à divulgation nulle de connaissance. Cette étape annule la transaction si la preuve à divulgation nulle de connaissance est incorrecte.
+
+```solidity
+        currentStateHash = _publicFields[1];
+
+        emit TransactionProcessed(
+            _publicFields[2]<<128 | _publicFields[3],
+            _publicFields[0],
+            _publicFields[1]
+        );
+    }
+}
+```
+
+Si tout est correct, mettez à jour le hachage d'état avec la nouvelle valeur et émettez un événement `TransactionProcessed`.
+
+## Abus par le composant centralisé {#abuses}
+
+La sécurité de l'information se compose de trois attributs :
+
+- _Confidentialité_, les utilisateurs ne peuvent pas lire les informations qu'ils ne sont pas autorisés à lire.
+- _Intégrité_, les informations ne peuvent être modifiées que par des utilisateurs autorisés d'une manière autorisée.
+- _Disponibilité_, les utilisateurs autorisés peuvent utiliser le système.
+
+Sur ce système, l'intégrité est assurée par des preuves à divulgation nulle de connaissance. La disponibilité est beaucoup plus difficile à garantir, et la confidentialité est impossible, car la banque doit connaître le solde de chaque compte et toutes les transactions. Il n'y a aucun moyen d'empêcher une entité qui détient des informations de les partager.
+
+Il serait peut-être possible de créer une banque véritablement confidentielle en utilisant des [adresses furtives](https://vitalik.eth.limo/general/2023/01/20/stealth.html), mais cela dépasse le cadre de cet article.
+
+### Fausses informations {#false-info}
+
+Une façon pour le serveur de violer l'intégrité est de fournir de fausses informations lorsque [des données sont demandées](https://github.com/qbzzt/250911-zk-bank/blob/03-smart-contracts/server/index.mjs#L278-L291).
+
+Pour résoudre ce problème, nous pouvons écrire un deuxième programme Noir qui reçoit les comptes en tant qu'entrée privée et l'adresse pour laquelle des informations sont demandées en tant qu'entrée publique. La sortie est le solde et le nonce de cette adresse, et le hachage des comptes.
+
+Bien sûr, cette preuve ne peut pas être vérifiée sur la chaîne, car nous ne voulons pas publier de nonces et de soldes sur la chaîne. Cependant, elle peut être vérifiée par le code client s'exécutant dans le navigateur.
+
+### Transactions forcées {#forced-txns}
+
+Le mécanisme habituel pour garantir la disponibilité et empêcher la censure sur les L2 est les [transactions forcées](https://docs.optimism.io/stack/transactions/forced-transaction). Mais les transactions forcées ne se combinent pas avec les preuves à divulgation nulle de connaissance. Le serveur est la seule entité capable de vérifier les transactions.
+
+Nous pouvons modifier `smart-contracts/src/ZkBank.sol` pour accepter les transactions forcées et empêcher le serveur de changer l'état jusqu'à ce qu'elles soient traitées. Cependant, cela nous expose à une simple attaque par déni de service. Que se passe-t-il si une transaction forcée est invalide et donc impossible à traiter ?
+
+La solution consiste à avoir une preuve à divulgation nulle de connaissance qu'une transaction forcée est invalide. Cela donne au serveur trois options :
+
+- Traiter la transaction forcée, en fournissant une preuve à divulgation nulle de connaissance qu'elle a été traitée et le nouveau hachage d'état.
+- Rejeter la transaction forcée et fournir au contrat une preuve à divulgation nulle de connaissance que la transaction est invalide (adresse inconnue, mauvais nonce ou solde insuffisant).
+- Ignorer la transaction forcée. Il n'y a aucun moyen de forcer le serveur à traiter réellement la transaction, mais cela signifie que l'ensemble du système est indisponible.
+
+#### Cautionnement de disponibilité {#avail-bonds}
+
+Dans une implémentation réelle, il y aurait probablement une sorte de motivation de profit pour maintenir le serveur en fonctionnement. Nous pouvons renforcer cette incitation en faisant en sorte que le serveur dépose une caution de disponibilité que n'importe qui peut brûler si une transaction forcée n'est pas traitée dans un certain délai.
+
+### Mauvais code Noir {#bad-noir-code}
+
+Normalement, pour que les gens fassent confiance à un contrat intelligent, nous téléchargeons le code source sur un [explorateur de blocs](https://eth.blockscout.com/address/0x7D16d2c4e96BCFC8f815E15b771aC847EcbDB48b?tab=contract). Cependant, dans le cas des preuves à divulgation nulle de connaissance, cela est insuffisant.
+
+`Verifier.sol` contient la clé de vérification, qui est une fonction du programme Noir. Cependant, cette clé ne nous dit pas ce qu'était le programme Noir. Pour avoir une solution réellement fiable, vous devez télécharger le programme Noir (et la version qui l'a créé). Sinon, les preuves à divulgation nulle de connaissance pourraient refléter un programme différent, un programme avec une porte dérobée.
+
+Jusqu'à ce que les explorateurs de blocs nous permettent de télécharger et de vérifier les programmes Noir, vous devriez le faire vous-même (de préférence sur [IPFS](/developers/tutorials/ipfs-decentralized-ui/)). Alors, les utilisateurs avertis pourront télécharger le code source, le compiler eux-mêmes, créer `Verifier.sol`, et vérifier qu'il est identique à celui sur la chaîne.
+
+## Conclusion {#conclusion}
+
+Les applications de type Plasma nécessitent un composant centralisé pour le stockage des informations. Cela ouvre des vulnérabilités potentielles mais, en retour, nous permet de préserver la confidentialité de manières non disponibles sur la blockchain elle-même. Avec les preuves à divulgation nulle de connaissance, nous pouvons garantir l'intégrité et éventuellement rendre économiquement avantageux pour quiconque exécute le composant centralisé de maintenir la disponibilité.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
+
+## Remerciements {#acknowledgements}
+
+- Josh Crites a lu une ébauche de cet article et m'a aidé avec un problème épineux de Noir.
+
+Toute erreur restante est de ma responsabilité.
diff --git a/public/content/translations/fr/developers/tutorials/calling-a-smart-contract-from-javascript/index.md b/public/content/translations/fr/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
index 95005ce720f..dd997c04818 100644
--- a/public/content/translations/fr/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
+++ b/public/content/translations/fr/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
@@ -1,12 +1,8 @@
 ---
 title: Appeler un contrat intelligent depuis JavaScript
-description: Comment appeler une fonction de contrat intelligent à partir de JavaScript en utilisant un exemple de jeton Dai
+description: "Comment appeler une fonction de contrat intelligent à partir de JavaScript en utilisant un exemple de jeton Dai"
 author: jdourlens
-tags:
-  - "transactions"
-  - "frontend"
-  - "JavaScript"
-  - "web3.js"
+tags: [ "transactions", "frontend", "JavaScript", "web3.js" ]
 skill: beginner
 lang: fr
 published: 2020-04-19
@@ -15,15 +11,15 @@ sourceUrl: https://ethereumdev.io/calling-a-smart-contract-from-javascript/
 address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 ---
 
-Dans ce tutoriel, nous allons voir comment appeler une fonction de [contrat intelligent](/developers/docs/smart-contracts/) à partir de JavaScript. La première consiste à lire l'état d'un contrat intelligent (par exemple, le solde d'un détenteur d'ERC20), puis nous modifierons l'état de la blockchain en effectuant un transfert de jeton. Vous devriez déjà être familiarisé avec [la configuration d'un environnement JS pour interagir avec la blockchain](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/).
+Dans ce tutoriel, nous verrons comment appeler une fonction de [contrat intelligent](/developers/docs/smart-contracts/) à partir de JavaScript. La première étape consiste à lire l'état d'un contrat intelligent (par exemple, le solde d'un détenteur d'ERC20), puis nous modifierons l'état de la blockchain en effectuant un transfert de jeton. Vous devriez déjà être familiarisé avec [la configuration d'un environnement JS pour interagir avec la blockchain](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/).
 
-Pour cet exemple, nous allons jouer avec le jeton DAI, à des fins de test, nous allons créer une fourche de la blockchain en utilisant ganache-cli et débloquer une adresse qui a déjà beaucoup de DAI :
+Pour cet exemple, nous allons jouer avec le jeton DAI. À des fins de test, nous allons créer une fourche de la blockchain en utilisant ganache-cli et déverrouiller une adresse qui possède déjà beaucoup de DAI :
 
 ```bash
 ganache-cli -f https://mainnet.infura.io/v3/[YOUR INFURA KEY] -d -i 66 1 --unlock 0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81
 ```
 
-Pour interagir avec un contrat intelligent, nous avons besoin de son adresse et de son ABI :
+Pour interagir avec un contrat intelligent, nous aurons besoin de son adresse et de son ABI :
 
 ```js
 const ERC20TransferABI = [
@@ -74,7 +70,7 @@ const ERC20TransferABI = [
 const DAI_ADDRESS = "0x6b175474e89094c44da98b954eedeac495271d0f"
 ```
 
-Pour ce projet, nous avons dépouillé l'ABI ERC20 complet pour ne garder que les fonctions `balanceOf` et `transfer` mais vous pouvez trouver [l'ABI ERC20 complète ici](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/).
+Pour ce projet, nous avons réduit l'ABI ERC20 complet pour ne conserver que les fonctions `balanceOf` et `transfer`, mais vous pouvez trouver [l'ABI ERC20 complet ici](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/).
 
 Nous devons ensuite instancier notre contrat intelligent :
 
@@ -96,25 +92,25 @@ const receiverAddress = "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 
 Dans la partie suivante, nous allons appeler la fonction `balanceOf` pour récupérer la quantité actuelle de jetons que les deux adresses détiennent.
 
-## Appel : Lire la valeur d'un contrat intelligent {#call-reading-value-from-a-smart-contract}
+## Appel : lecture d'une valeur à partir d'un contrat intelligent {#call-reading-value-from-a-smart-contract}
 
 Le premier exemple appelle une méthode « constante » et exécute sa méthode de contrat intelligent dans l'EVM sans envoyer de transaction. Pour cela, nous allons lire le solde ERC20 d'une adresse. [Lisez notre article sur les jetons ERC20](/developers/tutorials/understand-the-erc-20-token-smart-contract/).
 
-Vous pouvez accéder aux méthodes d'un contrat intelligent instancié pour lequel vous avez fourni l'ABI comme suit : `yourContract.methods.methodname`. En utilisant la fonction `call`, vous recevrez le résultat de l'exécution de la fonction.
+Vous pouvez accéder aux méthodes d'un contrat intelligent instancié pour lesquelles vous avez fourni l'ABI comme suit : `yourContract.methods.methodname`. En utilisant la fonction `call`, vous recevrez le résultat de l'exécution de la fonction.
 
 ```js
 daiToken.methods.balanceOf(senderAddress).call(function (err, res) {
   if (err) {
-    console.log("An error occurred", err)
+    console.log("Une erreur s'est produite", err)
     return
   }
-  console.log("The balance is: ", res)
+  console.log("Le solde est : ", res)
 })
 ```
 
-N'oubliez pas que le DAI ERC20 comporte 18 décimales, ce qui signifie que vous devez supprimer 18 zéros pour obtenir le montant correct. Les uint256 sont retournés sous forme de chaînes de caractères, car JavaScript ne gère pas les grandes valeurs numériques. Si vous ne savez pas [comment traiter les grands nombres dans JS, consultez notre tutoriel sur bignumber.js](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/).
+N'oubliez pas que le DAI ERC20 a 18 décimales, ce qui signifie que vous devez supprimer 18 zéros pour obtenir le montant correct. Les uint256 sont retournés sous forme de chaînes de caractères, car JavaScript ne gère pas les grandes valeurs numériques. Si vous n'êtes pas sûr de [comment gérer les grands nombres en JS, consultez notre tutoriel sur bignumber.js](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/).
 
-## Envoyer : Envoi d'une transaction à une fonction de contrat intelligent {#send-sending-a-transaction-to-a-smart-contract-function}
+## Envoyer : envoi d'une transaction à une fonction de contrat intelligent {#send-sending-a-transaction-to-a-smart-contract-function}
 
 Pour le deuxième exemple, nous allons appeler la fonction de transfert du contrat intelligent DAI pour envoyer 10 DAI à notre deuxième adresse. La fonction de transfert accepte deux paramètres : l'adresse du destinataire et le montant du jeton à transférer.
 
@@ -123,13 +119,13 @@ daiToken.methods
   .transfer(receiverAddress, "100000000000000000000")
   .send({ from: senderAddress }, function (err, res) {
     if (err) {
-      console.log("An error occurred", err)
+      console.log("Une erreur s'est produite", err)
       return
     }
-    console.log("Hash of the transaction: " + res)
+    console.log("Hachage de la transaction : " + res)
   })
 ```
 
-La fonction d'appel renvoie le hachage de la transaction qui sera miné dans la blockchain. Sur Ethereum, les hachages de transaction sont prévisibles - c'est ainsi que nous pouvons obtenir le hachage de la transaction avant qu'elle ne soit exécutée ([apprenez comment les hachages sont calculés ici](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction)).
+La fonction d'appel renvoie le hachage de la transaction qui sera minée dans la blockchain. Sur Ethereum, les hachages de transaction sont prévisibles ; c'est ainsi que nous pouvons obtenir le hachage de la transaction avant son exécution ([apprenez ici comment les hachages sont calculés](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction)).
 
-Comme la fonction ne fait que soumettre la transaction à la blockchain, nous ne pouvons pas voir le résultat avant de savoir quand elle est minée et incluse dans la blockchain. Dans le prochain tutoriel, nous apprendrons[comment attendre pour qu'une transaction soit exécutée sur la blockchain en connaissant son hachage](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/).
+Comme la fonction ne fait que soumettre la transaction à la blockchain, nous ne pouvons pas voir le résultat tant que nous ne savons pas quand elle est minée et incluse dans la blockchain. Dans le prochain tutoriel, nous apprendrons [comment attendre qu'une transaction soit exécutée sur la blockchain en connaissant son hachage](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/).
diff --git a/public/content/translations/fr/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md b/public/content/translations/fr/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
new file mode 100644
index 00000000000..ee40bcf5a75
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
@@ -0,0 +1,585 @@
+---
+title: "Construire une interface utilisateur pour votre contrat"
+description: "En utilisant des composants modernes tels que TypeScript, React, Vite et Wagmi, nous allons passer en revue une interface utilisateur moderne, mais minimale, et apprendre à connecter un portefeuille à l'interface utilisateur, à appeler un contrat intelligent pour lire des informations, à envoyer une transaction à un contrat intelligent et à surveiller les événements d'un contrat intelligent pour identifier les changements."
+author: Ori Pomerantz
+tags: [ "TypeScript", "react", "vite", "wagmi", "frontend" ]
+skill: beginner
+published: 2023-11-01
+lang: fr
+sidebarDepth: 3
+---
+
+Vous avez trouvé une fonctionnalité dont nous avons besoin dans l'écosystème Ethereum. Vous avez écrit les contrats intelligents pour la mettre en œuvre, et peut-être même du code connexe qui s'exécute hors chaîne. C'est génial ! Malheureusement, sans interface utilisateur, vous n'aurez aucun utilisateur, et la dernière fois que vous avez écrit un site web, les gens utilisaient des modems commutés et JavaScript était nouveau.
+
+Cet article est pour vous. Je suppose que vous connaissez la programmation, et peut-être un peu de JavaScript et de HTML, mais que vos compétences en matière d'interface utilisateur sont rouillées et obsolètes. Ensemble, nous allons passer en revue une application moderne simple pour que vous puissiez voir comment on fait de nos jours.
+
+## Pourquoi est-ce important {#why-important}
+
+En théorie, vous pourriez simplement demander aux gens d'utiliser [Etherscan](https://holesky.etherscan.io/address/0x432d810484add7454ddb3b5311f0ac2e95cecea8#writeContract) ou [Blockscout](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=write_contract) pour interagir avec vos contrats. Ce sera formidable pour les Éthériens expérimentés. Mais nous essayons de servir [un autre milliard de personnes](https://blog.ethereum.org/2021/05/07/ethereum-for-the-next-billion). Cela ne se produira pas sans une excellente expérience utilisateur, et une interface utilisateur conviviale en est une grande partie.
+
+## Application Greeter {#greeter-app}
+
+Il y a beaucoup de théorie derrière le fonctionnement d'une interface utilisateur moderne, et [beaucoup de bons sites](https://react.dev/learn/thinking-in-react) [qui l'expliquent](https://wagmi.sh/core/getting-started). Au lieu de répéter l'excellent travail effectué par ces sites, je vais supposer que vous préférez apprendre par la pratique et commencer par une application avec laquelle vous pouvez jouer. Vous avez encore besoin de la théorie pour faire avancer les choses, et nous y viendrons - nous allons simplement parcourir les fichiers sources un par un, et discuter des choses au fur et à mesure que nous les abordons.
+
+### Installation {#installation}
+
+1. Si nécessaire, ajoutez [la blockchain Holesky](https://chainlist.org/?search=holesky&testnets=true) à votre portefeuille et [obtenez des ETH de test](https://www.holeskyfaucet.io/).
+
+2. Clonez le dépôt GitHub.
+
+   ```sh
+   git clone https://github.com/qbzzt/20230801-modern-ui.git
+   ```
+
+3. Installez les paquets nécessaires.
+
+   ```sh
+   cd 20230801-modern-ui
+   pnpm install
+   ```
+
+4. Démarrez l'application.
+
+   ```sh
+   pnpm dev
+   ```
+
+5. Naviguez vers l'URL affichée par l'application. Dans la plupart des cas, c'est [http://localhost:5173/](http://localhost:5173/).
+
+6. Vous pouvez voir le code source du contrat, une version légèrement modifiée du Greeter de Hardhat, [sur un explorateur de blockchain](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=contract).
+
+### Présentation des fichiers {#file-walk-through}
+
+#### `index.html` {#index-html}
+
+Ce fichier est un modèle HTML standard, à l'exception de cette ligne, qui importe le fichier de script.
+
+```html
+<script type="module" src="/src/main.tsx"></script>
+```
+
+#### `src/main.tsx` {#main-tsx}
+
+L'extension du fichier nous indique que ce fichier est un [composant React](https://www.w3schools.com/react/react_components.asp) écrit en [TypeScript](https://www.typescriptlang.org/), une extension de JavaScript qui prend en charge la [vérification de type](https://en.wikipedia.org/wiki/Type_system#Type_checking). TypeScript est compilé en JavaScript, nous pouvons donc l'utiliser pour l'exécution côté client.
+
+```tsx
+import '@rainbow-me/rainbowkit/styles.css'
+import { RainbowKitProvider } from '@rainbow-me/rainbowkit'
+import * as React from 'react'
+import * as ReactDOM from 'react-dom/client'
+import { WagmiConfig } from 'wagmi'
+import { chains, config } from './wagmi'
+```
+
+Importez le code de la bibliothèque dont nous avons besoin.
+
+```tsx
+import { App } from './App'
+```
+
+Importez le composant React qui met en œuvre l'application (voir ci-dessous).
+
+```tsx
+ReactDOM.createRoot(document.getElementById('root')!).render(
+```
+
+Créez le composant React racine. Le paramètre de `render` est [JSX](https://www.w3schools.com/react/react_jsx.asp), un langage d'extension qui utilise à la fois HTML et JavaScript/TypeScript. Le point d'exclamation ici indique au composant TypeScript : « vous ne savez pas que `document.getElementById('root')` sera un paramètre valide pour `ReactDOM.createRoot`, mais ne vous inquiétez pas - je suis le développeur et je vous dis qu'il y en aura un ».
+
+```tsx
+  <React.StrictMode>
+```
+
+L'application se trouve à l'intérieur d'un [composant `React.StrictMode`](https://react.dev/reference/react/StrictMode). Ce composant indique à la bibliothèque React d'insérer des vérifications de débogage supplémentaires, ce qui est utile pendant le développement.
+
+```tsx
+    <WagmiConfig config={config}>
+```
+
+L'application se trouve également à l'intérieur d'un [composant `WagmiConfig`](https://wagmi.sh/react/api/WagmiProvider). [La bibliothèque wagmi (we are going to make it)](https://wagmi.sh/) connecte les définitions de l'interface utilisateur React avec [la bibliothèque viem](https://viem.sh/) pour l'écriture d'une application décentralisée Ethereum.
+
+```tsx
+      <RainbowKitProvider chains={chains}>
+```
+
+Et enfin, [un composant `RainbowKitProvider`](https://www.rainbowkit.com/). Ce composant gère la connexion et la communication entre le portefeuille et l'application.
+
+```tsx
+        <App />
+```
+
+Nous pouvons maintenant avoir le composant pour l'application, qui met réellement en œuvre l'interface utilisateur. Le `/>` à la fin du composant indique à React que ce composant n'a pas de définitions à l'intérieur, conformément à la norme XML.
+
+```tsx
+      </RainbowKitProvider>
+    </WagmiConfig>
+  </React.StrictMode>,
+)
+```
+
+Bien sûr, nous devons fermer les autres composants.
+
+#### `src/App.tsx` {#app-tsx}
+
+```tsx
+import { ConnectButton } from '@rainbow-me/rainbowkit'
+import { useAccount } from 'wagmi'
+import { Greeter } from './components/Greeter'
+
+export function App() {
+```
+
+C'est la manière standard de créer un composant React - définir une fonction qui est appelée chaque fois qu'elle doit être rendue. Cette fonction a généralement du code TypeScript ou JavaScript en haut, suivi d'une instruction `return` qui renvoie le code JSX.
+
+```tsx
+  const { isConnected } = useAccount()
+```
+
+Ici, nous utilisons [`useAccount`](https://wagmi.sh/react/api/hooks/useAccount) pour vérifier si nous sommes connectés à une blockchain via un portefeuille ou non.
+
+Par convention, dans React, les fonctions appelées `use...` sont des [hooks](https://www.w3schools.com/react/react_hooks.asp) qui renvoient un certain type de données. Lorsque vous utilisez de tels hooks, non seulement votre composant obtient les données, mais lorsque ces données changent, le composant est re-rendu avec les informations mises à jour.
+
+```tsx
+  return (
+    <>
+```
+
+Le JSX d'un composant React _doit_ renvoyer un seul composant. Lorsque nous avons plusieurs composants et que nous n'avons rien qui les englobe « naturellement », nous utilisons un composant vide (`<> ... </>`) pour en faire un seul composant.
+
+```tsx
+      <h1>Greeter</h1>
+      <ConnectButton />
+```
+
+Nous obtenons [le composant `ConnectButton`](https://www.rainbowkit.com/docs/connect-button) de RainbowKit. Lorsque nous ne sommes pas connectés, il nous donne un bouton `Connect Wallet` qui ouvre une fenêtre modale qui explique les portefeuilles et vous permet de choisir celui que vous utilisez. Lorsque nous sommes connectés, il affiche la blockchain que nous utilisons, l'adresse de notre compte et notre solde d'ETH. Nous pouvons utiliser ces affichages pour changer de réseau ou pour nous déconnecter.
+
+```tsx
+      {isConnected && (
+```
+
+Lorsque nous devons insérer du JavaScript réel (ou du TypeScript qui sera compilé en JavaScript) dans un JSX, nous utilisons des accolades (`{}`).
+
+La syntaxe `a && b` est un raccourci pour [`a ?` b : a`](https://www.w3schools.com/react/react_es6_ternary.asp). C'est-à-dire que si `a`est vrai, il est évalué à`b`et sinon, il est évalué à`a`(qui peut être`false`, `0`, etc.). C'est un moyen facile d'indiquer à React qu'un composant ne doit être affiché que si une certaine condition est remplie.
+
+Dans ce cas, nous ne voulons montrer à l'utilisateur `Greeter` que si l'utilisateur est connecté à une blockchain.
+
+```tsx
+          <Greeter />
+      )}
+    </>
+  )
+}
+```
+
+#### `src/components/Greeter.tsx` {#greeter-tsx}
+
+Ce fichier contient la plupart des fonctionnalités de l'interface utilisateur. Il inclut des définitions qui seraient normalement dans plusieurs fichiers, mais comme il s'agit d'un tutoriel, le programme est optimisé pour être facile à comprendre la première fois, plutôt que pour la performance ou la facilité de maintenance.
+
+```tsx
+import { useState, ChangeEventHandler } from 'react'
+import {  useNetwork,
+          useReadContract,
+          usePrepareContractWrite,
+          useContractWrite,
+          useContractEvent
+        } from 'wagmi'
+```
+
+Nous utilisons ces fonctions de bibliothèque. Encore une fois, elles sont expliquées ci-dessous là où elles sont utilisées.
+
+```tsx
+import { AddressType } from 'abitype'
+```
+
+[La bibliothèque `abitype`](https://abitype.dev/) nous fournit des définitions TypeScript pour divers types de données Ethereum, tels que [`AddressType`](https://abitype.dev/config#addresstype).
+
+```tsx
+let greeterABI = [
+  .
+  .
+  .
+] as const   // greeterABI
+```
+
+L'ABI pour le contrat `Greeter`.
+Si vous développez les contrats et l'interface utilisateur en même temps, vous les placez normalement dans le même dépôt et utilisez l'ABI généré par le compilateur Solidity comme fichier dans votre application. Cependant, ce n'est pas nécessaire ici car le contrat est déjà développé et ne va pas changer.
+
+```tsx
+type AddressPerBlockchainType = {
+  [key: number]: AddressType
+}
+```
+
+TypeScript est fortement typé. Nous utilisons cette définition pour spécifier l'adresse à laquelle le contrat `Greeter` est déployé sur différentes chaînes. La clé est un nombre (le chainId), et la valeur est un `AddressType` (une adresse).
+
+```tsx
+const contractAddrs: AddressPerBlockchainType = {
+  // Holesky
+  17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+
+  // Sepolia
+  11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+}
+```
+
+L'adresse du contrat sur les deux réseaux pris en charge : [Holesky](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=contact_code) et [Sepolia](https://eth-sepolia.blockscout.com/address/0x7143d5c190F048C8d19fe325b748b081903E3BF0?tab=contact_code).
+
+Note : Il y a en fait une troisième définition, pour Redstone Holesky, elle sera expliquée ci-dessous.
+
+```tsx
+type ShowObjectAttrsType = {
+  name: string,
+  object: any
+}
+```
+
+Ce type est utilisé comme paramètre pour le composant `ShowObject` (expliqué plus tard). Il inclut le nom de l'objet et sa valeur, qui sont affichés à des fins de débogage.
+
+```tsx
+type ShowGreetingAttrsType = {
+  greeting: string | undefined
+}
+```
+
+À tout moment, nous pouvons soit savoir quel est le message d'accueil (parce que nous l'avons lu sur la blockchain), soit ne pas le savoir (parce que nous ne l'avons pas encore reçu). Il est donc utile d'avoir un type qui peut être soit une chaîne de caractères, soit rien.
+
+##### Composant `Greeter` {#greeter-component}
+
+```tsx
+const Greeter = () => {
+```
+
+Enfin, nous arrivons à la définition du composant.
+
+```tsx
+  const { chain } = useNetwork()
+```
+
+Informations sur la chaîne que nous utilisons, gracieuseté de [wagmi](https://wagmi.sh/react/hooks/useNetwork).
+Comme il s'agit d'un hook (`use...`), chaque fois que cette information change, le composant est redessiné.
+
+```tsx
+  const greeterAddr = chain && contractAddrs[chain.id]
+```
+
+L'adresse du contrat Greeter, qui varie selon la chaîne (et qui est `undefined` si nous n'avons pas d'informations sur la chaîne ou si nous sommes sur une chaîne sans ce contrat).
+
+```tsx
+  const readResults = useReadContract({
+    address: greeterAddr,
+    abi: greeterABI,
+    functionName: "greet" , // Pas d'arguments
+    watch: true
+  })
+```
+
+[Le hook `useReadContract`](https://wagmi.sh/react/api/hooks/useReadContract) lit les informations d'un contrat. Vous pouvez voir exactement quelles informations il renvoie en développant `readResults` dans l'interface utilisateur. Dans ce cas, nous voulons qu'il continue à chercher afin d'être informés lorsque le message d'accueil change.
+
+**Note :** Nous pourrions écouter les [événements `setGreeting`](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=logs) pour savoir quand le message d'accueil change et le mettre à jour de cette manière. Cependant, bien que cela puisse être plus efficace, cela ne s'appliquera pas dans tous les cas. Lorsque l'utilisateur passe à une chaîne différente, le message d'accueil change également, mais ce changement n'est pas accompagné d'un événement. Nous pourrions avoir une partie du code qui écoute les événements et une autre qui identifie les changements de chaîne, mais ce serait plus compliqué que de simplement définir [le paramètre `watch`](https://wagmi.sh/react/api/hooks/useReadContract#watch-optional).
+
+```tsx
+  const [ newGreeting, setNewGreeting ] = useState("")
+```
+
+Le [`hook useState` de React](https://www.w3schools.com/react/react_usestate.asp) nous permet de spécifier une variable d'état, dont la valeur persiste d'un rendu du composant à un autre. La valeur initiale est le paramètre, dans ce cas la chaîne vide.
+
+Le hook `useState` renvoie une liste avec deux valeurs :
+
+1. La valeur actuelle de la variable d'état.
+2. Une fonction pour modifier la variable d'état si nécessaire. Comme il s'agit d'un hook, chaque fois qu'il est appelé, le composant est à nouveau rendu.
+
+Dans ce cas, nous utilisons une variable d'état pour le nouveau message d'accueil que l'utilisateur veut définir.
+
+```tsx
+  const greetingChange : ChangeEventHandler<HTMLInputElement> = (evt) =>
+    setNewGreeting(evt.target.value)
+```
+
+C'est le gestionnaire d'événements pour le changement du champ de saisie du nouveau message d'accueil. Le type, [`ChangeEventHandler<HTMLInputElement>`](https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forms_and_events/), spécifie qu'il s'agit d'un gestionnaire pour un changement de valeur d'un élément d'entrée HTML. La partie `<HTMLInputElement>` est utilisée car il s'agit d'un [type générique](https://www.w3schools.com/typescript/typescript_basic_generics.php).
+
+```tsx
+  const preparedTx = usePrepareContractWrite({
+    address: greeterAddr,
+    abi: greeterABI,
+    functionName: 'setGreeting',
+    args: [ newGreeting ]
+  })
+  const workingTx = useContractWrite(preparedTx.config)
+```
+
+Voici le processus pour soumettre une transaction blockchain du point de vue du client :
+
+1. Envoyez la transaction à un nœud de la blockchain en utilisant [`eth_estimateGas`](https://docs.alchemy.com/reference/eth-estimategas).
+2. Attendez une réponse du nœud.
+3. Lorsque la réponse est reçue, demandez à l'utilisateur de signer la transaction via le portefeuille. Cette étape _doit_ avoir lieu après la réception de la réponse du nœud, car le coût en gaz de la transaction est montré à l'utilisateur avant qu'il ne la signe.
+4. Attendez l'approbation de l'utilisateur.
+5. Envoyez à nouveau la transaction, cette fois en utilisant [`eth_sendRawTransaction`](https://docs.alchemy.com/reference/eth-sendrawtransaction).
+
+L'étape 2 est susceptible de prendre un temps perceptible, pendant lequel les utilisateurs se demanderaient si leur commande a bien été reçue par l'interface utilisateur et pourquoi on ne leur demande pas déjà de signer la transaction. Cela crée une mauvaise expérience utilisateur (UX).
+
+La solution est d'utiliser des [hooks de préparation](https://wagmi.sh/react/prepare-hooks). Chaque fois qu'un paramètre change, envoyez immédiatement au nœud la requête `eth_estimateGas`. Ensuite, lorsque l'utilisateur veut réellement envoyer la transaction (dans ce cas en appuyant sur **Mettre à jour le message d'accueil**), le coût en gaz est connu et l'utilisateur peut voir la page du portefeuille immédiatement.
+
+```tsx
+  return (
+```
+
+Nous pouvons maintenant enfin créer le HTML réel à renvoyer.
+
+```tsx
+    <>
+      <h2>Greeter</h2>
+      {
+        !readResults.isError && !readResults.isLoading &&
+          <ShowGreeting greeting={readResults.data} />
+      }
+      <hr />
+```
+
+Créez le composant `ShowGreeting` (expliqué ci-dessous), mais uniquement si le message d'accueil a été lu avec succès à partir de la blockchain.
+
+```tsx
+      <input type="text"
+        value={newGreeting}
+        onChange={greetingChange}
+      />
+```
+
+C'est le champ de saisie de texte où l'utilisateur peut définir un nouveau message d'accueil. Chaque fois que l'utilisateur appuie sur une touche, nous appelons `greetingChange` qui appelle `setNewGreeting`. Comme `setNewGreeting` provient du hook `useState`, il provoque un nouveau rendu du composant `Greeter`. Cela signifie que :
+
+- Nous devons spécifier `value` pour conserver la valeur du nouveau message d'accueil, sinon il reviendrait à la valeur par défaut, la chaîne vide.
+- `usePrepareContractWrite` est appelé chaque fois que `newGreeting` change, ce qui signifie qu'il aura toujours le dernier `newGreeting` dans la transaction préparée.
+
+```tsx
+      <button disabled={!workingTx.write}
+              onClick={workingTx.write}
+      >
+        Mettre à jour le message d'accueil
+      </button>
+```
+
+S'il n'y a pas de `workingTx.write`, nous attendons toujours les informations nécessaires pour envoyer la mise à jour du message d'accueil, donc le bouton est désactivé. S'il y a une valeur `workingTx.write`, alors c'est la fonction à appeler pour envoyer la transaction.
+
+```tsx
+      <hr />
+      <ShowObject name="readResults" object={readResults} />
+      <ShowObject name="preparedTx" object={preparedTx} />
+      <ShowObject name="workingTx" object={workingTx} />
+    </>
+  )
+}
+```
+
+Enfin, pour vous aider à voir ce que nous faisons, montrez les trois objets que nous utilisons :
+
+- `readResults`
+- `preparedTx`
+- `workingTx`
+
+##### Composant `ShowGreeting` {#showgreeting-component}
+
+Ce composant montre
+
+```tsx
+const ShowGreeting = (attrs : ShowGreetingAttrsType) => {
+```
+
+Une fonction de composant reçoit un paramètre avec tous les attributs du composant.
+
+```tsx
+  return <b>{attrs.greeting}</b>
+}
+```
+
+##### Composant `ShowObject` {#showobject-component}
+
+À titre d'information, nous utilisons le composant `ShowObject` pour montrer les objets importants (`readResults` pour la lecture du message d'accueil et `preparedTx` et `workingTx` pour les transactions que nous créons).
+
+```tsx
+const ShowObject = (attrs: ShowObjectAttrsType ) => {
+  const keys = Object.keys(attrs.object)
+  const funs = keys.filter(k => typeof attrs.object[k] == "function")
+  return <>
+    <details>
+```
+
+Nous ne voulons pas encombrer l'interface utilisateur avec toutes les informations, donc pour permettre de les voir ou de les fermer, nous utilisons une balise [`details`](https://www.w3schools.com/tags/tag_details.asp).
+
+```tsx
+      <summary>{attrs.name}</summary>
+      <pre>
+        {JSON.stringify(attrs.object, null, 2)}
+```
+
+La plupart des champs sont affichés en utilisant [`JSON.stringify`](https://www.w3schools.com/js/js_json_stringify.asp).
+
+```tsx
+      </pre>
+      { funs.length > 0 &&
+        <>
+          Fonctions :
+          <ul>
+```
+
+L'exception concerne les fonctions, qui ne font pas partie de [la norme JSON](https://www.json.org/json-en.html), elles doivent donc être affichées séparément.
+
+```tsx
+          {funs.map((f, i) =>
+```
+
+Dans JSX, le code à l'intérieur des accolades `{` `}` est interprété comme du JavaScript. Ensuite, le code à l'intérieur des parenthèses `( )` est interprété à nouveau comme du JSX.
+
+```tsx
+           (<li key={i}>{f}</li>)
+                )}
+```
+
+React exige que les balises dans [l'arbre DOM](https://www.w3schools.com/js/js_htmldom.asp) aient des identifiants distincts. Cela signifie que les enfants de la même balise (dans ce cas, [la liste non ordonnée](https://www.w3schools.com/tags/tag_ul.asp)), ont besoin d'attributs `key` différents.
+
+```tsx
+          </ul>
+        </>
+      }
+    </details>
+  </>
+}
+```
+
+Terminez les différentes balises HTML.
+
+##### L'exportation finale {#the-final-export}
+
+```tsx
+export { Greeter }
+```
+
+Le composant `Greeter` est celui que nous devons exporter pour l'application.
+
+#### `src/wagmi.ts` {#wagmi-ts}
+
+Enfin, diverses définitions liées à WAGMI se trouvent dans `src/wagmi.ts`. Je ne vais pas tout expliquer ici, car la plupart est du code passe-partout que vous n'aurez probablement pas besoin de changer.
+
+Le code ici n'est pas exactement le même que [sur GitHub](https://github.com/qbzzt/20230801-modern-ui/blob/main/src/wagmi.ts) car plus tard dans l'article, nous ajoutons une autre chaîne ([Redstone Holesky](https://redstone.xyz/docs/network-info)).
+
+```ts
+import { getDefaultWallets } from '@rainbow-me/rainbowkit'
+import { configureChains, createConfig } from 'wagmi'
+import { holesky, sepolia } from 'wagmi/chains'
+```
+
+Importez les blockchains que l'application prend en charge. Vous pouvez voir la liste des chaînes prises en charge [dans le GitHub de viem](https://github.com/wagmi-dev/viem/tree/main/src/chains/definitions).
+
+```ts
+import { publicProvider } from 'wagmi/providers/public'
+
+const walletConnectProjectId = 'c96e690bb92b6311e8e9b2a6a22df575'
+```
+
+Pour pouvoir utiliser [WalletConnect](https://walletconnect.com/), vous avez besoin d'un ID de projet pour votre application. Vous pouvez l'obtenir sur [cloud.walletconnect.com](https://cloud.walletconnect.com/sign-in).
+
+```ts
+const { chains, publicClient, webSocketPublicClient } = configureChains(
+  [ holesky, sepolia ],
+  [
+    publicProvider(),
+  ],
+)
+
+const { connectors } = getDefaultWallets({
+  appName: 'My wagmi + RainbowKit App',
+  chains,
+  projectId: walletConnectProjectId,
+})
+
+export const config = createConfig({
+  autoConnect: true,
+  connectors,
+  publicClient,
+  webSocketPublicClient,
+})
+
+export { chains }
+```
+
+### Ajouter une autre blockchain {#add-blockchain}
+
+De nos jours, il existe de nombreuses [solutions de mise à l'échelle de couche 2](/layer-2/), et vous pourriez vouloir en prendre en charge certaines que viem ne prend pas encore en charge. Pour ce faire, vous devez modifier `src/wagmi.ts`. Ces instructions expliquent comment ajouter [Redstone Holesky](https://redstone.xyz/docs/network-info).
+
+1. Importez le type `defineChain` depuis viem.
+
+   ```ts
+   import { defineChain } from 'viem'
+   ```
+
+2. Ajoutez la définition du réseau.
+
+   ```ts
+   const redstoneHolesky = defineChain({
+      id: 17_001,
+      name: 'Redstone Holesky',
+      network: 'redstone-holesky',
+      nativeCurrency: {
+        decimals: 18,
+        name: 'Ether',
+        symbol: 'ETH',
+      },
+      rpcUrls: {
+        default: {
+          http: ['https://rpc.holesky.redstone.xyz'],
+          webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+      },
+      public: {
+          http: ['https://rpc.holesky.redstone.xyz'],
+          webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+        },
+      },
+      blockExplorers: {
+        default: { name: 'Explorer', url: 'https://explorer.holesky.redstone.xyz' },
+      },
+   })
+   ```
+
+3. Ajoutez la nouvelle chaîne à l'appel `configureChains`.
+
+   ```ts
+    const { chains, publicClient, webSocketPublicClient } = configureChains(
+      [ holesky, sepolia, redstoneHolesky ],
+      [ publicProvider(), ],
+    )
+   ```
+
+4. Assurez-vous que l'application connaît l'adresse de vos contrats sur le nouveau réseau. Dans ce cas, nous modifions `src/components/Greeter.tsx` :
+
+    ```ts
+    const contractAddrs : AddressPerBlockchainType = {
+      // Holesky
+      17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+    
+      // Redstone Holesky
+      17001: '0x4919517f82a1B89a32392E1BF72ec827ba9986D3',
+    
+      // Sepolia
+      11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+    }
+    ```
+
+## Conclusion {#conclusion}
+
+Bien sûr, vous ne vous souciez pas vraiment de fournir une interface utilisateur pour `Greeter`. Vous voulez créer une interface utilisateur pour vos propres contrats. Pour créer votre propre application, suivez ces étapes :
+
+1. Spécifiez la création d'une application wagmi.
+
+   ```sh copy
+   pnpm create wagmi
+   ```
+
+2. Nommez l'application.
+
+3. Sélectionnez le framework **React**.
+
+4. Sélectionnez la variante **Vite**.
+
+5. Vous pouvez [ajouter le kit Rainbow](https://www.rainbowkit.com/docs/installation#manual-setup).
+
+Maintenant, allez rendre vos contrats utilisables pour le monde entier.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/fr/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/fr/developers/tutorials/deploying-your-first-smart-contract/index.md
index 5944d2fa576..5c2448ba00a 100644
--- a/public/content/translations/fr/developers/tutorials/deploying-your-first-smart-contract/index.md
+++ b/public/content/translations/fr/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -1,12 +1,14 @@
 ---
-title: Déployer votre premier contrat intelligent
-description: Introduction au déploiement de votre premier contrat intelligent sur le réseau de test Ethereum
+title: "Déployer votre premier contrat intelligent"
+description: "Introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum"
 author: "jdourlens"
 tags:
-  - "contrats intelligents"
-  - "remix"
-  - "solidity"
-  - "déploiement"
+  [
+    "contrats intelligents",
+    "Remix",
+    "Solidity",
+    "déploiement"
+  ]
 skill: beginner
 lang: fr
 published: 2020-04-03
@@ -17,15 +19,15 @@ address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 
 Je suppose que vous êtes aussi enthousiaste que nous à l'idée de [déployer](/developers/docs/smart-contracts/deploying/) et d'interagir avec votre premier [contrat intelligent](/developers/docs/smart-contracts/) sur la blockchain Ethereum.
 
-Pas d'inquiétude, comme il s'agit de notre premier contrat, nous le déploierons sur un [réseau de test local](/developers/docs/networks/) afin qu'il ne vous coûte rien de le déployer et de vous amuser autant que vous le souhaitez avec.
+Ne vous inquiétez pas, comme il s'agit de notre premier contrat intelligent, nous le déploierons sur un [réseau de test local](/developers/docs/networks/) afin que son déploiement et son utilisation ne vous coûtent rien et que vous puissiez l'utiliser autant que vous le souhaitez.
 
 ## Rédiger notre contrat {#writing-our-contract}
 
-La première étape est de [visiter Remix](https://remix.ethereum.org/) et de créer un nouveau fichier. Dans la partie supérieure gauche de l'interface Remix ajoutez un nouveau fichier et entrez le nom de fichier que vous voulez.
+La première étape consiste à [visiter Remix](https://remix.ethereum.org/) et à créer un nouveau fichier. Dans la partie supérieure gauche de l'interface Remix, ajoutez un nouveau fichier et saisissez le nom de fichier que vous souhaitez.
 
 ![Ajout d'un nouveau fichier dans l'interface Remix](./remix.png)
 
-Dans ce nouveau fichier, nous collerons le code suivant.
+Dans le nouveau fichier, nous allons coller le code suivant.
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -33,15 +35,15 @@ pragma solidity >=0.5.17;
 
 contract Counter {
 
-    // Public variable of type unsigned int to keep the number of counts
+    // Variable publique de type entier non signé pour conserver le nombre de comptages
     uint256 public count = 0;
 
-    // Function that increments our counter
+    // Fonction qui incrémente notre compteur
     function increment() public {
         count += 1;
     }
 
-    // Not necessary getter to get the count value
+    // Accesseur non nécessaire pour obtenir la valeur du compteur
     function getCount() public view returns (uint256) {
         return count;
     }
@@ -49,51 +51,51 @@ contract Counter {
 }
 ```
 
-Si vous êtes un habitué de la programmation, vous pouvez facilement deviner ce que fait ce programme. Voici une explication ligne par ligne :
+Si vous êtes habitué à la programmation, vous pouvez facilement deviner ce que fait ce programme. Voici une explication ligne par ligne :
 
-- Ligne 4 : Nous définissons un contrat portant le nom `Counter`.
-- Ligne 7 : Notre contrat stocke un entier non signé nommé `count` commençant à 0.
-- Ligne 10 : La première fonction va modifier l'état du contrat et `incrémenter()` notre variable `count`.
-- Ligne 15 : La seconde fonction permet de lire la valeur de la variable `count` en dehors du contrat intelligent. Notez que, comme nous avons défini notre variable `count` comme étant publique, ce n'est pas nécessaire mais est montré comme exemple.
+- Ligne 4 : nous définissons un contrat avec le nom `Counter`.
+- Ligne 7 : notre contrat stocke un entier non signé nommé `count` commençant à 0.
+- Ligne 10 : la première fonction modifiera l'état du contrat et `increment()` notre variable `count`.
+- Ligne 15 : la seconde fonction est juste un accesseur (« getter ») pour pouvoir lire la valeur de la variable `count` en dehors du contrat intelligent. Notez que, comme nous avons défini notre variable `count` comme publique, cela n'est pas nécessaire mais est montré à titre d'exemple.
 
-Tout cela pour notre premier contrat intelligent simple. Comme vous le savez peut-être, il ressemble à une classe des langages OOP (Object-Oriented Programming) comme Java ou C++. Il est maintenant temps de jouer avec notre contrat.
+C'est tout pour notre premier contrat intelligent simple. Comme vous le savez peut-être, cela ressemble à une classe de langages POO (programmation orientée objet) comme Java ou C++. Il est maintenant temps d'interagir avec notre contrat.
 
-## Déployer notre contract {#deploying-our-contract}
+## Déployer notre contrat {#deploying-our-contract}
 
-Notre tout premier contrat intelligent ayant été rédigé, nous allons maintenant le déployer sur la blockchain pour pouvoir jouer avec lui.
+Maintenant que nous avons écrit notre tout premier contrat intelligent, nous allons le déployer sur la blockchain pour pouvoir interagir avec.
 
-[Déployer le contrat intelligent sur la blockchain](/developers/docs/smart-contracts/deploying/) consiste en fait à envoyer une transaction contenant le code du contrat intelligent compilé sans spécifier de destinataires.
+[Déployer le contrat intelligent sur la blockchain](/developers/docs/smart-contracts/deploying/) consiste en fait simplement à envoyer une transaction contenant le code du contrat intelligent compilé sans spécifier de destinataires.
 
-Nous allons d'abord [compiler le contrat](/developers/docs/smart-contracts/compiling/) en cliquant sur l'icône de compilation sur le côté gauche :
+Nous allons d'abord [compiler le contrat](/developers/docs/smart-contracts/compiling/) en cliquant sur l'icône de compilation sur le côté gauche :
 
-![L'icône de compilation dans la barre d'outils Remix](./remix-compile-button.png)
+![L'icône de compilation dans la barre d'outils de Remix](./remix-compile-button.png)
 
-Cliquez ensuite sur le bouton compiler :
+Cliquez ensuite sur le bouton de compilation :
 
-![Le bouton de compilation dans le compilateur solidity de Remix](./remix-compile.png)
+![Le bouton de compilation dans le compilateur Solidity de Remix](./remix-compile.png)
 
-Vous pouvez choisir de sélectionner l’option "Compilation automatique" pour que le contrat soit toujours compilé lorsque vous enregistrez le contenu dans l’éditeur de texte.
+Vous pouvez choisir de sélectionner l'option « Auto compile » afin que le contrat soit toujours compilé lorsque vous sauvegardez le contenu dans l'éditeur de texte.
 
-Ensuite, accédez à l'écran "déployer et executer" des transactions :
+Ensuite, naviguez vers l'écran « déployer et exécuter les transactions » :
 
-![L'icône deployer dans la barre d'outils Remix](./remix-deploy.png)
+![L'icône de déploiement dans la barre d'outils Remix](./remix-deploy.png)
 
-Une fois que vous êtes sur l’écran "déployer et exécuter", vérifiez que le nom de votre contrat apparaît et cliquez sur déployer. Comme vous pouvez le voir en haut de la page, l'environnement actuel est "JavaScript VM", ce qui signifie que nous allons déployer et interagir avec notre contrat intelligent sur une blockchain de test locale pour être en mesure de tester plus rapidement et sans frais.
+Une fois que vous êtes sur l'écran « déployer et exécuter les transactions », vérifiez bien que le nom de votre contrat apparaisse et cliquez sur Déployer. Comme vous pouvez le voir en haut de la page, l'environnement actuel est « JavaScript VM », ce qui signifie que nous allons déployer et interagir avec notre contrat intelligent sur une blockchain de test locale pour pouvoir tester plus rapidement et sans frais.
 
-![Le bouton deployer dans le compilateur solidity de Remix](./remix-deploy-button.png)
+![Le bouton de déploiement dans le compilateur Solidity de Remix](./remix-deploy-button.png)
 
-Une fois que vous avez cliqué sur le bouton « Déployer », vous verrez votre contrat apparaître en bas de page. Cliquez sur la flèche à gauche pour la développer pour voir le contenu de notre contrat. Ceci est notre variable `counter`, notre fonction `increment()` et l'accesseur `getCounter()`.
+Une fois que vous avez cliqué sur le bouton « Déployer », vous verrez votre contrat apparaître en bas. Cliquez sur la flèche à gauche pour le développer afin de voir le contenu de notre contrat. Il s'agit de notre variable `counter`, de notre fonction `increment()` et de l'accesseur `getCounter()`.
 
-Si vous cliquez sur le bouton `count` ou `getCount` , il récupérera le contenu de la variable `count` du contrat et l'affichera. Comme nous n'avons pas encore appelé la fonction `incrément` , elle devrait afficher 0.
+Si vous cliquez sur le bouton `count` ou `getCount`, le contenu de la variable `count` du contrat sera récupéré et affiché. Comme nous n'avons pas encore appelé la fonction `increment`, la valeur 0 devrait s'afficher.
 
-![Le bouton de fonction dans le compilateur solidity de Remix](./remix-function-button.png)
+![Le bouton de fonction dans le compilateur Solidity de Remix](./remix-function-button.png)
 
-Appelons maintenant la fonction `increment` en cliquant sur le bouton. Vous verrez les journaux des transactions terminées apparaitre en bas de la fenêtre. Vous verrez que les journaux sont différents si vous appuyez sur le bouton de récupération des données plutôt que sur le bouton `increment`. C’est parce que la lecture des données sur la blockchain ne requiert ni transactions (écriture) ni frais. En effet, seule la modification de l'état de la blockchain nécessite de faire une transaction :
+Appelons maintenant la fonction `increment` en cliquant sur le bouton. Vous verrez les journaux des transactions effectuées apparaître en bas de la fenêtre. Vous verrez que les journaux sont différents lorsque vous appuyez sur le bouton pour récupérer les données, par opposition au bouton `increment`. C'est parce que la lecture des données sur la blockchain ne nécessite aucune transaction (écriture) ni aucun frais. En effet, seule la modification de l'état de la blockchain nécessite d'effectuer une transaction :
 
-![Un journal des transactions](./transaction-log.png)
+![Un journal de transactions](./transaction-log.png)
 
-Après avoir appuyé sur le bouton increment qui va générer une transaction pour appeler notre fonction `increment()` si nous cliquons de nouveau sur le boutons count ou getCount, nous allons lire l'état récemment mis à jour de notre contrat intelligent avec une variable count supérieure à 0.
+Après avoir appuyé sur le bouton `increment` qui génère une transaction pour appeler notre fonction `increment()`, si nous cliquons à nouveau sur les boutons `count` ou `getCount`, nous lirons l'état nouvellement mis à jour de notre contrat intelligent, avec la variable `count` supérieure à 0.
 
-![État du contrat intelligent récemment mis à jour](./updated-state.png)
+![État nouvellement mis à jour du contrat intelligent](./updated-state.png)
 
-Dans le prochain tutoriel, nous aborderons [comment vous pouvez ajouter des événements à vos contrats intelligents](/developers/tutorials/logging-events-smart-contracts/). La journalisation des événements est un moyen pratique de déboguer votre contrat intelligent et de comprendre ce qui se passe en appelant une fonction.
+Dans le prochain tutoriel, nous verrons [comment vous pouvez ajouter des événements à vos contrats intelligents](/developers/tutorials/logging-events-smart-contracts/). La journalisation des événements est un moyen pratique de déboguer votre contrat intelligent et de comprendre ce qui se passe lors de l'appel d'une fonction.
diff --git a/public/content/translations/fr/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/fr/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
new file mode 100644
index 00000000000..2fb3d623ecc
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -0,0 +1,372 @@
+---
+title: "Comment développer et tester une dApp sur un réseau de test local multi-clients"
+description: "Ce guide vous expliquera d'abord comment instancier et configurer un réseau de test Ethereum local multi-clients avant d'utiliser le réseau de test pour déployer et tester une dApp."
+author: "Tedi Mitiku"
+tags:
+  [
+    "clients",
+    "nœuds",
+    "contrats intelligents",
+    "composabilité",
+    "couche de consensus",
+    "couche d'exécution",
+    "test"
+  ]
+skill: intermediate
+lang: fr
+published: 2023-04-11
+---
+
+## Introduction {#introduction}
+
+Ce guide vous explique comment instancier un réseau de test Ethereum local configurable, y déployer un contrat intelligent et utiliser ce réseau de test pour exécuter des tests sur votre dApp. Ce guide est conçu pour les développeurs de dApps qui souhaitent développer et tester leurs dApps localement avec différentes configurations de réseau avant de les déployer sur un réseau de test public ou sur le réseau principal.
+
+Dans ce guide, vous allez :
+
+- Instancier un réseau de test Ethereum local avec le [`eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) en utilisant [Kurtosis](https://www.kurtosis.com/),
+- Connecter votre environnement de développement de dApp Hardhat au réseau de test local pour compiler, déployer et tester une dApp, et
+- Configurer le réseau de test local, y compris des paramètres comme le nombre de nœuds et les paires de clients EL/CL spécifiques, pour permettre des flux de travail de développement et de test sur diverses configurations de réseau.
+
+### Qu'est-ce que Kurtosis ? {#what-is-kurtosis}
+
+[Kurtosis](https://www.kurtosis.com/) est un système de construction composable conçu pour configurer des environnements de test multi-conteneurs. Il permet spécifiquement aux développeurs de créer des environnements reproductibles qui nécessitent une logique de configuration dynamique, comme les réseaux de test de blockchain.
+
+Dans ce guide, le paquet eth-network-package de Kurtosis lance un réseau de test Ethereum local avec prise en charge du client de couche d'exécution (EL) [`geth`](https://geth.ethereum.org/), ainsi que des clients de couche de consensus (CL) [`teku`](https://consensys.io/teku), [`lighthouse`](https://lighthouse.sigmaprime.io/) et [`lodestar`](https://lodestar.chainsafe.io/). Ce paquet sert d'alternative configurable et composable aux réseaux dans des cadres de développement comme Hardhat Network, Ganache et Anvil. Kurtosis offre aux développeurs un contrôle et une flexibilité accrus sur les réseaux de test qu'ils utilisent, ce qui est l'une des raisons principales pour lesquelles la [Fondation Ethereum a utilisé Kurtosis pour tester la Fusion](https://www.kurtosis.com/blog/testing-the-ethereum-merge) et continue de l'utiliser pour tester les mises à niveau du réseau.
+
+## Configuration de Kurtosis {#setting-up-kurtosis}
+
+Avant de continuer, assurez-vous d'avoir :
+
+- [Installé et démarré le moteur Docker](https://docs.kurtosis.com/install/#i-install--start-docker) sur votre machine locale
+- [Installé la CLI Kurtosis](https://docs.kurtosis.com/install#ii-install-the-cli) (ou l'avoir mise à niveau vers la dernière version, si vous avez déjà installé la CLI)
+- Installé [Node.js](https://nodejs.org/en), [yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable), et [npx](https://www.npmjs.com/package/npx) (pour votre environnement de dApp)
+
+## Instanciation d'un réseau de test Ethereum local {#instantiate-testnet}
+
+Pour lancer un réseau de test Ethereum local, exécutez :
+
+```python
+kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
+```
+
+Remarque : cette commande nomme votre réseau « local-eth-testnet » à l'aide de l'indicateur `--enclave`.
+
+Kurtosis affichera les étapes qu'il exécute en arrière-plan pendant qu'il interprète, valide, puis exécute les instructions. À la fin, vous devriez voir une sortie qui ressemble à ce qui suit :
+
+```python
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+INFO[2023-04-04T18:09:44-04:00] ||          Created enclave: local-eth-testnet      ||
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+Name:            local-eth-testnet
+UUID:            39372d756ae8
+Status:          RUNNING
+Creation Time:   Tue, 04 Apr 2023 18:09:03 EDT
+
+========================================= Files Artifacts =========================================
+UUID           Name
+d4085a064230   cl-genesis-data
+1c62cb792e4c   el-genesis-data
+bd60489b73a7   genesis-generation-config-cl
+b2e593fe5228   genesis-generation-config-el
+d552a54acf78   geth-prefunded-keys
+5f7e661eb838   prysm-password
+054e7338bb59   validator-keystore-0
+
+========================================== User Services ==========================================
+UUID           Name                                           Ports                                         Status
+e20f129ee0c5   cl-client-0-beacon                             http: 4000/tcp -> <http://127.0.0.1:54261>    RUNNING
+                                                              metrics: 5054/tcp -> <http://127.0.0.1:54262>
+                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:54263
+                                                              udp-discovery: 9000/udp -> 127.0.0.1:60470
+a8b6c926cdb4   cl-client-0-validator                          http: 5042/tcp -> 127.0.0.1:54267             RUNNING
+                                                              metrics: 5064/tcp -> <http://127.0.0.1:54268>
+d7b802f623e8   el-client-0                                    engine-rpc: 8551/tcp -> 127.0.0.1:54253       RUNNING
+                                                              rpc: 8545/tcp -> 127.0.0.1:54251
+                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:54254
+                                                              udp-discovery: 30303/udp -> 127.0.0.1:53834
+                                                              ws: 8546/tcp -> 127.0.0.1:54252
+514a829c0a84   prelaunch-data-generator-1680646157905431468   <none>                                        STOPPED
+62bd62d0aa7a   prelaunch-data-generator-1680646157915424301   <none>                                        STOPPED
+05e9619e0e90   prelaunch-data-generator-1680646157922872635   <none>                                        STOPPED
+
+```
+
+Félicitations ! Vous avez utilisé Kurtosis pour instancier un réseau de test Ethereum local, avec un client CL (`lighthouse`) et un client EL (`geth`), via Docker.
+
+### Résumé {#review-instantiate-testnet}
+
+Dans cette section, vous avez exécuté une commande qui a demandé à Kurtosis d'utiliser le [`eth-network-package` hébergé à distance sur GitHub](https://github.com/kurtosis-tech/eth-network-package) pour lancer un réseau de test Ethereum local dans une [Enclave](https://docs.kurtosis.com/advanced-concepts/enclaves/) Kurtosis. À l'intérieur de votre enclave, vous trouverez à la fois des « artefacts de fichiers » et des « services utilisateur ».
+
+Les [Artefacts de fichiers](https://docs.kurtosis.com/advanced-concepts/files-artifacts/) dans votre enclave incluent toutes les données générées et utilisées pour amorcer les clients EL et CL. Les données ont été créées à l'aide du service `prelaunch-data-generator` construit à partir de cette [image Docker](https://github.com/ethpandaops/ethereum-genesis-generator)
+
+Les services utilisateur affichent tous les services conteneurisés fonctionnant dans votre enclave. Vous remarquerez qu'un seul nœud, comprenant à la fois un client EL et un client CL, a été créé.
+
+## Connecter votre environnement de développement de dApp au réseau de test Ethereum local {#connect-your-dapp}
+
+### Configurer l'environnement de développement de la dApp {#set-up-dapp-env}
+
+Maintenant que vous disposez d'un réseau de test local en cours d'exécution, vous pouvez connecter votre environnement de développement de dApp pour utiliser votre réseau de test local. Le cadre de développement Hardhat sera utilisé dans ce guide pour déployer une dApp de blackjack sur votre réseau de test local.
+
+Pour configurer votre environnement de développement de dApp, clonez le dépôt qui contient notre exemple de dApp et installez ses dépendances, exécutez :
+
+```python
+git clone https://github.com/kurtosis-tech/awesome-kurtosis.git && cd awesome-kurtosis/smart-contract-example && yarn
+```
+
+Le dossier [smart-contract-example](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example) utilisé ici contient la configuration typique pour un développeur de dApp utilisant le cadre de développement [Hardhat](https://hardhat.org/) :
+
+- [`contracts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/contracts) contient quelques contrats intelligents simples pour une dApp de Blackjack
+- [`scripts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/scripts) contient un script pour déployer un contrat de jeton sur votre réseau Ethereum local
+- [`test/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/test) contient un simple test .js pour votre contrat de jeton afin de confirmer que chaque joueur de notre dApp de Blackjack a reçu 1000 jetons frappés pour lui
+- [`hardhat.config.ts`](https://github.com/kurtosis-tech/awesome-kurtosis/blob/main/smart-contract-example/hardhat.config.ts) configure votre installation Hardhat
+
+### Configurer Hardhat pour utiliser le réseau de test local {#configure-hardhat}
+
+Une fois votre environnement de développement de dApp configuré, vous allez maintenant connecter Hardhat pour utiliser le réseau de test Ethereum local généré à l'aide de Kurtosis. Pour ce faire, remplacez `<$YOUR_PORT>` dans la structure `localnet` de votre fichier de configuration `hardhat.config.ts` par le port de la sortie de l'URI rpc de n'importe quel service `el-client-<num>`. Dans cet exemple, le port serait `64248`. Votre port sera différent.
+
+Exemple dans `hardhat.config.ts` :
+
+```js
+localnet: {
+url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO : REMPLACEZ $YOUR_PORT PAR LE PORT D'UNE URI DE NŒUD PRODUITE PAR LE PAQUETAGE KURTOSIS DU RÉSEAU ETH
+
+// Il s'agit de clés privées associées à des comptes de test pré-financés créés par le paquetage eth-network-package
+// <https://github.com/kurtosis-tech/eth-network-package/blob/main/src/prelaunch_data_generator/genesis_constants/genesis_constants.star>
+accounts: [
+    "ef5177cd0b6b21c87db5a0bf35d4084a8a57a9d6a064f86d51ac85f2b873a4e2",
+    "48fcc39ae27a0e8bf0274021ae6ebd8fe4a0e12623d61464c498900b28feb567",
+    "7988b3a148716ff800414935b305436493e1f25237a2a03e5eebc343735e2f31",
+    "b3c409b6b0b3aa5e65ab2dc1930534608239a478106acf6f3d9178e9f9b00b35",
+    "df9bb6de5d3dc59595bcaa676397d837ff49441d211878c024eabda2cd067c9f",
+    "7da08f856b5956d40a72968f93396f6acff17193f013e8053f6fbb6c08c194d6",
+  ],
+},
+```
+
+Une fois que vous avez enregistré votre fichier, votre environnement de développement de dApp Hardhat est maintenant connecté à votre réseau de test Ethereum local ! Vous pouvez vérifier que votre réseau de test fonctionne en exécutant :
+
+```python
+npx hardhat balances --network localnet
+```
+
+La sortie devrait ressembler à ceci :
+
+```python
+0x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
+0x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
+0xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
+0x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
+0x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
+0x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000
+```
+
+Cela confirme que Hardhat utilise votre réseau de test local et détecte les comptes pré-financés créés par le `eth-network-package`.
+
+### Déployer et tester votre dApp localement {#deploy-and-test-dapp}
+
+L'environnement de développement de la dApp étant entièrement connecté au réseau de test Ethereum local, vous pouvez maintenant exécuter des flux de travail de développement et de test sur votre dApp en utilisant le réseau de test local.
+
+Pour compiler et déployer le contrat intelligent `ChipToken.sol` pour le prototypage et le développement local, exécutez :
+
+```python
+npx hardhat compile
+npx hardhat run scripts/deploy.ts --network localnet
+```
+
+La sortie devrait ressembler à :
+
+```python
+ChipToken déployé à : 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d
+```
+
+Essayez maintenant d'exécuter le test `simple.js` sur votre dApp locale pour confirmer que chaque joueur de notre dApp de Blackjack a reçu 1000 jetons frappés pour lui :
+
+La sortie devrait ressembler à ceci :
+
+```python
+npx hardhat test --network localnet
+```
+
+La sortie devrait ressembler à ceci :
+
+```python
+ChipToken
+    mint
+      ✔ devrait frapper 1000 jetons pour PLAYER ONE
+
+  1 réussi (654ms)
+```
+
+### Résumé {#review-dapp-workflows}
+
+À ce stade, vous avez configuré un environnement de développement de dApp, l'avez connecté à un réseau Ethereum local créé par Kurtosis, et avez compilé, déployé et exécuté un test simple sur votre dApp.
+
+Explorons maintenant comment vous pouvez configurer le réseau sous-jacent pour tester nos dApps dans diverses configurations de réseau.
+
+## Configuration du réseau de test Ethereum local {#configure-testnet}
+
+### Modification des configurations du client et du nombre de nœuds {#configure-client-config-and-num-nodes}
+
+Votre réseau de test Ethereum local peut être configuré pour utiliser différentes paires de clients EL et CL, ainsi qu'un nombre variable de nœuds, en fonction du scénario et de la configuration réseau spécifique que vous souhaitez développer ou tester. Cela signifie qu'une fois configuré, vous pouvez lancer un réseau de test local personnalisé et l'utiliser pour exécuter les mêmes flux de travail (déploiement, tests, etc.) dans diverses configurations de réseau pour vous assurer que tout fonctionne comme prévu. Pour en savoir plus sur les autres paramètres que vous pouvez modifier, consultez ce lien.
+
+Essayez ! Vous pouvez transmettre diverses options de configuration au `eth-network-package` via un fichier JSON. Ce fichier JSON de paramètres réseau fournit les configurations spécifiques que Kurtosis utilisera pour configurer le réseau Ethereum local.
+
+Prenez le fichier de configuration par défaut et modifiez-le pour lancer trois nœuds avec différentes paires EL/CL :
+
+- Nœud 1 avec `geth`/`lighthouse`
+- Nœud 2 avec `geth`/`lodestar`
+- Nœud 3 avec `geth`/`teku`
+
+Cette configuration crée un réseau hétérogène d'implémentations de nœuds Ethereum pour tester votre dApp. Votre fichier de configuration devrait maintenant ressembler à :
+
+```yaml
+{
+  "participants":
+    [
+      {
+        "el_client_type": "geth",
+        "el_client_image": "",
+        "el_client_log_level": "",
+        "cl_client_type": "lighthouse",
+        "cl_client_image": "",
+        "cl_client_log_level": "",
+        "beacon_extra_params": [],
+        "el_extra_params": [],
+        "validator_extra_params": [],
+        "builder_network_params": null,
+      },
+      {
+        "el_client_type": "geth",
+        "el_client_image": "",
+        "el_client_log_level": "",
+        "cl_client_type": "lodestar",
+        "cl_client_image": "",
+        "cl_client_log_level": "",
+        "beacon_extra_params": [],
+        "el_extra_params": [],
+        "validator_extra_params": [],
+        "builder_network_params": null,
+      },
+      {
+        "el_client_type": "geth",
+        "el_client_image": "",
+        "el_client_log_level": "",
+        "cl_client_type": "teku",
+        "cl_client_image": "",
+        "cl_client_log_level": "",
+        "beacon_extra_params": [],
+        "el_extra_params": [],
+        "validator_extra_params": [],
+        "builder_network_params": null,
+      },
+    ],
+  "network_params":
+    {
+      "preregistered_validator_keys_mnemonic": "giant issue aisle success illegal bike spike question tent bar rely arctic volcano long crawl hungry vocal artwork sniff fantasy very lucky have athlete",
+      "num_validator_keys_per_node": 64,
+      "network_id": "3151908",
+      "deposit_contract_address": "0x4242424242424242424242424242424242424242",
+      "seconds_per_slot": 12,
+      "genesis_delay": 120,
+      "capella_fork_epoch": 5,
+    },
+}
+```
+
+Chaque structure `participants` correspond à un nœud du réseau, donc 3 structures `participants` indiqueront à Kurtosis de lancer 3 nœuds dans votre réseau. Chaque structure `participants` vous permettra de spécifier la paire EL et CL utilisée pour ce nœud spécifique.
+
+La structure `network_params` configure les paramètres réseau qui sont utilisés pour créer les fichiers de genèse pour chaque nœud ainsi que d'autres paramètres comme les secondes par créneau du réseau.
+
+Enregistrez votre fichier de paramètres modifié dans le répertoire de votre choix (dans l'exemple ci-dessous, il est enregistré sur le bureau), puis utilisez-le pour exécuter votre paquetage Kurtosis en exécutant :
+
+```python
+kurtosis clean -a && kurtosis run --enclave local-eth-testnet github.com/kurtosis-tech/eth-network-package "$(cat ~/eth-network-params.json)"
+```
+
+Remarque : la commande `kurtosis clean -a` est utilisée ici pour demander à Kurtosis de détruire l'ancien réseau de test et son contenu avant d'en démarrer un nouveau.
+
+Encore une fois, Kurtosis fonctionnera un instant et affichera les différentes étapes qui se déroulent. Finalement, la sortie devrait ressembler à :
+
+```python
+Starlark code successfully run. No output was returned.
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+INFO[2023-04-07T11:43:16-04:00] ||          Created enclave: local-eth-testnet          ||
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+Name:            local-eth-testnet
+UUID:            bef8c192008e
+Status:          RUNNING
+Creation Time:   Fri, 07 Apr 2023 11:41:58 EDT
+
+========================================= Files Artifacts =========================================
+UUID           Name
+cc495a8e364a   cl-genesis-data
+7033fcdb5471   el-genesis-data
+a3aef43fc738   genesis-generation-config-cl
+8e968005fc9d   genesis-generation-config-el
+3182cca9d3cd   geth-prefunded-keys
+8421166e234f   prysm-password
+d9e6e8d44d99   validator-keystore-0
+23f5ba517394   validator-keystore-1
+4d28dea40b5c   validator-keystore-2
+
+========================================== User Services ==========================================
+UUID           Name                                           Ports                                            Status
+485e6fde55ae   cl-client-0-beacon                             http: 4000/tcp -> http://127.0.0.1:65010         RUNNING
+                                                              metrics: 5054/tcp -> http://127.0.0.1:65011
+                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65012
+                                                              udp-discovery: 9000/udp -> 127.0.0.1:54455
+73739bd158b2   cl-client-0-validator                          http: 5042/tcp -> 127.0.0.1:65016                RUNNING
+                                                              metrics: 5064/tcp -> 127.0.0.1:65017
+1b0a233cd011   cl-client-1-beacon                             http: 4000/tcp -> 127.0.0.1:65021                RUNNING
+                                                              metrics: 8008/tcp -> 127.0.0.1:65023
+                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65024
+                                                              udp-discovery: 9000/udp -> 127.0.0.1:56031
+                                                              validator-metrics: 5064/tcp -> 127.0.0.1:65022
+949b8220cd53   cl-client-1-validator                          http: 4000/tcp -> 127.0.0.1:65028                RUNNING
+                                                              metrics: 8008/tcp -> 127.0.0.1:65030
+                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65031
+                                                              udp-discovery: 9000/udp -> 127.0.0.1:60784
+                                                              validator-metrics: 5064/tcp -> 127.0.0.1:65029
+c34417bea5fa   cl-client-2                                    http: 4000/tcp -> 127.0.0.1:65037                RUNNING
+                                                              metrics: 8008/tcp -> 127.0.0.1:65035
+                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65036
+                                                              udp-discovery: 9000/udp -> 127.0.0.1:63581
+e19738e6329d   el-client-0                                    engine-rpc: 8551/tcp -> 127.0.0.1:64986          RUNNING
+                                                              rpc: 8545/tcp -> 127.0.0.1:64988
+                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:64987
+                                                              udp-discovery: 30303/udp -> 127.0.0.1:55706
+                                                              ws: 8546/tcp -> 127.0.0.1:64989
+e904687449d9   el-client-1                                    engine-rpc: 8551/tcp -> 127.0.0.1:64993          RUNNING
+                                                              rpc: 8545/tcp -> 127.0.0.1:64995
+                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:64994
+                                                              udp-discovery: 30303/udp -> 127.0.0.1:58096
+                                                              ws: 8546/tcp -> 127.0.0.1:64996
+ad6f401126fa   el-client-2                                    engine-rpc: 8551/tcp -> 127.0.0.1:65003          RUNNING
+                                                              rpc: 8545/tcp -> 127.0.0.1:65001
+                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:65000
+                                                              udp-discovery: 30303/udp -> 127.0.0.1:57269
+                                                              ws: 8546/tcp -> 127.0.0.1:65002
+12d04a9dbb69   prelaunch-data-generator-1680882122181135513   <none>                                           STOPPED
+5b45f9c0504b   prelaunch-data-generator-1680882122192182847   <none>                                           STOPPED
+3d4aaa75e218   prelaunch-data-generator-1680882122201668972   <none>                                           STOPPED
+```
+
+Félicitations ! Vous avez configuré avec succès votre réseau de test local pour avoir 3 nœuds au lieu de 1. Pour exécuter les mêmes flux de travail que précédemment sur votre dApp (déploiement et test), effectuez les mêmes opérations que nous avons faites auparavant en remplaçant le `<$YOUR_PORT>` dans la structure `localnet` de votre fichier de configuration `hardhat.config.ts` par le port de la sortie de l'URI rpc de n'importe quel service `el-client-<num>` dans votre nouveau réseau de test local à 3 nœuds.
+
+## Conclusion {#conclusion}
+
+Et c'est tout ! Pour résumer ce court guide, vous avez :
+
+- Créé un réseau de test Ethereum local sur Docker en utilisant Kurtosis
+- Connecté votre environnement de développement de dApp local au réseau Ethereum local
+- Déployé une dApp et exécuté un test simple sur celle-ci sur le réseau Ethereum local
+- Configuré le réseau Ethereum sous-jacent pour avoir 3 nœuds
+
+Nous serions ravis d'avoir votre retour sur ce qui s'est bien passé pour vous, ce qui pourrait être amélioré, ou de répondre à vos questions. N'hésitez pas à nous contacter via [GitHub](https://github.com/kurtosis-tech/kurtosis/issues/new/choose) ou à [nous envoyer un e-mail](mailto:feedback@kurtosistech.com) !
+
+### Autres exemples et guides {#other-examples-guides}
+
+Nous vous encourageons à consulter notre [guide de démarrage rapide](https://docs.kurtosis.com/quickstart) (où vous construirez une base de données Postgres et une API par-dessus) et nos autres exemples dans notre [dépôt awesome-kurtosis](https://github.com/kurtosis-tech/awesome-kurtosis) où vous trouverez d'excellents exemples, y compris des paquetages pour :
+
+- [Lancer le même réseau de test Ethereum local](https://github.com/kurtosis-tech/eth2-package), mais avec des services supplémentaires connectés tels qu'un spammeur de transactions (pour simuler des transactions), un moniteur de fourche, et une instance Grafana et Prometheus connectée
+- Effectuer un [test de sous-réseautage](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/ethereum-network-partition-test) sur le même réseau Ethereum local
diff --git a/public/content/translations/fr/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md b/public/content/translations/fr/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
index f51c122adb2..e26cd2d5678 100644
--- a/public/content/translations/fr/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
+++ b/public/content/translations/fr/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
@@ -1,12 +1,9 @@
 ---
 title: "Réduire la taille des contrats pour ne pas dépasser la limite"
-description: Que pouvez-vous faire pour éviter que vos contrats intelligents ne deviennent trop volumineux ?
+description: "Que pouvez-vous faire pour éviter que vos contrats intelligents ne deviennent trop volumineux ?"
 author: Markus Waas
 lang: fr
-tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "stockage"
+tags: [ "Solidity", "contrats intelligents", "stockage" ]
 skill: intermediate
 published: 2020-06-26
 source: soliditydeveloper.com
@@ -15,17 +12,17 @@ sourceUrl: https://soliditydeveloper.com/max-contract-size
 
 ## Pourquoi existe-t-il une limite ? {#why-is-there-a-limit}
 
-Le [22 novembre 2016,](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon) la fourche Spurious Dragon a introduit [EIP-170](https://eips.ethereum.org/EIPS/eip-170), qui a ajouté une limite de taille des contrats intelligents de 24,576 kb. Pour vous, en tant que développeur Solidity, cela signifie que lorsque vous ajoutez de plus en plus de fonctionnalités à votre contrat, à un moment donné, vous atteindrez la limite et, lors du déploiement, vous rencontrerez cette erreur :
+Le 22 novembre 2016, le [hard fork Spurious Dragon](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/) a introduit l'[EIP-170](https://eips.ethereum.org/EIPS/eip-170), qui a ajouté une limite de taille de contrat intelligent de 24,576 ko. Pour vous, en tant que développeur Solidity, cela signifie que lorsque vous ajoutez de plus en plus de fonctionnalités à votre contrat, à un moment donné, vous atteindrez la limite et, lors du déploiement, vous rencontrerez cette erreur :
 
-`Warning: Contract code size exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.`
+`Warning: Contract code size exceeds 24576 bytes (a limit introduced in Spurious Dragon). Ce contrat pourrait ne pas être déployable sur le Réseau principal. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.`
 
-Cette limite a été apportée pour empêcher les attaques par déni de service (DOS). Tout appel vers un contrat est relativement peu coûteux en gaz. Cependant, l'impact d'un appel de contrat sur les nœuds Ethereum augmente de manière exponentielle en fonction de la taille du code du contrat appelé (lecture du code sur le disque, pré-traitement du code et ajout des données à la preuve de Merkle). Dans une situation où l'attaquant n'a besoin que de peu de ressources pour donner beaucoup de travail aux autres nœuds, il y a un risque d'attaques DOS.
+Cette limite a été apportée pour empêcher les attaques par déni de service (DOS). Tout appel vers un contrat est relativement peu coûteux en gaz. Cependant, l'impact d'un appel de contrat sur les nœuds Ethereum augmente de manière disproportionnée en fonction de la taille du code du contrat appelé (lecture du code sur le disque, pré-traitement du code et ajout des données à la preuve de Merkle). Dans une situation où l'attaquant n'a besoin que de peu de ressources pour donner beaucoup de travail aux autres nœuds, il y a un risque d'attaques DOS.
 
-À l'origine, le problème était moins préoccupant, car la limite naturelle de la taille des contrats était la limite de gaz par bloc. Bien entendu, un contrat doit être déployé dans une transaction qui contient tout le bytecode du contrat. Si vous n'incluez ensuite que cette seule transaction dans un bloc, vous pourrez utiliser tout le gaz, mais il ne sera pas illimité. Depuis la [mise à niveau de Londres](/ethereum-forks/#london), la limite de gaz de bloc a pu varier entre 15M et 30M unités selon la demande du réseau.
+À l'origine, le problème était moins préoccupant, car la limite naturelle de la taille des contrats était la limite de gaz par bloc. Bien entendu, un contrat doit être déployé dans une transaction qui contient tout le bytecode du contrat. Si vous n'incluez ensuite que cette seule transaction dans un bloc, vous pourrez utiliser tout le gaz, mais il ne sera pas illimité. Depuis la [mise à niveau London](/ethereum-forks/#london), la limite de gaz par bloc a pu varier entre 15M et 30M d'unités en fonction de la demande du réseau.
 
-Dans les prochaines lignes, nous examinerons certaines méthodes classées en fonction de leur impact potentiel. Considérez ça comme perdre du poids. La meilleure stratégie pour atteindre son poids cible (dans notre cas, 24 kb) est de se concentrer en premier lieu sur les méthodes à fort impact. Dans la plupart des cas, il suffit de revoir son régime alimentaire pour y parvenir, mais il faut parfois aller un peu plus loin. Ensuite, vous pouvez ajouter à cela un peu d'exercice (impact modéré) ou même des suppléments (impact faible).
+Dans les prochaines lignes, nous examinerons certaines méthodes classées en fonction de leur impact potentiel. Considérez cela comme une perte de poids. La meilleure stratégie pour atteindre son poids cible (dans notre cas, 24 ko) est de se concentrer en premier lieu sur les méthodes à fort impact. Dans la plupart des cas, il suffit de revoir son régime alimentaire pour y parvenir, mais il faut parfois aller un peu plus loin. Ensuite, vous pouvez ajouter à cela un peu d'exercice (impact modéré) ou même des suppléments (impact faible).
 
-## Impact important {#big-impact}
+## Grand impact {#big-impact}
 
 ### Séparez vos contrats {#separate-your-contracts}
 
@@ -37,24 +34,22 @@ Cela devrait toujours être votre première approche. Comment peut-on séparer l
 
 ### Bibliothèques {#libraries}
 
-Une façon simple de séparer le code fonctionnel du stockage est d'utiliser une [bibliothèque](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#libraries). Ne déclarez pas les fonctions de la bibliothèque comme internes, sinon elles seront [ajoutées au contrat](https://ethereum.stackexchange.com/questions/12975/are-internal-functions-in-libraries-not-covered-by-linking) directement, lors de la compilation. Mais si vous utilisez des fonctions publiques, celles-ci seront en fait dans un contrat de bibliothèque séparé. Pensez à utiliser « [using for](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#using-for) » pour rendre l'utilisation des bibliothèques plus pratique.
+Une façon simple de séparer le code des fonctionnalités du stockage est d'utiliser une [bibliothèque](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#libraries). Ne déclarez pas les fonctions de la bibliothèque comme étant `internal`, car celles-ci seront directement [ajoutées au contrat](https://ethereum.stackexchange.com/questions/12975/are-internal-functions-in-libraries-not-covered-by-linking) lors de la compilation. Mais si vous utilisez des fonctions `public`, celles-ci se trouveront en fait dans un contrat de bibliothèque distinct. Pensez à [utiliser `using for`](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#using-for) pour rendre l'utilisation des bibliothèques plus pratique.
 
-### Proxies {#proxies}
+### Proxys {#proxies}
 
-Une méthode plus avancée consiste à utiliser le système de proxy. Les bibliothèques utilisent `DELEGATECALL` en coulisse, qui exécute simplement la fonction d'un autre contrat avec l'état du contrat appelant. Consultez cette [publication de blog](https://hackernoon.com/how-to-make-smart-contracts-upgradable-2612e771d5a2) pour en savoir plus sur les systèmes de proxy. Cela vous offrira plus de fonctionnalités, comme permettre les mise à niveau, par exemple, mais ils ajoutent aussi beaucoup de complexité. Je ne les ajouterais pas uniquement pour réduire la taille des contrats, à moins que ce ne soit votre seule option pour une raison quelconque.
+Une méthode plus avancée consiste à utiliser le système de proxy. Les bibliothèques utilisent `DELEGATECALL` en coulisse, qui exécute simplement la fonction d'un autre contrat avec l'état du contrat appelant. Consultez [cet article de blog](https://hackernoon.com/how-to-make-smart-contracts-upgradable-2612e771d5a2) pour en savoir plus sur les systèmes de proxy. Ils offrent plus de fonctionnalités, par exemple, ils permettent les mises à niveau, mais ils ajoutent aussi beaucoup de complexité. Je ne les ajouterais pas uniquement pour réduire la taille des contrats, à moins que ce ne soit votre seule option pour une raison quelconque.
 
-## Impact modéré {#medium-impact}
+## Impact moyen {#medium-impact}
 
-### Supprimez des fonctions {#remove-functions}
+### Supprimer des fonctions {#remove-functions}
 
 Cela devrait être évident. Les fonctions augmentent considérablement la taille d'un contrat.
 
-- **Externe** : Souvent, nous ajoutons beaucoup de fonctions « view », pour des raisons de commodité. Ce n'est pas vraiment un problème, jusqu'à ce que vous atteigniez la taille limite. Quand cela arrive, vous devriez vraiment penser à supprimer tous les éléments qui ne sont absolument pas essentiels.
-- **Interne** : Vous pouvez également supprimer les fonctions internes/privées et mettre le code dans la ligne, à condition qu'elles ne soient appelées qu'une fois.
+- **Externe** : Souvent, nous ajoutons de nombreuses fonctions `view` pour des raisons de commodité. Ce n'est pas vraiment un problème, jusqu'à ce que vous atteigniez la taille limite. Quand cela arrive, vous devriez vraiment penser à supprimer tous les éléments qui ne sont absolument pas essentiels.
+- **Interne** : Vous pouvez également supprimer les fonctions `internal`/`private` et simplement inliner le code tant que la fonction n'est appelée qu'une seule fois.
 
-### Évitez les variables inutiles {#avoid-additional-variables}
-
-Un simple changement comme celui-ci :
+### Évitez les variables supplémentaires {#avoid-additional-variables}
 
 ```solidity
 function get(uint id) returns (address,address) {
@@ -69,15 +64,14 @@ function get(uint id) returns (address,address) {
 }
 ```
 
-représente une différence de **0,28 kb**. Il y a de fortes chances que vous puissiez trouver de nombreuses situations similaires dans vos contrats, et elles peuvent engendrer une augmentation significative du poids total.
+Un simple changement comme celui-ci fait une différence de **0,28 ko**. Il y a de fortes chances que vous puissiez trouver de nombreuses situations similaires dans vos contrats, et elles peuvent engendrer une augmentation significative du poids total.
 
-### Abrégez les messages d'erreur {#shorten-error-message}
+### Raccourcir les messages d'erreur {#shorten-error-message}
 
-Les longs messages d'annulation et, en particulier, les nombreux messages différents d'annulation peuvent alourdir le contrat. Utilisez plutôt des codes d'erreur courts et décodez-les dans votre contrat. Un long message peut ainsi devenir beaucoup plus court :
+De longs messages `revert` et en particulier de nombreux messages `revert` différents peuvent alourdir le contrat. Utilisez plutôt des codes d'erreur courts et décodez-les dans votre contrat. Un long message peut ainsi devenir beaucoup plus court :
 
 ```solidity
-require(msg.sender == owner, "Only the owner of this contract can call this function");
-
+require(msg.sender == owner, "Seul le propriétaire de ce contrat peut appeler cette fonction");
 ```
 
 ```solidity
@@ -86,7 +80,7 @@ require(msg.sender == owner, "OW1");
 
 ### Utiliser des erreurs personnalisées au lieu de messages d'erreur
 
-Des erreurs personnalisées ont été introduites dans [Solidity 0.8.4](https://blog.soliditylang.org/2021/04/21/custom-errors/). Ils sont un excellent moyen de réduire la taille de vos contrats, car ils sont encodés ABI en tant que sélecteurs (comme les fonctions).
+Les erreurs personnalisées ont été introduites dans [Solidity 0.8.4](https://blog.soliditylang.org/2021/04/21/custom-errors/). C'est un excellent moyen de réduire la taille de vos contrats, car ils sont encodés en ABI en tant que sélecteurs (tout comme le sont les fonctions).
 
 ```solidity
 error Unauthorized();
@@ -96,15 +90,15 @@ if (msg.sender != owner) {
 }
 ```
 
-### Envisagez une valeur d'exécution faible dans l'optimiseur {#consider-a-low-run-value-in-the-optimizer}
+### Envisager une faible valeur de `runs` dans l'optimiseur {#consider-a-low-run-value-in-the-optimizer}
 
-Vous pouvez également modifier les paramètres de l'optimiseur. La valeur par défaut à 200 signifie qu'il va essayer d'optimiser le bytecode comme si une fonction était appelée 200 fois. Si vous la définissez à 1, vous demandez simplement à l'optimiseur d'optimiser dans le cas où chaque fonction n'est exécutée qu'une seule fois. Une fonction optimisée pour une seule exécution signifie qu'elle est optimisée pour le déploiement lui-même. Sachez que **cela augmente les [coûts en gaz](/developers/docs/gas/) pour l'exécution des fonctions**, donc vous ne voudrez peut-être pas le faire.
+Vous pouvez également modifier les paramètres de l'optimiseur. La valeur par défaut de 200 signifie qu'il essaie d'optimiser le bytecode comme si une fonction était appelée 200 fois. Si vous la changez pour 1, vous indiquez simplement à l'optimiseur d'optimiser pour le cas où chaque fonction n'est exécutée qu'une seule fois. Une fonction optimisée pour une seule exécution signifie qu'elle est optimisée pour le déploiement lui-même. Sachez que **cela augmente les [coûts en gaz](/developers/docs/gas/) pour l'exécution des fonctions**, donc vous ne voudrez peut-être pas le faire.
 
-## Impact faible {#small-impact}
+## Faible impact {#small-impact}
 
-### Évitez de passer des structures aux fonctions {#avoid-passing-structs-to-functions}
+### Évitez de passer des `structs` aux fonctions {#avoid-passing-structs-to-functions}
 
-Si vous utilisez [ABIEncoderV2](https://solidity.readthedocs.io/en/v0.6.10/layout-of-source-files.html#abiencoderv2), il peut être utile de ne pas passer de structures à une fonction. Au lieu de passer le paramètre comme structure...
+Si vous utilisez l'[ABIEncoderV2](https://solidity.readthedocs.io/en/v0.6.10/layout-of-source-files.html#abiencoderv2), il peut être utile de ne pas passer de `structs` à une fonction. Au lieu de passer le paramètre en tant que `struct`, passez les paramètres requis directement. Dans cet exemple, nous avons économisé **0,1 ko** de plus.
 
 ```solidity
 function get(uint id) returns (address,address) {
@@ -126,14 +120,12 @@ function _get(address addr1, address addr2) private view returns(address,address
 }
 ```
 
-... passez les paramètres requis directement. Dans l'exemple ci-dessus, nous avons économisé **0,1 kb** de plus.
-
-### Spécifiez des visibilités appropriées pour vos fonctions et variables {#declare-correct-visibility-for-functions-and-variables}
+### Déclarer la bonne visibilité pour les fonctions et les variables {#declare-correct-visibility-for-functions-and-variables}
 
-- Des fonctions ou des variables uniquement appelées de l'extérieur ? Déclarez-les `external` au lieu de `public`.
-- Des fonctions ou des variables uniquement appelées au sein du contrat ? Déclarez-les `private` ou `internal` au lieu de `public`.
+- Des fonctions ou des variables uniquement appelées de l'extérieur ? Déclarez-les comme `external` au lieu de `public`.
+- Des fonctions ou des variables uniquement appelées au sein du contrat ? Déclarez-les comme `private` ou `internal` au lieu de `public`.
 
-### Retirez les modificateurs {#remove-modifiers}
+### Supprimer les modificateurs {#remove-modifiers}
 
 Les modificateurs, surtout lorsqu'ils sont utilisés de manière intensive, peuvent avoir un impact significatif sur la taille du contrat. Envisagez de les supprimer et d'utiliser plutôt des fonctions.
 
diff --git a/public/content/translations/fr/developers/tutorials/eip-1271-smart-contract-signatures/index.md b/public/content/translations/fr/developers/tutorials/eip-1271-smart-contract-signatures/index.md
index 0421276c605..5164794909b 100644
--- a/public/content/translations/fr/developers/tutorials/eip-1271-smart-contract-signatures/index.md
+++ b/public/content/translations/fr/developers/tutorials/eip-1271-smart-contract-signatures/index.md
@@ -1,20 +1,22 @@
 ---
 title: "EIP-1271 : Signature et vérification des signatures de contrats intelligents"
-description: Un aperçu de la génération et de la vérification de signatures de contrat intelligent avec l'EIP-1271. Nous examinons également la mise en œuvre de l'EIP-1271 utilisée dans Safe (anciennement Gnosis Safe) pour fournir un exemple concret aux développeurs de contrats intelligents sur lequel s'appuyer.
+description: "Un aperçu de la génération et de la vérification de signatures de contrat intelligent avec l'EIP-1271. Nous examinons également la mise en œuvre de l'EIP-1271 utilisée dans Safe (anciennement Gnosis Safe) pour fournir un exemple concret aux développeurs de contrats intelligents sur lequel s'appuyer."
 author: Nathan H. Leung
 lang: fr
 tags:
-  - "eip-1271"
-  - "contrats intelligents"
-  - "vérification"
-  - "Signature"
+  [
+    "eip-1271",
+    "contrats intelligents",
+    "vérification",
+    "Signature"
+  ]
 skill: intermediate
 published: 2023-01-12
 ---
 
 La norme [EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) permet aux contrats intelligents de vérifier les signatures.
 
-Dans ce tutoriel, nous donnons un aperçu des signatures numériques, de l'historique de l'EIP-1271 et de la mise en œuvre spécifique de l'EIP-1271 utilisée par [Safe](https://safe.global/) (anciennement Gnosis Safe). L'ensemble peut servir de point de départ à la mise en œuvre de la norme EIP-1271 dans vos propres contrats.
+Dans ce tutoriel, nous donnons un aperçu des signatures numériques, du contexte de l'EIP-1271 et de la mise en œuvre spécifique de l'EIP-1271 utilisée par [Safe](https://safe.global/) (anciennement Gnosis Safe). L'ensemble peut servir de point de départ à la mise en œuvre de la norme EIP-1271 dans vos propres contrats.
 
 ## Qu'est-ce qu'une signature ?
 
@@ -36,11 +38,11 @@ De même, une signature numérique ne signifie rien sans un message associé !
 
 Pour créer une signature numérique à utiliser sur les blockchains basées sur Ethereum, vous avez généralement besoin d'une clé privée secrète que personne d'autre ne connaît. C'est ce qui fait que votre signature vous appartient (personne d'autre ne peut créer la même signature sans connaître la clé secrète).
 
-Votre compte Ethereum (c'est-à-dire votre compte externe/EOA) est associé à une clé privée, et c'est cette clé privée qui est généralement utilisée lorsqu'un site web ou une application vous demande une signature (par exemple, pour « Se connecter avec Ethereum »).
+Votre compte Ethereum (c.-à-d. votre compte détenu en externe/EOA) est associé à une clé privée, et c'est cette clé privée qui est généralement utilisée lorsqu'un site Web ou une dapp vous demande une signature (p. ex. pour « Se connecter avec Ethereum »).
 
-Une application peut [vérifier une signature](https://docs.alchemy.com/docs/how-to-verify-a-message-signature-on-ethereum) que vous créez à l'aide d'une bibliothèque tierce telle que ethers.js [sans connaître votre clé privée](https://en.wikipedia.org/wiki/Public-key_cryptography) et être certaine que _vous_ êtes celui/celle qui a créé la signature.
+Une application peut [vérifier une signature](https://www.alchemy.com/docs/how-to-verify-a-message-signature-on-ethereum) que vous créez à l'aide d'une bibliothèque tierce comme ethers.js [sans connaître votre clé privée](https://en.wikipedia.org/wiki/Public-key_cryptography) et avoir la certitude que c'est _vous_ qui avez créé la signature.
 
-> En fait, comme les signatures numériques EOA utilisent la cryptographie à clé publique, elles peuvent être générées et vérifiées **hors chaîne** ! C'est comme cela que fonctionne les votes DAO sans gaz - au lieu de soumettre les votes sur la chaîne, les signatures numériques peuvent être créées et vérifiées hors chaîne à l'aide de bibliothèques cryptographiques.
+> En fait, parce que les signatures numériques EOA utilisent la cryptographie à clé publique, elles peuvent être générées et vérifiées **hors chaîne** ! C'est ainsi que fonctionne le vote DAO sans gaz — au lieu de soumettre des votes en chaîne, les signatures numériques peuvent être créées et vérifiées hors chaîne à l'aide de bibliothèques cryptographiques.
 
 Alors que les comptes EOA disposent d'une clé privée, les comptes de contrats intelligents ne disposent d'aucune forme de clé privée ou secrète (de sorte que la fonction « Se connecter avec Ethereum », etc. ne peut pas fonctionner nativement avec les comptes de contrats intelligents).
 
@@ -50,17 +52,17 @@ Le problème que l'EIP-1271 cherche à résoudre : comment savoir si la signatur
 
 Les contrats intelligents ne disposent pas de clés privées pouvant être utilisées pour signer des messages. Alors, comment savoir si une signature est authentique ?
 
-Eh bien, une idée serait tout simplement de _demander_ au contrat intelligent si une signature est authentique !
+Eh bien, une idée est que nous pouvons simplement _demander_ au contrat intelligent si une signature est authentique !
 
 L'EIP-1271 normalise l'idée de « demander » à un contrat intelligent si une signature donnée est valide.
 
-Un contrat qui implémente l'EIP-1271 doit avoir une fonction appelée `isValidSignature` qui prend en compte un message et une signature. Le contrat peut alors exécuter une logique de validation (la spécification n'impose rien de spécifique ici) et renvoyer une valeur indiquant si la signature est valide ou non.
+Un contrat qui implémente l'EIP-1271 doit avoir une fonction appelée `isValidSignature` qui prend en entrée un message et une signature. Le contrat peut alors exécuter une logique de validation (la spécification n'impose rien de spécifique ici) et renvoyer une valeur indiquant si la signature est valide ou non.
 
 Si `isValidSignature` renvoie un résultat valide, c'est en gros le contrat qui dit « oui, j'approuve cette signature + ce message ! »
 
 ### Interface
 
-Voici l'interface exacte dans la spécification EIP-1271 (nous parlerons du paramètre `_hash` plus loin, mais pour l'instant, considérez-le comme le message qui est vérifié) :
+Voici l'interface exacte dans la spécification EIP-1271 (nous parlerons du paramètre `_hash` ci-dessous, mais pour l'instant, considérez-le comme le message en cours de vérification) :
 
 ```jsx
 pragma solidity ^0.5.0;
@@ -71,13 +73,13 @@ contract ERC1271 {
   bytes4 constant internal MAGICVALUE = 0x1626ba7e;
 
   /**
-   * @dev Should return whether the signature provided is valid for the provided hash
-   * @param _hash      Hash of the data to be signed
-   * @param _signature Signature byte array associated with _hash
+   * @dev Devrait retourner si la signature fournie est valide pour le hachage fourni
+   * @param _hash      Hachage des données à signer
+   * @param _signature Tableau d'octets de la signature associé à _hash
    *
-   * MUST return the bytes4 magic value 0x1626ba7e when function passes.
-   * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
-   * MUST allow external calls
+   * DOIT retourner la valeur magique bytes4 0x1626ba7e lorsque la fonction réussit.
+   * NE DOIT PAS modifier l'état (en utilisant STATICCALL pour solc < 0.5, modificateur view pour solc > 0.5)
+   * DOIT autoriser les appels externes
    */
   function isValidSignature(
     bytes32 _hash,
@@ -90,28 +92,28 @@ contract ERC1271 {
 
 ## Exemple d'implémentation EIP-1271 : Safe
 
-Les contrats peuvent implémenter `isValidSignature` de plusieurs façons - la spécification seule ne précise pas l'implémentation exacte.
+Les contrats peuvent implémenter `isValidSignature` de nombreuses manières — la spécification elle-même ne dit pas grand-chose sur l'implémentation exacte.
 
 Un contrat significatif qui met en œuvre l'EIP-1271 est Safe (anciennement Gnosis Safe).
 
-Dans le code de Safe, la fonction `isValidSignature` [est implémentée](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol) de manière à ce que les signatures puissent être créées et vérifiées de [deux manières](https://ethereum.stackexchange.com/questions/122635/signing-messages-as-a-gnosis-safe-eip1271-support) :
+Dans le code de Safe, `isValidSignature` [est implémenté](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol) de sorte que les signatures peuvent être créées et vérifiées de [deux manières](https://ethereum.stackexchange.com/questions/122635/signing-messages-as-a-gnosis-safe-eip1271-support) :
 
-1. Messages on-chain
-   1. Création : un propriétaire du coffre-fort crée une nouvelle transaction sécurisée pour « signer » un message, en transmettant le message sous forme de données dans la transaction. Une fois que suffisamment de propriétaires ont signé la transaction pour atteindre le seuil multisig, la transaction est diffusée et exécutée. Dans la transaction, une fonction « safe » est invoquée afin d'ajouter le message à une liste de messages « approuvés ».
-   2. Vérification : appelez `isValidSignature` sur le contrat Safe, et envoyez le message à vérifier en tant que paramètre du message et [une valeur vide pour le paramètre de signature](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L32) (c'est-à-dire `0x`). Le Safe verra que le paramètre de signature est vide et au lieu de vérifier cryptographiquement la signature, il saura simplement aller de l'avant et vérifier si le message figure sur la liste des messages « approuvés ».
+1. Messages en chaîne
+   1. Création : un propriétaire du coffre-fort crée une nouvelle transaction sécurisée pour « signer » un message, en transmettant le message sous forme de données dans la transaction. Une fois que suffisamment de propriétaires ont signé la transaction pour atteindre le seuil multisig, la transaction est diffusée et exécutée. Dans la transaction, il y a une fonction de Safe appelée (`signMessage(bytes calldata _data)`) qui ajoute le message à une liste de messages « approuvés ».
+   2. Vérification : appelez `isValidSignature` sur le contrat Safe, et passez le message à vérifier comme paramètre de message et [une valeur vide pour le paramètre de signature](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L32) (c.-à-d., `0x`). Le Safe verra que le paramètre de signature est vide et au lieu de vérifier cryptographiquement la signature, il saura simplement aller de l'avant et vérifier si le message figure sur la liste des messages « approuvés ».
 2. Messages hors chaîne :
-   1. Création : un propriétaire de coffre-fort crée un message hors chaîne, puis demande à d'autres propriétaires de coffre-fort de signer le message chacun individuellement jusqu'à ce qu'il y ait suffisamment de signatures pour dépasser le seuil d'approbation multisig.
+   1. Création : un propriétaire de Safe crée un message hors chaîne, puis demande à d'autres propriétaires de Safe de signer le message chacun individuellement jusqu'à ce qu'il y ait suffisamment de signatures pour dépasser le seuil d'approbation multisig.
    2. Vérification : appelez `isValidSignature`. Dans le paramètre du message, envoyez le message à vérifier. Dans le paramètre de signature, transmettez les signatures individuelles de chaque propriétaire de coffre-fort, toutes concaténées ensemble, dos à dos. Le Safe vérifiera qu'il y a suffisamment de signatures pour atteindre le seuil **et** que chaque signature est valide. Si c'est le cas, il renverra une valeur indiquant une vérification de signature réussie.
 
-## Qu'est-ce que le paramètre `_hash` ? Pourquoi ne pas transmettre le message dans son intégralité ?
+## Qu'est-ce que le paramètre `_hash` exactement ? Pourquoi ne pas transmettre le message dans son intégralité ?
 
-Vous avez peut-être remarqué que la fonction `isValidSignature` dans l'[interface de l'EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) ne prend pas le message lui-même, mais plutôt un paramètre `_hash`. Ce que cela signifie, c'est qu'au lieu de passer le message complet de longueur arbitraire à `isValidSignature`, nous passons plutôt un hash de 32 octets du message (généralement keccak256).
+Vous avez peut-être remarqué que la fonction `isValidSignature` dans [l'interface EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) ne prend pas en entrée le message lui-même, mais plutôt un paramètre `_hash`. Cela signifie qu'au lieu de passer le message complet de longueur arbitraire à `isValidSignature`, nous passons un hachage de 32 octets du message (généralement keccak256).
 
-Chaque octet de calldata - c'est-à-dire les données des paramètres de fonction passées à une fonction de contrat intelligent - [coûte 16 gaz (4 gaz si l'octet est zéro)](https://eips.ethereum.org/EIPS/eip-2028), cela peut donc économiser beaucoup de gaz si un message est long.
+Chaque octet de calldata — c.-à-d. les données de paramètre de fonction passées à une fonction de contrat intelligent — [coûte 16 gaz (4 gaz si l'octet est un zéro)](https://eips.ethereum.org/EIPS/eip-2028), ce qui peut permettre d'économiser beaucoup de gaz si un message est long.
 
 ### Spécifications précédentes de l'EIP-1271
 
-Il existe des spécifications de l'EIP-1271 dans la nature qui ont une fonction `isValidSignature` avec un premier paramètre de type `bytes` (longueur arbitraire, au lieu d'une longueur fixe `bytes32`) et un nom de paramètre `message`. C'est une [version plus ancienne](https://github.com/safe-global/safe-contracts/issues/391#issuecomment-1075427206) de l'EIP-1271.
+Il existe dans la nature des spécifications EIP-1271 qui ont une fonction `isValidSignature` avec un premier paramètre de type `bytes` (longueur arbitraire, au lieu d'une longueur fixe `bytes32`) et le nom de paramètre `message`. Il s'agit d'une [ancienne version](https://github.com/safe-global/safe-contracts/issues/391#issuecomment-1075427206) de la norme EIP-1271.
 
 ## Comment implémenter l'EIP-1271 dans mes propres contrats ?
 
@@ -124,4 +126,4 @@ En fin de compte, c'est à vous de décider en tant que développeur de contrat
 
 ## Conclusion
 
-[L'EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) est une norme polyvalente qui permet aux contrats intelligents de vérifier les signatures. Cela ouvre la voie à des contrats intelligents pour qu'ils agissent davantage comme des EOA - par exemple, en offrant un moyen de faire fonctionner la fonction « Se connecter avec Ethereum » avec les contrats intelligents — et cela peut être implémenté de plusieurs façons (Safe offre une implémentation intéressante et originale à prendre en compte).
+[EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) est une norme polyvalente qui permet aux contrats intelligents de vérifier les signatures. Cela ouvre la voie à des contrats intelligents pour qu'ils agissent davantage comme des EOA - par exemple, en offrant un moyen de faire fonctionner la fonction « Se connecter avec Ethereum » avec les contrats intelligents — et cela peut être implémenté de plusieurs façons (Safe offre une implémentation intéressante et originale à prendre en compte).
diff --git a/public/content/translations/fr/developers/tutorials/erc-721-vyper-annotated-code/index.md b/public/content/translations/fr/developers/tutorials/erc-721-vyper-annotated-code/index.md
index 69190ba7dbd..9974f41f053 100644
--- a/public/content/translations/fr/developers/tutorials/erc-721-vyper-annotated-code/index.md
+++ b/public/content/translations/fr/developers/tutorials/erc-721-vyper-annotated-code/index.md
@@ -3,29 +3,29 @@ title: "Découvrir le contrat Vyper ERC-721"
 description: Le contrat ERC-721 de Ryuya Nakamura et son fonctionnement
 author: Ori Pomerantz
 lang: fr
-tags:
-  - "vyper"
-  - "erc-721"
-  - "python"
+tags: [ "Vyper", "erc-721", "Python" ]
 skill: beginner
 published: 2021-04-01
 ---
 
 ## Introduction {#introduction}
 
-[ERC-721](/developers/docs/standards/tokens/erc-721/) est une norme utilisée pour garantir la propriété des jetons non fongibles (NFT). Les jetons [ERC-20](/developers/docs/standards/tokens/erc-20/) se comportent comme une monnaie, car il n'y a aucune différence entre chacun d'eux. À l'inverse, les jetons ERC-721 ont été conçus pour des actifs qui sont similaires mais pas identiques, comme par exemple différents [dessins de chats](https://www.cryptokitties.co/) ou différents titres de propriété de biens immobiliers.
+La norme [ERC-721](/developers/docs/standards/tokens/erc-721/) est utilisée pour détenir la propriété des jetons non fongibles (NFT).
+Les jetons [ERC-20](/developers/docs/standards/tokens/erc-20/) se comportent comme un produit de base, car il n'y a aucune différence entre les jetons individuels.
+En revanche, les jetons ERC-721 sont conçus pour des actifs similaires mais non identiques, tels que différents [dessins animés de chats](https://www.cryptokitties.co/) ou des titres de propriété pour différents biens immobiliers.
 
-Dans cet article, nous allons décortiquer le [contrat ERC-721 de Ryuya Nakamura](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy). Ce contrat a été écrit en [Vyper](https://vyper.readthedocs.io/en/latest/index.html), un langage de contrat similaire à Python, conçu pour rendre plus difficile l'écriture de code non sécurisé que ce n'est le cas dans Solidity.
+Dans cet article, nous analyserons le [contrat ERC-721 de Ryuya Nakamura](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy).
+Ce contrat est écrit en [Vyper](https://vyper.readthedocs.io/en/latest/index.html), un langage de contrat de type Python conçu pour rendre plus difficile l'écriture de code non sécurisé qu'en Solidity.
 
 ## Le contrat {#contract}
 
 ```python
-# @dev Implementation of ERC-721 non-fungible token standard.
+# @dev Implémentation de la norme de jeton non fongible ERC-721.
 # @author Ryuya Nakamura (@nrryuya)
-# Modified from: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
+# Modifié à partir de : https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
 ```
 
-Tout comme avec Python, les commentaires Vyper commencent par une empreinte numérique (`#`) et continuent jusqu'au bout de la ligne. Les commentaires qui comportent `@<keyword>` sont compris par [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) afin de produire une documentation compréhensible pour l'être humain.
+Les commentaires en Vyper, comme en Python, commencent par un dièse (`#`) et se poursuivent jusqu'à la fin de la ligne. Les commentaires qui incluent `@<keyword>` sont utilisés par [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) pour produire une documentation lisible par l'homme.
 
 ```python
 from vyper.interfaces import ERC721
@@ -33,159 +33,162 @@ from vyper.interfaces import ERC721
 implements: ERC721
 ```
 
-L'interface ERC-721 est intégrée au langage Vyper. [Vous pouvez lire sa définition en code Python ici](https://github.com/vyperlang/vyper/blob/master/vyper/builtin_interfaces/ERC721.py). La définition de l'interface est écrite en Python plutôt qu'en Vyper. En effet, les interfaces ne sont pas utilisées seulement au sein de la blockchain, mais aussi lors de l'envoi d'une transaction vers la blockchain depuis un client externe, qui peut avoir été écrit en Python.
+L'interface ERC-721 est intégrée au langage Vyper.
+[Vous pouvez voir la définition du code ici](https://github.com/vyperlang/vyper/blob/master/vyper/builtin_interfaces/ERC721.py).
+La définition de l'interface est écrite en Python plutôt qu'en Vyper, car les interfaces ne sont pas seulement utilisées au sein de la blockchain, mais aussi lors de l'envoi d'une transaction à la blockchain depuis un client externe, qui peut être écrit en Python.
 
 La première ligne importe l'interface, et la deuxième spécifie que nous l'implémentons ici.
 
 ### L'interface ERC721Receiver {#receiver-interface}
 
 ```python
-# Interface for the contract called by safeTransferFrom()
+# Interface pour le contrat appelé par safeTransferFrom()
 interface ERC721Receiver:
     def onERC721Received(
 ```
 
-ERC-721 autorise deux types de transfert :
+L'ERC-721 prend en charge deux types de transfert :
 
-- `transferFrom`, qui permet à l'expéditeur de spécifier n'importe quelle adresse de destination et fait reposer la responsabilité du transfert sur l'expéditeur. Cela signifie que vous pouvez effectuer un transfert vers une adresse erronée, auquel cas le NFT sera définitivement perdu.
-- `safeTransferFrom`, qui vérifie si l'adresse de destination est un contrat. Si c'est le cas, le contrat ERC-721 demande au contrat destinataire s'il accepte de recevoir le NFT.
+- `transferFrom`, qui permet à l'expéditeur de spécifier n'importe quelle adresse de destination et qui lui attribue la responsabilité du transfert. Cela signifie que vous pouvez effectuer un transfert vers une adresse invalide, auquel cas le NFT est perdu à jamais.
+- `safeTransferFrom`, qui vérifie si l'adresse de destination est un contrat. Si c'est le cas, le contrat ERC-721 demande au contrat destinataire s'il souhaite recevoir le NFT.
 
-Pour répondre aux requêtes de `safeTransferFrom`, le contrat destinataire doit implémenter `ERC721Receiver`.
+Pour répondre aux requêtes `safeTransferFrom`, un contrat destinataire doit implémenter `ERC721Receiver`.
 
 ```python
             _operator: address,
             _from: address,
 ```
 
-L'adresse `_from` est le propriétaire actuel du jeton. L'adresse `_operator` est celle qui a demandé le transfert (les deux peuvent ne pas être identiques, en raison des quotas).
+L'adresse `_from` est le propriétaire actuel du jeton. L'adresse `_operator` est celle qui a demandé le transfert (ces deux adresses peuvent ne pas être les mêmes, en raison des autorisations).
 
 ```python
             _tokenId: uint256,
 ```
 
-Les identifiants des jetons ERC-721 comportent 256 bits. Il sont généralement créés par le hachage de la description qui représente le jeton.
+Les ID de jetons ERC-721 sont de 256 bits. Généralement, ils sont créés en effectuant un hachage de la description de ce que le jeton représente.
 
 ```python
             _data: Bytes[1024]
 ```
 
-La requête peut comporter jusqu'à 1024 octets de données utilisateur.
+La requête peut contenir jusqu'à 1024 octets de données utilisateur.
 
 ```python
         ) -> bytes32: view
 ```
 
-Pour éviter les cas où un contrat accepte accidentellement un transfert, la valeur de retour n'est pas un booléen, mais 256 bits avec une valeur spécifique.
+Pour éviter les cas où un contrat accepte accidentellement un transfert, la valeur de retour n'est pas un booléen, mais une valeur de 256 bits avec une valeur spécifique.
 
-Cette fonction est de type `view`, ce qui signifie qu'elle peut consulter l'état de la blockchain, mais pas le modifier.
+Cette fonction est une `view`, ce qui signifie qu'elle peut lire l'état de la blockchain, mais pas le modifier.
 
-### Évènements {#events}
+### Événements {#events}
 
-Les [évènements](https://media.consensys.net/technical-introduction-to-events-and-logs-in-ethereum-a074d65dd61e) sont émis pour informer les utilisateurs et les serveurs extérieurs à la blockchain des évènements. Notez que le contenu des évènements n'est pas accessible aux contrats sur la blockchain.
+Des [événements](https://media.consensys.net/technical-introduction-to-events-and-logs-in-ethereum-a074d65dd61e) sont émis pour informer les utilisateurs et les serveurs en dehors de la blockchain. Notez que le contenu des événements n'est pas disponible pour les contrats sur la blockchain.
 
 ```python
-# @dev Emits when ownership of any NFT changes by any mechanism. This event emits when NFTs are
-#      created (`from` == 0) and destroyed (`to` == 0). Exception: during contract creation, any
-#      number of NFTs may be created and assigned without emitting Transfer. At the time of any
-#      transfer, the approved address for that NFT (if any) is reset to none.
-# @param _from Sender of NFT (if address is zero address it indicates token creation).
-# @param _to Receiver of NFT (if address is zero address it indicates token destruction).
-# @param _tokenId The NFT that got transferred.
+# @dev Émet lorsque la propriété d'un NFT change par n'importe quel mécanisme. Cet événement est émis lorsque des NFT sont
+#      créés (`from` == 0) et détruits (`to` == 0). Exception : lors de la création du contrat, un
+#      nombre quelconque de NFT peut être créé et attribué sans émettre de Transfer. Au moment d'un
+#      transfert, l'adresse approuvée pour ce NFT (le cas échéant) est réinitialisée à aucune.
+# @param _from Expéditeur du NFT (si l'adresse est l'adresse zéro, cela indique la création du jeton).
+# @param _to Destinataire du NFT (si l'adresse est l'adresse zéro, cela indique la destruction du jeton).
+# @param _tokenId Le NFT qui a été transféré.
 event Transfer:
     sender: indexed(address)
     receiver: indexed(address)
     tokenId: indexed(uint256)
 ```
 
-On retrouve des similitudes avec l'évènement Transfer ERC-20, à l'exception du fait que nous fournissons un `tokenId` au lieu d'un montant. Personne n'est propriétaire de l'adresse zéro, donc par convention, on l'utilise pour indiquer la création et la destruction des jetons.
+C'est similaire à l'événement Transfer de l'ERC-20, sauf que nous déclarons un `tokenId` au lieu d'un montant.
+Personne ne possède l'adresse zéro, donc par convention, nous l'utilisons pour signaler la création et la destruction des jetons.
 
 ```python
-# @dev This emits when the approved address for an NFT is changed or reaffirmed. The zero
-#      address indicates there is no approved address. When a Transfer event emits, this also
-#      indicates that the approved address for that NFT (if any) is reset to none.
-# @param _owner Owner of NFT.
-# @param _approved Address that we are approving.
-# @param _tokenId NFT which we are approving.
+# @dev Émet lorsque l'adresse approuvée pour un NFT est modifiée ou reconfirmée. L'adresse
+#      zéro indique qu'il n'y a pas d'adresse approuvée. Lorsqu'un événement Transfer est émis, cela
+#      indique également que l'adresse approuvée pour ce NFT (le cas échéant) est réinitialisée à aucune.
+# @param _owner Propriétaire du NFT.
+# @param _approved Adresse que nous approuvons.
+# @param _tokenId NFT que nous approuvons.
 event Approval:
     owner: indexed(address)
     approved: indexed(address)
     tokenId: indexed(uint256)
 ```
 
-Un évènement d'approbation ERC-721 est comparable à une autorisation ERC-20. Une adresse spécifique est autorisée à transférer un jeton spécifique. Cela donne un mécanisme permettant aux contrats de répondre lorsqu'ils acceptent un jeton. Les contrats ne peuvent pas écouter les évènements, donc si vous leur transférez simplement le jeton, ils n'en seront pas « informés ». De cette façon, le propriétaire envoie d'abord un évènement d'approbation, puis envoie une demande au contrat : « J'ai autorisé le transfert du jeton X, veuillez ... ».
+Une approbation ERC-721 est similaire à une autorisation ERC-20. Une adresse spécifique est autorisée à transférer un jeton spécifique. Cela fournit un mécanisme permettant aux contrats de répondre lorsqu'ils acceptent un jeton. Les contrats ne peuvent pas écouter les événements, donc si vous leur transférez simplement le jeton, ils n'en seront pas « informés ». De cette façon, le propriétaire soumet d'abord une approbation, puis envoie une demande au contrat : « Je vous ai autorisé à transférer le jeton X, veuillez le faire... ».
 
-Il s'agit d'un choix de conception visant à rendre la norme ERC-721 similaire à la norme ERC-20. Les jetons ERC-721 n'étant pas fongibles, un contrat peut aussi déterminer qu'il a reçu un jeton spécifique en regardant la propriété du jeton.
+Il s'agit d'un choix de conception visant à rendre la norme ERC-721 similaire à la norme ERC-20. Comme les jetons ERC-721 ne sont pas fongibles, un contrat peut également identifier qu'il a reçu un jeton spécifique en consultant la propriété du jeton.
 
 ```python
-# @dev This emits when an operator is enabled or disabled for an owner. The operator can manage
-#      all NFTs of the owner.
-# @param _owner Owner of NFT.
-# @param _operator Address to which we are setting operator rights.
-# @param _approved Status of operator rights(true if operator rights are given and false if
-# revoked).
+# @dev Émet lorsqu'un opérateur est activé ou désactivé pour un propriétaire. L'opérateur peut gérer
+#      tous les NFT du propriétaire.
+# @param _owner Propriétaire du NFT.
+# @param _operator Adresse à laquelle nous accordons les droits d'opérateur.
+# @param _approved Statut des droits d'opérateur (true si les droits d'opérateur sont accordés et false si
+# révoqués).
 event ApprovalForAll:
     owner: indexed(address)
     operator: indexed(address)
     approved: bool
 ```
 
-Il est parfois utile de disposer d'un _opérateur_ qui peut gérer tous les jetons d'un compte d'un type spécifique (ceux qui sont gérés par un contrat spécifique), à la manière d'une procuration. Par exemple, je pourrais vouloir donner ce rôle à un contrat qui vérifie si je ne l'ai pas contacté pendant six mois et qui, le cas échéant, distribuerait mes biens à mes héritiers (si l'un d'entre eux le demande, en effet, les contrats ne peuvent rien faire sans être appelés par une transaction). Avec ERC-20, nous avons simplement à allouer un quota élevé à un contrat d'héritage, mais cela ne fonctionne pas avec ERC-721, car les jetons ne sont pas fongibles. C'est l'équivalent.
+Il est parfois utile de disposer d'un _opérateur_ qui peut gérer tous les jetons d'un compte d'un type spécifique (ceux qui sont gérés par un contrat spécifique), à la manière d'une procuration. Par exemple, je pourrais vouloir donner un tel pouvoir à un contrat qui vérifie si je ne l'ai pas contacté depuis six mois et, si c'est le cas, distribue mes actifs à mes héritiers (si l'un d'eux le demande, car les contrats ne peuvent rien faire sans être appelés par une transaction). Avec l'ERC-20, nous pouvons simplement donner une autorisation élevée à un contrat d'héritage, mais cela ne fonctionne pas pour l'ERC-721 car les jetons ne sont pas fongibles. C'est l'équivalent.
 
-La valeur `approved` nous indique si l'évènement concerne une approbation ou bien le retrait d'une approbation.
+La valeur `approved` nous indique si l'événement concerne une approbation ou le retrait d'une approbation.
 
 ### Variables d'état {#state-vars}
 
-Ces variables contiennent l'état actuel des jetons : lesquels sont disponibles et qui les possède. La plupart d'entre elles sont des objets de type `HashMap`, [une mise en correspondance (mapping) unidirectionnelle entre deux types](https://vyper.readthedocs.io/en/latest/types.html#mappings).
+Ces variables contiennent l'état actuel des jetons : lesquels sont disponibles et qui les possède. La plupart d'entre elles sont des objets `HashMap`, des [mappages unidirectionnels qui existent entre deux types](https://vyper.readthedocs.io/en/latest/types.html#mappings).
 
 ```python
-# @dev Mapping from NFT ID to the address that owns it.
+# @dev Mappage de l'ID du NFT à l'adresse qui le possède.
 idToOwner: HashMap[uint256, address]
 
-# @dev Mapping from NFT ID to approved address.
+# @dev Mappage de l'ID du NFT à l'adresse approuvée.
 idToApprovals: HashMap[uint256, address]
 ```
 
-Les identités des utilisateurs et les contrats sur Ethereum sont représentés par des adresses de 160 bits. Les deux variables ci-dessus mettent respectivement en correspondance les identifiants des jetons à leur propriétaire, et aux personnes autorisées à les transférer (au maximum un jeton pour chacun). Sur Ethereum, les données non initialisées sont toujours égales à zéro, donc s'il n'y a pas de propriétaire ou de transféreur approuvé, la valeur de ce jeton sera zéro.
+Les identités des utilisateurs et des contrats dans Ethereum sont représentées par des adresses de 160 bits. Ces deux variables mappent les ID des jetons à leurs propriétaires et à ceux approuvés pour les transférer (au maximum un pour chaque). Dans Ethereum, les données non initialisées sont toujours nulles, donc s'il n'y a pas de propriétaire ou de transféreur approuvé, la valeur de ce jeton est nulle.
 
 ```python
-# @dev Mapping from owner address to count of his tokens.
+# @dev Mappage de l'adresse du propriétaire au nombre de ses jetons.
 ownerToNFTokenCount: HashMap[address, uint256]
 ```
 
-Cette variable contient le nombre de jetons pour chaque propriétaire. Il n'y a pas de correspondance entre les propriétaires et les jetons, donc la seule manière d'identifier les jetons qu'un propriétaire spécifique possède est de regarder dans l'historique des évènements de la blockchain et d'y trouver les évènements `Transfer` associés à ce dernier. Cette variable peut être utilisée pour déterminer quand nous avons tous les NFT et que nous n'avons pas besoin d'attendre plus longtemps.
+Cette variable contient le nombre de jetons pour chaque propriétaire. Il n'y a pas de mappage des propriétaires vers les jetons, donc la seule façon d'identifier les jetons qu'un propriétaire spécifique possède est de consulter l'historique des événements de la blockchain et de voir les événements `Transfer` appropriés. Nous pouvons utiliser cette variable pour savoir quand nous avons tous les NFT et que nous n'avons pas besoin de chercher plus loin dans le temps.
 
-Veuillez noter que cet algorithme ne fonctionne qu'avec les interfaces utilisateurs et les serveurs externes. Le code qui s'exécute sur la blockchain elle-même ne peut pas accéder aux évènements passés.
+Notez que cet algorithme ne fonctionne que pour les interfaces utilisateur et les serveurs externes. Le code s'exécutant sur la blockchain elle-même ne peut pas lire les événements passés.
 
 ```python
-# @dev Mapping from owner address to mapping of operator addresses.
+# @dev Mappage de l'adresse du propriétaire au mappage des adresses des opérateurs.
 ownerToOperators: HashMap[address, HashMap[address, bool]]
 ```
 
-Un compte peut avoir plus d'un opérateur. Une simple `HashMap` est insuffisante pour tous les stocker, parce que chaque clé correspond à une seule valeur. À la place, vous pouvez utiliser `HashMap[address, bool]` en tant que valeur. Par défaut, la valeur de chaque adresse est `False`, ce qui signifie qu'il ne s'agit pas d'un opérateur. Vous pouvez changer les valeurs à `True` si nécessaire.
+Un compte peut avoir plus d'un opérateur. Un `HashMap` simple est insuffisant pour en garder la trace, car chaque clé mène à une seule valeur. À la place, vous pouvez utiliser `HashMap[address, bool]` comme valeur. Par défaut, la valeur de chaque adresse est `False`, ce qui signifie qu'il ne s'agit pas d'un opérateur. Vous pouvez définir les valeurs à `True` si nécessaire.
 
 ```python
-# @dev Address of minter, who can mint a token
+# @dev Adresse du minter, qui peut frapper un jeton
 minter: address
 ```
 
-Les nouveaux jetons doivent être créés d'une manière ou d'une autre. Dans ce contrat, une seule entité est autorisée à le faire, le `minter`. Cela devrait suffire dans le cas d'un jeu, par exemple. Dans d'autres situations, il se pourrait que vous ayez besoin de créer une stratégie commerciale plus complexe.
+Les nouveaux jetons doivent être créés d'une manière ou d'une autre. Dans ce contrat, il n'y a qu'une seule entité autorisée à le faire, le `minter`. Ceci est probablement suffisant pour un jeu, par exemple. À d'autres fins, il pourrait être nécessaire de créer une logique métier plus compliquée.
 
 ```python
-# @dev Mapping of interface id to bool about whether or not it's supported
+# @dev Mappage de l'ID de l'interface à un booléen indiquant si elle est prise en charge ou non
 supportedInterfaces: HashMap[bytes32, bool]
 
-# @dev ERC165 interface ID of ERC165
+# @dev ID d'interface ERC165 de ERC165
 ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
 
-# @dev ERC165 interface ID of ERC721
+# @dev ID d'interface ERC165 de ERC721
 ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
 ```
 
-[ERC-165](https://eips.ethereum.org/EIPS/eip-165) définit un mécanisme permettant à un contrat de préciser comment les applications peuvent communiquer avec ce dernier, auquel les normes ERC se conforment. Dans cet exemple, le contrat se conforme aux normes ERC-165 et ERC-721.
+L'[ERC-165](https://eips.ethereum.org/EIPS/eip-165) spécifie un mécanisme permettant à un contrat de divulguer la manière dont les applications peuvent communiquer avec lui et à quelles normes ERC il se conforme. Dans ce cas, le contrat est conforme aux normes ERC-165 et ERC-721.
 
 ### Fonctions {#functions}
 
-Ce sont les fonctions qui mettent véritablement ERC-721 en œuvre.
+Ce sont les fonctions qui implémentent réellement l'ERC-721.
 
 #### Constructeur {#constructor}
 
@@ -194,15 +197,15 @@ Ce sont les fonctions qui mettent véritablement ERC-721 en œuvre.
 def __init__():
 ```
 
-En Vyper, tout comme en Python, la fonction constructeur est appelée `__init__`.
+En Vyper, comme en Python, la fonction constructeur est appelée `__init__`.
 
 ```python
     """
-    @dev Contract constructor.
+    @dev Constructeur de contrat.
     """
 ```
 
-En Python, et en Vyper, vous pouvez aussi écrire des commentaires en spécifiant une chaîne de caractères multi-lignes (qui doit commencer et se terminer par `"""`), et ne l'utiliser en aucune façon. Les commentaires prennent également [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) en charge.
+En Python et en Vyper, vous pouvez également créer un commentaire en spécifiant une chaîne multiligne (qui commence et se termine par `"""`), sans l'utiliser d'aucune façon. Ces commentaires peuvent également inclure [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html).
 
 ```python
     self.supportedInterfaces[ERC165_INTERFACE_ID] = True
@@ -210,57 +213,59 @@ En Python, et en Vyper, vous pouvez aussi écrire des commentaires en spécifian
     self.minter = msg.sender
 ```
 
-Pour accéder aux variables d'état, on utilise `self.<variable name>` (encore une fois, comme en Python).
+Pour accéder aux variables d'état, vous utilisez `self.<nom de la variable>`(encore une fois, comme en Python).
 
-#### Fonctions « view » {#views}
+#### Fonctions de vue {#views}
 
-Ce sont des fonctions qui ne modifient pas l'état de la blockchain, et qui peuvent donc être exécutées gratuitement lorsqu'elles sont appelées en externe. Si ces fonctions sont appelées par un contrat, elles doivent quand-même être exécutées sur chaque nœud, et coûtent ainsi du gaz.
+Ce sont des fonctions qui ne modifient pas l'état de la blockchain et qui peuvent donc être exécutées gratuitement si elles sont appelées en externe. Si les fonctions de vue sont appelées par un contrat, elles doivent tout de même être exécutées sur chaque nœud et coûtent donc du gaz.
 
 ```python
 @view
 @external
 ```
 
-Ces mot-clés commençant par une arobase (`@`) précèdent une définition de fonction et s'appellent des _décorateurs_. Ils déterminent les circonstances dans lesquelles une fonction peut être appelée.
+Ces mots-clés précédant une définition de fonction qui commencent par un signe « at » (`@`) sont appelés des _décorations_. Ils spécifient les circonstances dans lesquelles une fonction peut être appelée.
 
-- `@view` spécifie que la fonction est de type « view ».
-- `@external` spécifie que cette fonction peut être appelée par des transactions et par d'autres contrats.
+- `@view` spécifie que cette fonction est une vue.
+- `@external` spécifie que cette fonction particulière peut être appelée par des transactions et par d'autres contrats.
 
 ```python
 def supportsInterface(_interfaceID: bytes32) -> bool:
 ```
 
-À la différence de Python, Vyper est un [langage à typage statique](https://wikipedia.org/wiki/Type_system#Static_type_checking). Vous ne pouvez pas déclarer une variable, ou un paramètre de fonction, sans préciser le [type de donnée](https://vyper.readthedocs.io/en/latest/types.html). Dans le cas présent, le paramètre d'entrée est `bytes32`, une valeur de 256 bits (cela correspond à la longueur de mot native au sein de la [machine virtuelle Ethereum](/developers/docs/evm/)). La valeur de sortie est de type booléen. Par convention, les noms des paramètres d'une fonction commencent par un tiret bas (`_`).
+Contrairement à Python, Vyper est un [langage à typage statique](https://wikipedia.org/wiki/Type_system#Static_type_checking).
+Vous ne pouvez pas déclarer une variable, ou un paramètre de fonction, sans identifier le [type de données](https://vyper.readthedocs.io/en/latest/types.html). Dans ce cas, le paramètre d'entrée est `bytes32`, une valeur de 256 bits (256 bits est la taille de mot native de la [machine virtuelle Ethereum](/developers/docs/evm/)). La sortie est une valeur booléenne. Par convention, les noms des paramètres de fonction commencent par un trait de soulignement (`_`).
 
 ```python
     """
-    @dev Interface identification is specified in ERC-165.
-    @param _interfaceID Id of the interface
+    @dev L'identification de l'interface est spécifiée dans l'ERC-165.
+    @param _interfaceID ID de l'interface
     """
     return self.supportedInterfaces[_interfaceID]
 ```
 
-Retourne la valeur de type HashMap contenue dans `self.supportedInterfaces`, qui est définie dans le constructeur (`__init__`).
+Retourne la valeur du HashMap `self.supportedInterfaces`, qui est définie dans le constructeur (`__init__`).
 
 ```python
-### VIEW FUNCTIONS ###
+### FONCTIONS DE VUE ###
+
 ```
 
-Ce sont les fonctions « view » qui rendent les informations sur les jetons accessibles aux utilisateurs et aux autres contrats.
+Ce sont les fonctions de vue qui rendent les informations sur les jetons disponibles pour les utilisateurs et autres contrats.
 
 ```python
 @view
 @external
 def balanceOf(_owner: address) -> uint256:
     """
-    @dev Returns the number of NFTs owned by `_owner`.
-         Throws if `_owner` is the zero address. NFTs assigned to the zero address are considered invalid.
-    @param _owner Address for whom to query the balance.
+    @dev Retourne le nombre de NFT détenus par `_owner`.
+         Lance une exception si `_owner` est l'adresse zéro. Les NFT attribués à l'adresse zéro sont considérés comme non valides.
+    @param _owner Adresse pour laquelle interroger le solde.
     """
     assert _owner != ZERO_ADDRESS
 ```
 
-Cette ligne [confirme](https://vyper.readthedocs.io/en/latest/statements.html#assert) le fait qu'`_owner` n'est pas égal à zéro. Si c'est le cas, il y a une erreur et l'opération est annulée.
+Cette ligne [affirme](https://vyper.readthedocs.io/en/latest/statements.html#assert) que `_owner` n'est pas zéro. Si c'est le cas, il y a une erreur et l'opération est annulée.
 
 ```python
     return self.ownerToNFTokenCount[_owner]
@@ -269,70 +274,73 @@ Cette ligne [confirme](https://vyper.readthedocs.io/en/latest/statements.html#as
 @external
 def ownerOf(_tokenId: uint256) -> address:
     """
-    @dev Returns the address of the owner of the NFT.
-         Throws if `_tokenId` is not a valid NFT.
-    @param _tokenId The identifier for an NFT.
+    @dev Retourne l'adresse du propriétaire du NFT.
+         Lance une exception si `_tokenId` n'est pas un NFT valide.
+    @param _tokenId L'identifiant d'un NFT.
     """
     owner: address = self.idToOwner[_tokenId]
-    # Throws if `_tokenId` is not a valid NFT
+    # Lance une exception si `_tokenId` n'est pas un NFT valide
     assert owner != ZERO_ADDRESS
     return owner
 ```
 
-Dans la machine virtuelle Ethereum (EVM), tout espace mémoire qui n'a pas de valeur stockée contient zéro. Si la valeur de `_tokenId` ne contient pas de jeton, alors la valeur de `self.idToOwner[_tokenId]` est égale à zéro. Dans ce cas, la fonction annule son exécution.
+Dans la machine virtuelle Ethereum (EVM), tout stockage qui ne contient pas de valeur stockée est égal à zéro.
+S'il n'y a pas de jeton à `_tokenId`, alors la valeur de `self.idToOwner[_tokenId]` est zéro. Dans ce cas, la fonction est annulée.
 
 ```python
 @view
 @external
 def getApproved(_tokenId: uint256) -> address:
     """
-    @dev Get the approved address for a single NFT.
-         Throws if `_tokenId` is not a valid NFT.
-    @param _tokenId ID of the NFT to query the approval of.
+    @dev Obtient l'adresse approuvée pour un seul NFT.
+         Lance une exception si `_tokenId` n'est pas un NFT valide.
+    @param _tokenId ID du NFT pour lequel interroger l'approbation.
     """
-    # Throws if `_tokenId` is not a valid NFT
+    # Lance une exception si `_tokenId` n'est pas un NFT valide
     assert self.idToOwner[_tokenId] != ZERO_ADDRESS
     return self.idToApprovals[_tokenId]
 ```
 
-Notez que `getApproved` _peut_ retourner zéro. Si le jeton est valide, la fonction retourne `self.idToApprovals[_tokenId]`. S'il n'y a pas d'approbateur, la valeur est égale à zéro.
+Notez que `getApproved` _peut_ retourner zéro. Si le jeton est valide, il retourne `self.idToApprovals[_tokenId]`.
+S'il n'y a pas d'approbateur, cette valeur est zéro.
 
 ```python
 @view
 @external
 def isApprovedForAll(_owner: address, _operator: address) -> bool:
     """
-    @dev Checks if `_operator` is an approved operator for `_owner`.
-    @param _owner The address that owns the NFTs.
-    @param _operator The address that acts on behalf of the owner.
+    @dev Vérifie si `_operator` est un opérateur approuvé pour `_owner`.
+    @param _owner L'adresse qui possède les NFT.
+    @param _operator L'adresse qui agit au nom du propriétaire.
     """
     return (self.ownerToOperators[_owner])[_operator]
 ```
 
-La fonction vérifie qu'`_operator` est autorisé à gérer tous les jetons d'`_owner` dans ce contrat. Comme il peut y avoir plusieurs opérateurs, il s'agit d'une HashMap à deux dimensions.
+Cette fonction vérifie si `_operator` est autorisé à gérer tous les jetons de `_owner` dans ce contrat.
+Comme il peut y avoir plusieurs opérateurs, il s'agit d'un HashMap à deux niveaux.
 
-#### Fonctions relatives au transfert {#transfer-helpers}
+#### Fonctions d'aide au transfert {#transfer-helpers}
 
-Ces fonctions effectuent des opérations qui concernent le transfert ou la gestion des jetons.
+Ces fonctions implémentent des opérations qui font partie du transfert ou de la gestion des jetons.
 
 ```python
 
-### TRANSFER FUNCTION HELPERS ###
+### FONCTIONS D'AIDE AU TRANSFERT ###
 
 @view
 @internal
 ```
 
-Ce décorateur, `@internal`, signifie que la fonction est uniquement accessible aux autres fonctions de ce contrat. Par convention, le nom de ces fonctions commence par un tiret bas (`_`).
+Cette décoration, `@internal`, signifie que la fonction n'est accessible qu'à partir d'autres fonctions du même contrat. Par convention, ces noms de fonction commencent également par un trait de soulignement (`_`).
 
 ```python
 def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
     """
-    @dev Returns whether the given spender can transfer a given token ID
-    @param spender address of the spender to query
-    @param tokenId uint256 ID of the token to be transferred
-    @return bool whether the msg.sender is approved for the given token ID,
-        is an operator of the owner, or is the owner of the token
+    @dev Retourne si le dépensier donné peut transférer un ID de jeton donné
+    @param spender adresse du dépensier à interroger
+    @param tokenId uint256 ID du jeton à transférer
+    @return bool si le msg.sender est approuvé pour l'ID de jeton donné,
+        est un opérateur du propriétaire, ou est le propriétaire du jeton
     """
     owner: address = self.idToOwner[_tokenId]
     spenderIsOwner: bool = owner == _spender
@@ -341,117 +349,117 @@ def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
     return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
 ```
 
-Il existe trois façons d'autoriser une adresse à transférer un jeton :
+Il y a trois façons pour une adresse d'être autorisée à transférer un jeton :
 
 1. L'adresse est le propriétaire du jeton
-2. L'adresse est autorisée à utiliser ce jeton
+2. L'adresse est approuvée pour dépenser ce jeton
 3. L'adresse est un opérateur pour le propriétaire du jeton
 
-La fonction ci-dessus peut être « view », car elle ne modifie par l'état. Pour réduire les coûts d'exécution, toute fonction qui _peut_ être « view » _devrait_ être « view ».
+La fonction ci-dessus peut être une vue car elle ne modifie pas l'état. Pour réduire les coûts d'exploitation, toute fonction qui _peut_ être une vue _devrait_ être une vue.
 
 ```python
 @internal
 def _addTokenTo(_to: address, _tokenId: uint256):
     """
-    @dev Add a NFT to a given address
-         Throws if `_tokenId` is owned by someone.
+    @dev Ajoute un NFT à une adresse donnée
+         Lance une exception si `_tokenId` est détenu par quelqu'un.
     """
-    # Throws if `_tokenId` is owned by someone
+    # Lance une exception si `_tokenId` est détenu par quelqu'un
     assert self.idToOwner[_tokenId] == ZERO_ADDRESS
-    # Change the owner
+    # Change le propriétaire
     self.idToOwner[_tokenId] = _to
-    # Change count tracking
+    # Change le suivi du compte
     self.ownerToNFTokenCount[_to] += 1
 
 
 @internal
 def _removeTokenFrom(_from: address, _tokenId: uint256):
     """
-    @dev Remove a NFT from a given address
-         Throws if `_from` is not the current owner.
+    @dev Supprime un NFT d'une adresse donnée
+         Lance une exception si `_from` n'est pas le propriétaire actuel.
     """
-    # Throws if `_from` is not the current owner
+    # Lance une exception si `_from` n'est pas le propriétaire actuel
     assert self.idToOwner[_tokenId] == _from
-    # Change the owner
+    # Change le propriétaire
     self.idToOwner[_tokenId] = ZERO_ADDRESS
-    # Change count tracking
+    # Change le suivi du compte
     self.ownerToNFTokenCount[_from] -= 1
 ```
 
-Lorsqu'il y a un problème avec un transfert, on annule l'appel de la fonction.
+En cas de problème avec un transfert, nous annulons l'appel.
 
 ```python
 @internal
 def _clearApproval(_owner: address, _tokenId: uint256):
     """
-    @dev Clear an approval of a given address
-         Throws if `_owner` is not the current owner.
+    @dev Efface une approbation d'une adresse donnée
+         Lance une exception si `_owner` n'est pas le propriétaire actuel.
     """
-    # Throws if `_owner` is not the current owner
+    # Lance une exception si `_owner` n'est pas le propriétaire actuel
     assert self.idToOwner[_tokenId] == _owner
     if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
-        # Reset approvals
+        # Réinitialise les approbations
         self.idToApprovals[_tokenId] = ZERO_ADDRESS
 ```
 
-Ne changez cette valeur que si c'est nécessaire. Les variables d'état se trouvent dans le stockage. Modifier le stockage est une des opérations les plus coûteuses que l'EVM (la machine virtuelle Ethereum) peut effectuer (en termes de [gaz](/developers/docs/gas/)). Par conséquent, il est préférable de l'éviter, même pour écrire que la valeur existante a un coût élevé.
+Ne modifiez la valeur que si nécessaire. Les variables d'état vivent dans le stockage. L'écriture dans le stockage est l'une des opérations les plus coûteuses que l'EVM (machine virtuelle Ethereum) effectue (en termes de [gaz](/developers/docs/gas/)). Par conséquent, il est conseillé de la minimiser, même l'écriture de la valeur existante a un coût élevé.
 
 ```python
 @internal
 def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
     """
-    @dev Execute transfer of a NFT.
-         Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
-         address for this NFT. (NOTE: `msg.sender` not allowed in private function so pass `_sender`.)
-         Throws if `_to` is the zero address.
-         Throws if `_from` is not the current owner.
-         Throws if `_tokenId` is not a valid NFT.
+    @dev Exécute le transfert d'un NFT.
+         Lance une exception sauf si `msg.sender` est le propriétaire actuel, un opérateur autorisé, ou l'adresse
+         approuvée pour ce NFT. (NOTE : `msg.sender` n'est pas autorisé dans une fonction privée, donc passez `_sender`.)
+         Lance une exception si `_to` est l'adresse zéro.
+         Lance une exception si `_from` n'est pas le propriétaire actuel.
+         Lance une exception si `_tokenId` n'est pas un NFT valide.
     """
 ```
 
-Nous avons cette fonction interne à disposition parce qu'il existe deux façons de transférer des jetons (« normale » et « sûre »), mais nous souhaitons que cela ne se passe qu'à un seul endroit du code, afin de simplifier l'audit.
+Nous avons cette fonction interne car il y a deux façons de transférer des jetons (régulière et sûre), mais nous ne voulons qu'un seul emplacement dans le code où nous le faisons pour faciliter l'audit.
 
 ```python
-    # Check requirements
+    # Vérifier les exigences
     assert self._isApprovedOrOwner(_sender, _tokenId)
-    # Throws if `_to` is the zero address
+    # Lance une exception si `_to` est l'adresse zéro
     assert _to != ZERO_ADDRESS
-    # Clear approval. Throws if `_from` is not the current owner
+    # Effacer l'approbation. Lance une exception si `_from` n'est pas le propriétaire actuel
     self._clearApproval(_from, _tokenId)
-    # Remove NFT. Throws if `_tokenId` is not a valid NFT
+    # Supprimer le NFT. Lance une exception si `_tokenId` n'est pas un NFT valide
     self._removeTokenFrom(_from, _tokenId)
-    # Add NFT
+    # Ajouter le NFT
     self._addTokenTo(_to, _tokenId)
-    # Log the transfer
+    # Journaliser le transfert
     log Transfer(_from, _to, _tokenId)
 ```
 
-Pour émettre un évènement dans Vyper, on utilise le mot-clé `log` ([cliquer ici pour plus de détails](https://vyper.readthedocs.io/en/latest/event-logging.html#event-logging)).
+Pour émettre un événement en Vyper, vous utilisez une instruction `log` ([voir ici pour plus de détails](https://vyper.readthedocs.io/en/latest/event-logging.html#event-logging)).
 
 #### Fonctions de transfert {#transfer-funs}
 
 ```python
 
-### TRANSFER FUNCTIONS ###
+### FONCTIONS DE TRANSFERT ###
 
 @external
 def transferFrom(_from: address, _to: address, _tokenId: uint256):
     """
-    @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
-         address for this NFT.
-         Throws if `_from` is not the current owner.
-         Throws if `_to` is the zero address.
-         Throws if `_tokenId` is not a valid NFT.
-    @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else
-            they maybe be permanently lost.
-    @param _from The current owner of the NFT.
-    @param _to The new owner.
-    @param _tokenId The NFT to transfer.
+    @dev Lance une exception sauf si `msg.sender` est le propriétaire actuel, un opérateur autorisé ou l'adresse
+         approuvée pour ce NFT.
+         Lance une exception si `_from` n'est pas le propriétaire actuel.
+         Lance une exception si `_to` est l'adresse zéro.
+         Lance une exception si `_tokenId` n'est pas un NFT valide.
+    @notice L'appelant est responsable de confirmer que `_to` est capable de recevoir des NFT, sinon
+            ils pourraient être perdus de manière permanente.
+    @param _from Le propriétaire actuel du NFT.
+    @param _to Le nouveau propriétaire.
+    @param _tokenId Le NFT à transférer.
     """
     self._transferFrom(_from, _to, _tokenId, msg.sender)
 ```
 
-Cette fonction permet d'effectuer un transfert vers l'adresse souhaitée. À moins que l'adresse représente un utilisateur ou un contract capable de transférer des jetons, tout jeton que vous transférez sera bloqué à cette adresse et rendu inutilisable.
+Cette fonction vous permet de transférer vers une adresse arbitraire. À moins que l'adresse ne soit un utilisateur ou un contrat qui sait comment transférer des jetons, tout jeton que vous transférez sera bloqué dans cette adresse et inutilisable.
 
 ```python
 @external
@@ -462,30 +470,30 @@ def safeTransferFrom(
         _data: Bytes[1024]=b""
     ):
     """
-    @dev Transfers the ownership of an NFT from one address to another address.
-         Throws unless `msg.sender` is the current owner, an authorized operator, or the
-         approved address for this NFT.
-         Throws if `_from` is not the current owner.
-         Throws if `_to` is the zero address.
-         Throws if `_tokenId` is not a valid NFT.
-         If `_to` is a smart contract, it calls `onERC721Received` on `_to` and throws if
-         the return value is not `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
-         NOTE: bytes4 is represented by bytes32 with padding
-    @param _from The current owner of the NFT.
-    @param _to The new owner.
-    @param _tokenId The NFT to transfer.
-    @param _data Additional data with no specified format, sent in call to `_to`.
+    @dev Transfère la propriété d'un NFT d'une adresse à une autre.
+         Lance une exception sauf si `msg.sender` est le propriétaire actuel, un opérateur autorisé ou l'adresse
+         approuvée pour ce NFT.
+         Lance une exception si `_from` n'est pas le propriétaire actuel.
+         Lance une exception si `_to` est l'adresse zéro.
+         Lance une exception si `_tokenId` n'est pas un NFT valide.
+         Si `_to` est un contrat intelligent, il appelle `onERC721Received` sur `_to` et lance une exception si
+         la valeur de retour n'est pas `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
+         NOTE : bytes4 est représenté par bytes32 avec remplissage
+    @param _from Le propriétaire actuel du NFT.
+    @param _to Le nouveau propriétaire.
+    @param _tokenId Le NFT à transférer.
+    @param _data Données supplémentaires sans format spécifié, envoyées dans l'appel à `_to`.
     """
     self._transferFrom(_from, _to, _tokenId, msg.sender)
 ```
 
-Il est correct d'effectuer le transfert au début parce qu'en cas de problème, nous allons de toute façon revenir en arrière, ce qui revient à annuler tout ce qui aura été fait durant l'appel.
+Il est acceptable de faire le transfert en premier car en cas de problème, nous allons de toute façon annuler, donc tout ce qui a été fait dans l'appel sera annulé.
 
 ```python
-    if _to.is_contract: # check if `_to` is a contract address
+    if _to.is_contract: # vérifier si `_to` est une adresse de contrat
 ```
 
-Vérifiez d'abord si l'adresse est un contrat (si elle comporte du code). Si ce n'est pas le cas, il s'agit d'une adresse utilisateur et celui-ci pourra alors utiliser le jeton ou bien le transférer. Mais ne vous laissez pas tromper par un faux sentiment de sécurité. Vous pouvez perdre vos jetons, même avec `safeTransferFrom`, si vous les transférez vers une adresse dont personne ne connaît la clé privée.
+Vérifiez d'abord si l'adresse est un contrat (si elle a du code). Sinon, supposez qu'il s'agit d'une adresse d'utilisateur et que l'utilisateur pourra utiliser le jeton ou le transférer. Mais ne vous laissez pas bercer par un faux sentiment de sécurité. Vous pouvez perdre des jetons, même avec `safeTransferFrom`, si vous les transférez à une adresse dont personne ne connaît la clé privée.
 
 ```python
         returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
@@ -494,34 +502,34 @@ Vérifiez d'abord si l'adresse est un contrat (si elle comporte du code). Si ce
 Appelez le contrat cible pour voir s'il peut recevoir des jetons ERC-721.
 
 ```python
-        # Throws if transfer destination is a contract which does not implement 'onERC721Received'
+        # Lance une exception si la destination du transfert est un contrat qui n'implémente pas 'onERC721Received'
         assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)
 ```
 
-Si le destinataire est un contrat, mais qui ne peut pas recevoir de jetons ERC-721 (ou qui a choisi de refuser ce transfert en particulier), annulez.
+Si la destination est un contrat, mais qui n'accepte pas les jetons ERC-721 (ou qui a décidé de ne pas accepter ce transfert particulier), annulez.
 
 ```python
 @external
 def approve(_approved: address, _tokenId: uint256):
     """
-    @dev Set or reaffirm the approved address for an NFT. The zero address indicates there is no approved address.
-         Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.
-         Throws if `_tokenId` is not a valid NFT. (NOTE: This is not written the EIP)
-         Throws if `_approved` is the current owner. (NOTE: This is not written the EIP)
-    @param _approved Address to be approved for the given NFT ID.
-    @param _tokenId ID of the token to be approved.
+    @dev Définit ou reconfirme l'adresse approuvée pour un NFT. L'adresse zéro indique qu'il n'y a pas d'adresse approuvée.
+         Lance une exception sauf si `msg.sender` est le propriétaire actuel du NFT, ou un opérateur autorisé du propriétaire actuel.
+         Lance une exception si `_tokenId` n'est pas un NFT valide. (NOTE : Ceci n'est pas écrit dans l'EIP)
+         Lance une exception si `_approved` est le propriétaire actuel. (NOTE : Ceci n'est pas écrit dans l'EIP)
+    @param _approved Adresse à approuver pour l'ID de NFT donné.
+    @param _tokenId ID du jeton à approuver.
     """
     owner: address = self.idToOwner[_tokenId]
-    # Throws if `_tokenId` is not a valid NFT
+    # Lance une exception si `_tokenId` n'est pas un NFT valide
     assert owner != ZERO_ADDRESS
-    # Throws if `_approved` is the current owner
+    # Lance une exception si `_approved` est le propriétaire actuel
     assert _approved != owner
 ```
 
-Par convention, si vous ne souhaitez pas avoir d'approbateur, vous désignez l'adresse zéro, pas la vôtre.
+Par convention, si vous ne voulez pas avoir d'approbateur, vous désignez l'adresse zéro, et non vous-même.
 
 ```python
-    # Check requirements
+    # Vérifier les exigences
     senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
     senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
     assert (senderIsOwner or senderIsApprovedForAll)
@@ -530,7 +538,7 @@ Par convention, si vous ne souhaitez pas avoir d'approbateur, vous désignez l'a
 Pour définir une approbation, vous pouvez être soit le propriétaire, soit un opérateur autorisé par le propriétaire.
 
 ```python
-    # Set the approval
+    # Définir l'approbation
     self.idToApprovals[_tokenId] = _approved
     log Approval(owner, _approved, _tokenId)
 
@@ -538,14 +546,14 @@ Pour définir une approbation, vous pouvez être soit le propriétaire, soit un
 @external
 def setApprovalForAll(_operator: address, _approved: bool):
     """
-    @dev Enables or disables approval for a third party ("operator") to manage all of
-         `msg.sender`'s assets. It also emits the ApprovalForAll event.
-         Throws if `_operator` is the `msg.sender`. (NOTE: This is not written the EIP)
-    @notice This works even if sender doesn't own any tokens at the time.
-    @param _operator Address to add to the set of authorized operators.
-    @param _approved True if the operators is approved, false to revoke approval.
+    @dev Active ou désactive l'approbation pour un tiers ("opérateur") afin de gérer tous les
+         actifs de `msg.sender`. Il émet également l'événement ApprovalForAll.
+         Lance une exception si `_operator` est le `msg.sender`. (NOTE : Ceci n'est pas écrit dans l'EIP)
+    @notice Cela fonctionne même si l'expéditeur ne possède aucun jeton au moment de l'exécution.
+    @param _operator Adresse à ajouter à l'ensemble des opérateurs autorisés.
+    @param _approved True si les opérateurs sont approuvés, false pour révoquer l'approbation.
     """
-    # Throws if `_operator` is the `msg.sender`
+    # Lance une exception si `_operator` est le `msg.sender`
     assert _operator != msg.sender
     self.ownerToOperators[msg.sender][_operator] = _approved
     log ApprovalForAll(msg.sender, _operator, _approved)
@@ -553,10 +561,10 @@ def setApprovalForAll(_operator: address, _approved: bool):
 
 #### Frapper de nouveaux jetons et détruire ceux existants {#mint-burn}
 
-Le compte qui a créé le contrat est le `minter`, un super-utilisateur autorisé à frapper de nouveaux NFT. Cependant, même lui n'est pas autorisé à détruire des jetons existants. Seul le propriétaire, ou une entité autorisée par le propriétaire, peut faire cela.
+Le compte qui a créé le contrat est le `minter`, le super utilisateur autorisé à frapper de nouveaux NFT. Cependant, même lui n'est pas autorisé à détruire des jetons existants. Seul le propriétaire, ou une entité autorisée par le propriétaire, peut le faire.
 
 ```python
-### MINT & BURN FUNCTIONS ###
+### FONCTIONS DE FRAPPE ET DE DESTRUCTION ###
 
 @external
 def mint(_to: address, _tokenId: uint256) -> bool:
@@ -566,67 +574,70 @@ Cette fonction retourne toujours `True`, car si l'opération échoue, elle est a
 
 ```python
     """
-    @dev Function to mint tokens
-         Throws if `msg.sender` is not the minter.
-         Throws if `_to` is zero address.
-         Throws if `_tokenId` is owned by someone.
-    @param _to The address that will receive the minted tokens.
-    @param _tokenId The token id to mint.
-    @return A boolean that indicates if the operation was successful.
+    @dev Fonction pour frapper des jetons
+         Lance une exception si `msg.sender` n'est pas le minter.
+         Lance une exception si `_to` est l'adresse zéro.
+         Lance une exception si `_tokenId` est détenu par quelqu'un.
+    @param _to L'adresse qui recevra les jetons frappés.
+    @param _tokenId L'ID du jeton à frapper.
+    @return Un booléen qui indique si l'opération a réussi.
     """
-    # Throws if `msg.sender` is not the minter
+    # Lance une exception si `msg.sender` n'est pas le minter
     assert msg.sender == self.minter
 ```
 
-Seul le minter (le compte qui a créé le contrat ERC-721) peut créer de nouveaux jetons. Cela peut être un problème à l'avenir dans le cas où l'on souhaiterait changer l'identité du minter. Dans un contrat en production, vous voudriez probablement une fonction qui permette au minter de transférer des privilèges de minter à quelqu'un d'autre.
+Seul le minter (le compte qui a créé le contrat ERC-721) peut frapper de nouveaux jetons. Cela peut poser un problème à l'avenir si nous voulons changer l'identité du minter. Dans un contrat en production, vous voudriez probablement une fonction qui permet au minter de transférer les privilèges de minter à quelqu'un d'autre.
 
 ```python
-    # Throws if `_to` is zero address
+    # Lance une exception si `_to` est l'adresse zéro
     assert _to != ZERO_ADDRESS
-    # Add NFT. Throws if `_tokenId` is owned by someone
+    # Ajoute un NFT. Lance une exception si `_tokenId` est détenu par quelqu'un
     self._addTokenTo(_to, _tokenId)
     log Transfer(ZERO_ADDRESS, _to, _tokenId)
     return True
 ```
 
-Par convention, la création de nouveaux jetons compte comme un transfert depuis l'adresse zéro.
+Par convention, la frappe de nouveaux jetons est considérée comme un transfert depuis l'adresse zéro.
 
 ```python
 
 @external
 def burn(_tokenId: uint256):
     """
-    @dev Burns a specific ERC721 token.
-         Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
-         address for this NFT.
-         Throws if `_tokenId` is not a valid NFT.
-    @param _tokenId uint256 id of the ERC721 token to be burned.
+    @dev Brûle un jeton ERC721 spécifique.
+         Lance une exception sauf si `msg.sender` est le propriétaire actuel, un opérateur autorisé, ou l'adresse
+         approuvée pour ce NFT.
+         Lance une exception si `_tokenId` n'est pas un NFT valide.
+    @param _tokenId uint256 ID du jeton ERC721 à brûler.
     """
-    # Check requirements
+    # Vérifier les exigences
     assert self._isApprovedOrOwner(msg.sender, _tokenId)
     owner: address = self.idToOwner[_tokenId]
-    # Throws if `_tokenId` is not a valid NFT
+    # Lance une exception si `_tokenId` n'est pas un NFT valide
     assert owner != ZERO_ADDRESS
     self._clearApproval(owner, _tokenId)
     self._removeTokenFrom(owner, _tokenId)
     log Transfer(owner, ZERO_ADDRESS, _tokenId)
 ```
 
-Toute personne autorisée à transférer un jeton est autorisée à le détruire. Bien que détruire un jeton semble équivalent à le transférer à l'adresse zéro, celle-ci ne reçoit pas réellement le jeton. Cela nous permet de libérer tout l'espace de stockage qui était utilisé pour le jeton, ce qui peut réduire les frais de gaz de la transaction.
+Toute personne autorisée à transférer un jeton est autorisée à le détruire. Bien que la destruction d'un jeton semble équivalente à un transfert vers l'adresse zéro, l'adresse zéro ne reçoit pas réellement le jeton. Cela nous permet de libérer tout le stockage qui a été utilisé pour le jeton, ce qui peut réduire le coût en gaz de la transaction.
 
-## Utiliser ce contrat {#using-contract}
+## Utilisation de ce contrat {#using-contract}
 
-Contrairement à Solidity, Vyper n'a pas de système d'héritage. Il s'agit d'un choix de conception délibéré visant à rendre le code plus clair et donc plus facile à sécuriser. Donc pour créer votre propre contrat Vyper ERC-721, vous prenez [ce contrat](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy) puis vous le modifiez en fonction de la stratégie commerciale que vous souhaitez mettre en œuvre.
+Contrairement à Solidity, Vyper n'a pas d'héritage. C'est un choix de conception délibéré pour rendre le code plus clair et donc plus facile à sécuriser. Donc, pour créer votre propre contrat Vyper ERC-721, vous prenez [ce contrat](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy) et le modifiez pour implémenter la logique métier que vous souhaitez.
 
-### Conclusion {#conclusion}
+## Conclusion {#conclusion}
 
-Voici les principaux points à retenir sur ce contrat :
+Pour récapituler, voici quelques-unes des idées les plus importantes de ce contrat :
 
-- Pour recevoir des jetons ERC-721 par un transfert sécurisé, les contrats doivent implémenter l'interface `ERC721Receiver`.
-- Même si vous effectuez un transfert sécurisé, les jetons peuvent rester bloqués si vous les envoyez à une adresse dont la clé privée est inconnue.
-- Lorsqu'il y a un problème avec une opération, il est judicieux de `revert` (annuler) l'appel, plutôt que de simplement retourner une valeur d'échec.
-- Les tokens ERC-721 existent lorsqu'ils ont un propriétaire.
+- Pour recevoir des jetons ERC-721 avec un transfert sécurisé, les contrats doivent implémenter l'interface `ERC721Receiver`.
+- Même si vous utilisez un transfert sécurisé, les jetons peuvent toujours être bloqués si vous les envoyez à une adresse dont la clé privée est inconnue.
+- En cas de problème avec une opération, il est conseillé d'annuler (`revert`) l'appel, plutôt que de simplement retourner une valeur d'échec.
+- Les jetons ERC-721 existent lorsqu'ils ont un propriétaire.
 - Il existe trois façons d'être autorisé à transférer un NFT. Vous pouvez être le propriétaire, être approuvé pour un jeton spécifique, ou être un opérateur pour tous les jetons du propriétaire.
-- Les évènements antérieurs sont uniquement visibles en dehors de la blockchain. Le code exécuté à l'intérieur de la blockchain ne peut pas les voir.
+- Les événements passés ne sont visibles qu'en dehors de la blockchain. Le code exécuté à l'intérieur de la blockchain ne peut pas les voir.
+
+Maintenant, allez implémenter des contrats Vyper sécurisés.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
 
-Vous êtes maintenant prêts à implémenter des contrats Vyper sécurisés.
diff --git a/public/content/translations/fr/developers/tutorials/erc20-annotated-code/index.md b/public/content/translations/fr/developers/tutorials/erc20-annotated-code/index.md
index 2efbab42acd..f424a2e42b4 100644
--- a/public/content/translations/fr/developers/tutorials/erc20-annotated-code/index.md
+++ b/public/content/translations/fr/developers/tutorials/erc20-annotated-code/index.md
@@ -3,28 +3,33 @@ title: "Présentation du contrat ERC-20"
 description: Qu'est-ce que le contrat OpenZeppelin ERC-20 et pourquoi existe-t-il ?
 author: Ori Pomerantz
 lang: fr
-tags:
-  - "solidity"
-  - "erc-20"
+tags: [ "Solidity", "erc-20" ]
 skill: beginner
 published: 2021-03-09
 ---
 
 ## Introduction {#introduction}
 
-Ethereum est couramment utilisé par des groupes pour créer des jetons échangeables ou, dans un certain sens, leur propre monnaie. Ces jetons suivent généralement une norme, [ERC-20](/developers/docs/standards/tokens/erc-20/). Cette norme permet d'écrire des outils, tels que des groupes de liquidité et des portefeuilles, qui fonctionnent avec tous les jetons ERC-20. . Dans cet article nous allons analyser [l'implémentation d'OpenZeppelin Solidity ERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol), ainsi que la [définition d'interface](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol).
+Ethereum est couramment utilisé par des groupes pour créer des jetons échangeables ou, dans un certain sens, leur propre monnaie. Ces jetons suivent généralement une norme,
+[ERC-20](/developers/docs/standards/tokens/erc-20/). Cette norme permet de créer des outils, tels que des pools de liquidités et des portefeuilles, qui fonctionnent avec tous les jetons ERC-20
+. Dans cet article, nous analyserons l'[implémentation ERC20 de Solidity par OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol), ainsi que la [définition de l'interface](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol).
 
-Ceci est le code source annoté. Si vous voulez implémenter ERC-20, [lisez ce tutoriel](https://docs.openzeppelin.com/contracts/2.x/erc20-supply).
+Ceci est le code source annoté. Si vous souhaitez implémenter l'ERC-20,
+[lisez ce tutoriel](https://docs.openzeppelin.com/contracts/2.x/erc20-supply).
 
 ## L'interface {#the-interface}
 
-L'objectif d'un standard comme ERC-20 est de permettre de nombreuses implémentations de jetons interopérables entre applications, comme les portefeuilles et les échanges décentralisés. À cette fin, nous créons une [interface](https://www.geeksforgeeks.org/solidity-basics-of-interface/). Tout code qui a besoin d'utiliser le contrat de jeton peut employer les mêmes définitions dans l'interface et ainsi être compatible avec tous les contrats de jetons qui l'utilisent, qu'il s'agisse d'un portefeuille tel que MetaMask, une DApp comme etherscan.io, ou un contrat différent tel qu'un pool de liquidités.
+L'objectif d'une norme comme l'ERC-20 est de permettre de nombreuses implémentations de jetons interopérables entre les applications, comme les portefeuilles et les échanges décentralisés. Pour ce faire, nous créons une
+[interface](https://www.geeksforgeeks.org/solidity/solidity-basics-of-interface/). Tout code qui a besoin d'utiliser le contrat de jeton peut employer les mêmes définitions dans l'interface et être compatible avec tous les contrats de jetons qui l'utilisent, qu'il s'agisse d'un portefeuille tel que MetaMask, d'une dapp comme etherscan.io, ou d'un contrat différent tel qu'un pool de liquidités.
 
 ![Illustration de l'interface ERC-20](erc20_interface.png)
 
-Si vous êtes un programmeur expérimenté, vous vous souvenez probablement avoir déjà vu des constructions similaires dans [Java](https://www.w3schools.com/java/java_interface.asp) ou même dans des [fichiers d'en-tête C](https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html).
+Si vous êtes un programmeur expérimenté, vous vous souvenez probablement avoir vu des constructions similaires en [Java](https://www.w3schools.com/java/java_interface.asp)
+ou même dans des [fichiers d'en-tête C](https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html).
 
-Ceci est une définition de [l'interface ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) d'OpenZeppelin. C'est une traduction du [standard lisible par l'homme](https://eips.ethereum.org/EIPS/eip-20) en code Solidity. Bien sûr, l'interface elle-même ne définit pas _comment_ faire quoi que ce soit. Ceci est expliqué dans le code source du contrat ci-dessous.
+Ceci est une définition de l'[Interface ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)
+d'OpenZeppelin. C'est une traduction de la [norme lisible par l'homme](https://eips.ethereum.org/EIPS/eip-20) en code Solidity. Bien sûr, l'interface
+elle-même ne définit pas _comment_ faire quoi que ce soit. Ceci est expliqué dans le code source du contrat ci-dessous.
 
 &nbsp;
 
@@ -32,7 +37,8 @@ Ceci est une définition de [l'interface ERC-20](https://github.com/OpenZeppelin
 // SPDX-License-Identifier: MIT
 ```
 
-Les fichiers Solidity sont supposés inclure un identifiant de licence. [Vous pouvez consulter la liste des licences ici](https://spdx.org/licenses/). Si vous avez besoin d'une licence différente, dites de quoi il s'agit dans les commentaires.
+Les fichiers Solidity sont censés inclure un identifiant de licence. [Vous pouvez voir la liste des licences ici](https://spdx.org/licenses/). Si vous avez besoin d'une autre
+licence, il vous suffit de l'expliquer dans les commentaires.
 
 &nbsp;
 
@@ -40,17 +46,20 @@ Les fichiers Solidity sont supposés inclure un identifiant de licence. [Vous po
 pragma solidity >=0.6.0 <0.8.0;
 ```
 
-Le langage Solidity évolue rapidement et les nouvelles versions peuvent ne pas être compatibles avec l'ancien code ([voir ici](https://docs.soliditylang.org/en/v0.7.0/070-breaking-changes.html)). Par conséquent, c'est une bonne idée de ne pas spécifier seulement une version minimale du langage, mais également une version maximale, la dernière avec laquelle vous avez testé le code.
+Le langage Solidity évolue encore rapidement, et les nouvelles versions peuvent ne pas être compatibles avec l'ancien code
+([voir ici](https://docs.soliditylang.org/en/v0.7.0/070-breaking-changes.html)). Par conséquent, il est judicieux de spécifier non seulement une version minimale
+du langage, mais aussi une version maximale, la plus récente avec laquelle vous avez testé le code.
 
 &nbsp;
 
 ```solidity
 /**
- * @dev Interface of the ERC20 standard as defined in the EIP.
+ * @dev Interface de la norme ERC20 telle que définie dans l'EIP.
  */
 ```
 
-Le `@dev` dans le commentaire fait partie du [format NatSpec](https://docs.soliditylang.org/en/develop/natspec-format.html), utilisé pour produire la documentation à partir du code source.
+Le `@dev` dans le commentaire fait partie du [format NatSpec](https://docs.soliditylang.org/en/develop/natspec-format.html), utilisé pour produire de la
+documentation à partir du code source.
 
 &nbsp;
 
@@ -64,78 +73,100 @@ Par convention, les noms d'interface commencent par `I`.
 
 ```solidity
     /**
-     * @dev Returns the amount of tokens in existence.
+     * @dev Renvoie la quantité de jetons existants.
      */
     function totalSupply() external view returns (uint256);
 ```
 
-Cette fonction est `external`, ce qui signifie [qu'elle ne peut être appelée qu'extra-contractuellement](https://docs.soliditylang.org/en/v0.7.0/cheatsheet.html#index-2). Elle retourne la quantité totale de jetons dans le contrat. Cette valeur est fournie en utilisant le type de données le plus commun dans Ethereum, 256 bits non signé (256 bits est la taille native de l'EVM). Cette fonction est également une `view`, ce qui signifie qu'elle ne change pas l'état et peut donc être exécutée sur un seul nœud au lieu de devoir exécuter chaque nœud dans la blockchain. Ce type de fonction ne génère pas de transaction et n'est pas [énergétivore](/developers/docs/gas/).
+Cette fonction est `external`, ce qui signifie qu'[elle ne peut être appelée que depuis l'extérieur du contrat](https://docs.soliditylang.org/en/v0.7.0/cheatsheet.html#index-2).
+Elle renvoie la quantité totale de jetons dans le contrat. Cette valeur est renvoyée en utilisant le type de données le plus courant sur Ethereum, un entier non signé de 256 bits (256 bits est la taille
+de mot native de l'EVM). Cette fonction est également de type `view`, ce qui signifie qu'elle ne modifie pas l'état. Elle peut donc être exécutée sur un seul nœud, sans que tous les nœuds de la blockchain n'aient à l'exécuter
+. Ce type de fonction ne génère pas de transaction et n'a pas de coût en [gaz](/developers/docs/gas/).
 
-**Remarque :** En théorie, on peut avoir l'impression que le créateur d'un contrat est en capacité de tricher en indiquant une quantité totale inférieure à la valeur réelle et en faisant ainsi apparaître chaque jeton plus précieux qu'il ne l'est réellement. Avoir cette crainte c'est, cependant, méconnaître la vraie nature de la blockchain. Tout ce qui se passe sur la blockchain peut être vérifié par chaque nœud. Pour ce faire, le langage de code et le stockage de chaque contrat sont disponibles sur chaque nœud. Vous n'avez pas à publier le code Solidity de votre contrat, mais personne ne vous prendrait au sérieux à moins de publier le code source et la version de Solidity avec laquelle il a été compilé pour qu'il puisse ainsi être comparé au code langue de la machine que vous avez utilisé. Par exemple, voir [ce contrat](https://etherscan.io/address/0xa530F85085C6FE2f866E7FdB716849714a89f4CD#code).
+**Remarque :** En théorie, il pourrait sembler que le créateur d'un contrat puisse tricher en renvoyant une offre totale inférieure à la valeur réelle, faisant ainsi paraître chaque jeton
+plus précieux qu'il ne l'est en réalité. Cependant, cette crainte ignore la véritable nature de la blockchain. Tout ce qui se passe sur la blockchain peut être vérifié par
+chaque nœud. Pour ce faire, le code en langage machine et le stockage de chaque contrat sont disponibles sur chaque nœud. Bien que vous ne soyez pas obligé de publier le code Solidity
+de votre contrat, personne ne vous prendrait au sérieux si vous ne publiez pas le code source et la version de Solidity avec laquelle il a été compilé, afin qu'il puisse
+être vérifié par rapport au code en langage machine que vous avez fourni.
+Par exemple, consultez [ce contrat](https://eth.blockscout.com/address/0xa530F85085C6FE2f866E7FdB716849714a89f4CD?tab=contract).
 
 &nbsp;
 
 ```solidity
     /**
-     * @dev Returns the amount of tokens owned by `account`.
+     * @dev Renvoie la quantité de jetons détenus par `account`.
      */
     function balanceOf(address account) external view returns (uint256);
 ```
 
-Comme son nom même l'indique, `balanceOf` permet d'afficher le solde d'un compte. Les comptes Ethereum sont identifiés dans Solidity en utilisant le type d'`address` ayant une valeur de 160 bits. Également `external` et `view`.
+Comme son nom l'indique, `balanceOf` renvoie le solde d'un compte. Les comptes Ethereum sont identifiés dans Solidity à l'aide du type `address`, qui contient 160 bits.
+Elle est également `external` et `view`.
 
 &nbsp;
 
 ```solidity
     /**
-     * @dev Moves `amount` tokens from the caller's account to `recipient`.
+     * @dev Déplace un `montant` (`amount`) de jetons du compte de l'appelant vers le `destinataire` (`recipient`).
      *
-     * Returns a boolean value indicating whether the operation succeeded.
+     * Renvoie une valeur booléenne indiquant si l'opération a réussi.
      *
-     * Emits a {Transfer} event.
+     * Émet un événement {Transfer}.
      */
     function transfer(address recipient, uint256 amount) external returns (bool);
 ```
 
-La fonction `transfer` permet de transférer un jeton de l'appelant à une adresse différente. Cela implique un changement d'état, donc ce n'est pas une `view`. Lorsqu'un utilisateur appelle cette fonction, il crée une transaction qui a un coût exprimé en gaz. Il émet également un événement, `Transfer`, pour informer tout le monde sur la blockchain de cet événement.
+La fonction `transfer` transfère des jetons de l'appelant à une autre adresse. Cela implique un changement d'état, ce n'est donc pas une fonction de type `view`.
+Lorsqu'un utilisateur appelle cette fonction, cela crée une transaction et coûte du gaz. Elle émet également un événement, `Transfer`, pour informer tout le monde sur la
+blockchain de l'événement.
 
-La fonction a deux types de sortie pour deux différents types d'appels :
+La fonction a deux types de sortie pour deux types d'appelants différents :
 
-- Les utilisateurs qui appellent la fonction directement depuis une interface utilisateur. Typiquement, l'utilisateur soumet une transaction et n'attend pas la réponse, ce qui peut prendre un temps indéfini. L'utilisateur peut voir ce qui s'est passé en recherchant le reçu de transaction (qui est identifié par le hash de transaction) ou en recherchant l'événement `Transfer`.
-- Autres contrats qui appellent la fonction dans le cadre d'une transaction globale. Ces contrats donnent immédiatement des résultats parce qu'ils s'exécutent lors de la même transaction, de sorte qu'ils peuvent utiliser la valeur fournie par la fonction.
+- Les utilisateurs qui appellent la fonction directement depuis une interface utilisateur. Généralement, l'utilisateur soumet une transaction
+  et n'attend pas de réponse, ce qui peut prendre un temps indéfini. L'utilisateur peut voir ce qui s'est passé
+  en consultant le reçu de transaction (identifié par le hachage de la transaction) ou en recherchant l'événement
+  `Transfer`.
+- D'autres contrats, qui appellent la fonction dans le cadre d'une transaction globale. Ces contrats obtiennent le résultat immédiatement,
+  car ils s'exécutent dans la même transaction, et peuvent donc utiliser la valeur de retour de la fonction.
 
-Les autres fonctions qui changent l'état du contrat donnent le même type de résultat.
+Le même type de sortie est créé par les autres fonctions qui modifient l'état du contrat.
 
 &nbsp;
 
-Les allocations permettent à un compte de dépenser des jetons qui appartiennent à un autre propriétaire. C'est utile par exemple, pour les contrats qui agissent en tant que vendeurs. Les contrats ne peuvent pas suivre les événements. Si un acheteur devait par conséquent transférer directement des jetons au contrat du vendeur, ce contrat ne saurait pas qu'il y a eu paiement. Au lieu de cela, l'acheteur permet au contrat du vendeur de dépenser un certain montant, le vendeur transférant ce montant. Cela est possible grâce à une fonction appelée par le contrat du vendeur qui peut savoir si l'opération a réussi.
+Les allocations permettent à un compte de dépenser des jetons qui appartiennent à un autre propriétaire.
+C'est utile, par exemple, pour les contrats qui agissent en tant que vendeurs. Les contrats ne peuvent
+pas surveiller les événements, donc si un acheteur devait transférer directement des jetons au contrat du vendeur
+, ce contrat ne saurait pas qu'il a été payé. Au lieu de cela, l'acheteur autorise le contrat du vendeur
+à dépenser un certain montant, et le vendeur transfère ce montant.
+Cela se fait par le biais d'une fonction que le contrat du vendeur appelle, de sorte que le contrat du vendeur
+puisse savoir si l'opération a réussi.
 
 ```solidity
     /**
-     * @dev Indique le nombre restant de jetons que `spender` sera
-     * autorisé à dépenser pour le compte du `owner` par l'intermédiaire de {transferFrom}. Ce nombre est
-     * zéro par défaut.
+     * @dev Renvoie le nombre de jetons restants que `spender` sera
+     * autorisé à dépenser au nom de `owner` via {transferFrom}. La valeur par
+     * défaut est zéro.
      *
-     * Cette valeur change lorsque {approve} ou {transferFrom} sont appelés.
+     * Cette valeur change lorsque {approve} ou {transferFrom} sont appelées.
      */
     function allowance(address owner, address spender) external view returns (uint256);
 ```
 
-La fonction `allowance` permet à quiconque de demander à voir quelle allocation une adresse (`owner`) permet à une autre adresse (`spender`) de dépenser.
+La fonction `allowance` permet à quiconque de demander à voir quelle est l'allocation qu'une
+adresse (`owner`) autorise une autre adresse (`spender`) à dépenser.
 
 &nbsp;
 
 ```solidity
     /**
-     * @dev  Définit l''amount` comme étant l'allocation que le `spender` attribue aux jetons de l'appelant.
+     * @dev Définit le `montant` (`amount`) comme l'allocation de `spender` sur les jetons de l'appelant.
      *
-     * Renvoie une valeur booléenne indiquant si l'opération a réussi. 
+     * Renvoie une valeur booléenne indiquant si l'opération a réussi.
      *
-     * IMPORTANT: Attention ! Modifier une allocation par ce biais comporte un risque :
-     * celui que quelqu'un puisse utiliser à la fois l'ancienne et la nouvelle allocation en activant une
-     * commande de transactions erronée. Solution possible pour résoudre le problème
-     * réduire l'allocation du client à 0 et fixer la
-     * valeur souhaitée par la suite :
+     * IMPORTANT : Sachez que la modification d'une allocation avec cette méthode comporte le risque
+     * que quelqu'un puisse utiliser à la fois l'ancienne et la nouvelle allocation en raison d'un
+     * ordre de transaction malencontreux. Une solution possible pour atténuer cette
+     * condition de concurrence consiste à d'abord réduire à 0 l'allocation du dépensier, puis à définir la
+     * valeur souhaitée :
      * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
      *
      * Émet un événement {Approval}.
@@ -143,15 +174,19 @@ La fonction `allowance` permet à quiconque de demander à voir quelle allocatio
     function approve(address spender, uint256 amount) external returns (bool);
 ```
 
-La fonction `approve` crée une autorisation. Veillez à lire le message expliquant comment elle peut être mal utilisée. Sur Ethereum, vous contrôlez l'ordre de vos propres transactions mais vous ne pouvez pas contrôler l'ordre dans lequel les transactions des autres seront exécutées, à moins que vous attendiez pour soumettre votre propre transaction de voir que la transaction est exécutée de l'autre côté.
+La fonction `approve` crée une allocation. Assurez-vous de lire le message sur
+la façon dont elle peut être utilisée de manière abusive. Dans Ethereum, vous contrôlez l'ordre de vos propres transactions,
+mais vous ne pouvez pas contrôler l'ordre dans lequel les transactions des autres personnes seront
+exécutées, à moins que vous ne soumettiez pas votre propre transaction avant de voir que la
+transaction de l'autre partie a eu lieu.
 
 &nbsp;
 
 ```solidity
     /**
-     * @dev Déplace l``amount` des jetons du `sender`  vers le `recipient`  grâce au
-     * mécanisme d'allocation. l'`amount` est ensuite déduit de l'  
-     * allocation de l'appelant.
+     * @dev Déplace un `montant` (`amount`) de jetons de `sender` vers `recipient` en utilisant le
+     * mécanisme d'allocation. Le `montant` (`amount`) est ensuite déduit de l'allocation
+     * de l'appelant.
      *
      * Renvoie une valeur booléenne indiquant si l'opération a réussi.
      *
@@ -160,14 +195,14 @@ La fonction `approve` crée une autorisation. Veillez à lire le message expliqu
     function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 ```
 
-Enfin, `transferFrom` est utilisé par le client pour dépenser réellement l'allocation.
+Enfin, `transferFrom` est utilisé par le dépensier pour dépenser réellement l'allocation.
 
 &nbsp;
 
 ```solidity
 
     /**
-     * @dev Émis lorsque les jetons `value` sont déplacés d'un compte (`from`) vers
+     * @dev Émis lorsque des jetons d'une `valeur` (`value`) sont déplacés d'un compte (`from`) à
      * un autre (`to`).
      *
      * Notez que `value` peut être zéro.
@@ -175,8 +210,8 @@ Enfin, `transferFrom` est utilisé par le client pour dépenser réellement l'al
     event Transfer(address indexed from, address indexed to, uint256 value);
 
     /**
-     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
-     * a call to {approve}. `value` est la nouvelle allocation.
+     * @dev Émis lorsque l'allocation d'un `dépensier` (`spender`) pour un `propriétaire` (`owner`) est définie par
+     * un appel à {approve}. `value` est la nouvelle allocation.
      */
     event Approval(address indexed owner, address indexed spender, uint256 value);
 }
@@ -186,7 +221,10 @@ Ces événements sont émis lorsque l'état du contrat ERC-20 change.
 
 ## Le contrat réel {#the-actual-contract}
 
-Ceci est le contrat réel qui implémente la norme ERC-20, [tirée d'ici](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol). Il n'est pas destiné à être utilisé tel quel, mais vous pouvez en [hériter](https://www.tutorialspoint.com/solidity/solidity_inheritance.htm) pour l'étendre à quelque chose d'utilisable.
+Ceci est le contrat réel qui implémente la norme ERC-20,
+[tiré d'ici](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol).
+Il n'est pas destiné à être utilisé tel quel, mais vous pouvez
+[en hériter](https://www.tutorialspoint.com/solidity/solidity_inheritance.htm) pour l'étendre à quelque chose d'utilisable.
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -195,9 +233,9 @@ pragma solidity >=0.6.0 <0.8.0;
 
 &nbsp;
 
-### Importer les relevés {#import-statements}
+### Instructions d'importation {#import-statements}
 
-En complément des définitions d'interface ci-dessus, la définition de contrat importe deux autres fichiers :
+En plus des définitions d'interface ci-dessus, la définition du contrat importe deux autres fichiers :
 
 ```solidity
 
@@ -206,37 +244,42 @@ import "./IERC20.sol";
 import "../../math/SafeMath.sol";
 ```
 
-- `GSN/Context.sol` est l'ensemble des définitions requises pour utiliser [OpenGSN](https://www.opengsn.org/), un système qui permet aux utilisateurs sans ether d'utiliser la blockchain. Notez que c'est une ancienne version, si vous souhaitez une intégration avec OpenGSN [utilisez ce tutoriel](https://docs.opengsn.org/javascript-client/tutorial.html).
-- [La bibliothèque SafeMath](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/), qui est utilisée pour faire des ajouts et retraits sans dépassements. Ceci est nécessaire car sinon une personne pourrait avoir un jeton, dépenser deux jetons, puis avoir 2^256-1 jetons.
+- `GSN/Context.sol` contient les définitions requises pour utiliser [OpenGSN](https://www.opengsn.org/), un système qui permet aux utilisateurs sans ether
+  d'utiliser la blockchain. Notez qu'il s'agit d'une ancienne version. Si vous voulez vous intégrer à OpenGSN,
+  [utilisez ce tutoriel](https://docs.opengsn.org/javascript-client/tutorial.html).
+- [La bibliothèque SafeMath](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/), qui empêche
+  les dépassements/sous-dépassements arithmétiques pour les versions de Solidity **&lt;0.8.0**. Dans Solidity ≥0.8.0, les opérations arithmétiques
+  s'annulent automatiquement en cas de dépassement/sous-dépassement, ce qui rend SafeMath inutile. Ce contrat utilise SafeMath pour la compatibilité descendante avec
+  les anciennes versions du compilateur.
 
 &nbsp;
 
-Ce commentaire explique la finalité du contrat.
+Ce commentaire explique l'objectif du contrat.
 
 ```solidity
 /**
- * Implémentation @dev de l'interface {IERC20}.
+ * @dev Implémentation de l'interface {IERC20}.
  *
- * Cette implémentation ne sait pas comment les jetons sont créés. Cela signifie
- * qu'un mécanisme de génération doit être ajouté dans un contrat dérivé en utilisant {_mint}.
+ * Cette implémentation est agnostique quant à la manière dont les jetons sont créés. Cela signifie
+ * qu'un mécanisme d'approvisionnement doit être ajouté dans un contrat dérivé utilisant {_mint}.
  * Pour un mécanisme générique, voir {ERC20PresetMinterPauser}.
  *
- * CONSEIL : Pour une description détaillée, consultez notre guide
+ * CONSEIL : pour un exposé détaillé, consultez notre guide
  * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[Comment
  * implémenter des mécanismes d'approvisionnement].
  *
- * Nous avons suivi les directives générales d'OpenZeppelin : les fonctions s'inversent au lieu de
- * faire état d'un `false` en cas d'échec. Ce comportement est néanmoins classique
+ * Nous avons suivi les directives générales d'OpenZeppelin : les fonctions s'annulent au lieu de
+ * renvoyer « `false` » en cas d'échec. Ce comportement est néanmoins conventionnel
  * et n'entre pas en conflit avec les attentes des applications ERC20.
  *
- * De plus, un événement {Approval} est émis en cas d'appels vers {transferFrom}.
- * Cela permet aux applications de reconstituer l'allocation pour tous les comptes rien
- * qu'en écoutant lesdits événements. Les autres implémentations de l'EIP peuvent ne pas émettre
- * ces événements car la spécification ne le demande pas.
+ * De plus, un événement {Approval} est émis lors des appels à {transferFrom}.
+ * Cela permet aux applications de reconstruire l'allocation pour tous les comptes simplement
+ * en écoutant lesdits événements. D'autres implémentations de l'EIP peuvent ne pas émettre
+ * ces événements, car ce n'est pas requis par la spécification.
  *
- * Enfin, les fonctions non normalisées {decreaseAllowance} et {increaseAllowance}
- * ont été ajoutées pour atténuer les problèmes bien connus autour de la définition des
- * allocations. Voir {IERC20-approve}.
+ * Enfin, les fonctions non standard {decreaseAllowance} et {increaseAllowance}
+ * ont été ajoutées pour atténuer les problèmes bien connus concernant la définition
+ * des allocations. Voir {IERC20-approve}.
  */
 
 ```
@@ -247,7 +290,7 @@ Ce commentaire explique la finalité du contrat.
 contract ERC20 is Context, IERC20 {
 ```
 
-Cette ligne spécifie l'héritage : dans ce cas du `IERC20` ci-dessus et `Context`, pour OpenGSN.
+Cette ligne spécifie l'héritage, dans ce cas de `IERC20` ci-dessus et de `Context`, pour OpenGSN.
 
 &nbsp;
 
@@ -257,19 +300,27 @@ Cette ligne spécifie l'héritage : dans ce cas du `IERC20` ci-dessus et `Contex
 
 ```
 
-Cette ligne associe la bibliothèque `SafeMath` au type `uint256`. Vous pouvez trouver cette bibliothèque [ici](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol).
+Cette ligne attache la bibliothèque `SafeMath` au type `uint256`. Vous pouvez trouver cette bibliothèque
+[ici](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol).
 
 ### Définitions des variables {#variable-definitions}
 
-Ces définitions précisent les variables d'état du contrat. Il y a des variables déclarées `private`, mais cela signifie uniquement que d'autres contrats sur la blockchain ne peuvent pas les lire. _Il n'ey a rien de secret sur la blockchain_, le logiciel sur chaque nœud dispose de l'état de chaque contrat pour chaque bloc. Par convention, les variables d'état sont nommées `_<something>`.
+Ces définitions spécifient les variables d'état du contrat. Ces variables sont déclarées comme `private`, mais
+cela signifie seulement que les autres contrats sur la blockchain ne peuvent pas les lire. _Il n'y a pas de
+secrets sur la blockchain_, le logiciel sur chaque nœud a l'état de chaque contrat
+à chaque bloc. Par convention, les variables d'état sont nommées `_<quelquechose>`.
 
-Les deux premières variables sont des [mappings](https://www.tutorialspoint.com/solidity/solidity_mappings.htm), ce qui signifie qu'elles se comportent à peu près comme un [tableau associatif](https://wikipedia.org/wiki/Associative_array), si ce n'est que les clés sont des valeurs numériques. Il n'y a de possibilité de stockage que pour les entrées qui ont des valeurs différentes de la valeur par défaut (zéro).
+Les deux premières variables sont des [mappings](https://www.tutorialspoint.com/solidity/solidity_mappings.htm),
+ce qui signifie qu'elles se comportent à peu près de la même manière que des [tableaux associatifs](https://wikipedia.org/wiki/Associative_array),
+sauf que les clés sont des valeurs numériques. Le stockage n'est alloué que pour les entrées qui ont des valeurs différentes
+de la valeur par défaut (zéro).
 
 ```solidity
     mapping (address => uint256) private _balances;
 ```
 
-Le premier mapping, `_balances`, correspond aux adresses et aux soldes respectifs de ce jeton. Pour accéder au solde, utilisez cette syntaxe : `_balances[<address>]`.
+Le premier mapping, `_balances`, contient les adresses et leurs soldes respectifs de ce jeton. Pour accéder
+au solde, utilisez cette syntaxe : `_balances[<adresse>]`.
 
 &nbsp;
 
@@ -277,7 +328,9 @@ Le premier mapping, `_balances`, correspond aux adresses et aux soldes respectif
     mapping (address => mapping (address => uint256)) private _allowances;
 ```
 
-Cette variable, `_allowances`, stocke les allocations expliquées plus haut. Le premier index est le propriétaire des jetons, et le second est le contrat avec l'allocation. Pour accéder au montant que l'adresse A peut dépenser à partir du compte de l'adresse B, utilisez `_allowances[B][A]`.
+Cette variable, `_allowances`, stocke les allocations expliquées précédemment. Le premier index est le propriétaire
+des jetons, et le second est le contrat avec l'allocation. Pour accéder au montant que l'adresse A peut
+dépenser à partir du compte de l'adresse B, utilisez `_allowances[B][A]`.
 
 &nbsp;
 
@@ -285,7 +338,7 @@ Cette variable, `_allowances`, stocke les allocations expliquées plus haut. Le
     uint256 private _totalSupply;
 ```
 
-Comme le nom le suggère, cette variable garde une trace de la quantité totale de jetons.
+Comme son nom l'indique, cette variable assure le suivi de l'offre totale de jetons.
 
 &nbsp;
 
@@ -295,34 +348,44 @@ Comme le nom le suggère, cette variable garde une trace de la quantité totale
     uint8 private _decimals;
 ```
 
-Ces trois variables sont utilisées pour améliorer la lisibilité. Les noms des deux premières parlent d'eux-mêmes, mais pas `_decimals`.
+Ces trois variables sont utilisées pour améliorer la lisibilité. Les deux premières sont explicites, mais `_decimals`
+ne l'est pas.
 
-D'une part, Ethereum n'a pas de variables à virgule flottante ou fractionnées. D'autre part, les gens apprécient de pouvoir diviser les jetons. Si les gens se sont orientés vers l'or comme monnaie c'est parce qu'il était difficile de faire de la monnaie quand quelqu'un voulait acheter la valeur d'un canard en vache.
+D'une part, Ethereum ne dispose pas de variables à virgule flottante ou fractionnaires. D'autre part,
+les humains aiment pouvoir diviser les jetons. Une des raisons pour lesquelles les gens ont opté pour l'or comme monnaie était qu'il
+était difficile de rendre la monnaie lorsque quelqu'un voulait acheter l'équivalent d'un canard en vache.
 
-La solution est de garder la trace des entiers, mais de compter à la place du jeton réel un jeton fractionné qui est presque sans valeur. Dans le cas de l'éther, la fraction de jeton est appelée wei, et 10^18 wei est égal à un ETH. A l’écriture, 10.000.000.000.000 wei représentent approximativement un centime de dollars américain ou un centime d’euro.
+La solution consiste à garder la trace des nombres entiers, mais de compter, au lieu du jeton réel, un jeton fractionnaire qui n'a
+pratiquement aucune valeur. Dans le cas de l'ether, le jeton fractionnaire est appelé wei, et 10^18 wei est égal à un
+ETH. Au moment de la rédaction de cet article, 10 000 000 000 000 de wei valent environ un centime de dollar américain ou d'euro.
 
-Les applications ont besoin de savoir comment afficher le solde de jetons. Si un utilisateur dispose de 3.141.000.000.000.000.000 wei, est-ce que cela correspond à 3,14 ETH ? 31,41 ETH ? 3,141 ETH ? Dans le cas de l'éther, il est défini comme 10^18 wei pour un ETH, mais pour votre jeton, vous pouvez sélectionner une valeur différente. Si diviser le jeton n'a pas de sens, vous pouvez définir une valeur `_decimals` de zéro. Si vous souhaitez definir le même standard que pour ETH, utilisez la valeur **18**.
+Les applications doivent savoir comment afficher le solde de jetons. Si un utilisateur a 3 141 000 000 000 000 000 wei, est-ce que cela fait
+3,14 ETH ? 31,41 ETH ? 3 141 ETH ? Dans le cas de l'ether, il est défini que 10^18 wei valent 1 ETH, mais pour votre
+jeton, vous pouvez sélectionner une valeur différente. Si la division du jeton n'a pas de sens, vous pouvez utiliser une
+valeur `_decimals` de zéro. Si vous voulez utiliser la même norme que l'ETH, utilisez la valeur **18**.
 
-### Le Constructeur {#the-constructor}
+### Le constructeur {#the-constructor}
 
 ```solidity
     /**
-     * @dev Définit les valeurs de {name} et {symbol}, initialise {decimals} avec
+     * @dev Définit les valeurs pour {name} et {symbol}, initialise {decimals} avec
      * une valeur par défaut de 18.
      *
      * Pour sélectionner une valeur différente pour {decimals}, utilisez {_setupDecimals}.
      *
      * Ces trois valeurs sont immuables : elles ne peuvent être définies qu'une seule fois pendant
-     * la phase de construction.
+     * la construction.
      */
     constructor (string memory name_, string memory symbol_) public {
+        // Dans Solidity ≥0.7.0, 'public' est implicite et peut être omis.
+
         _name = name_;
         _symbol = symbol_;
         _decimals = 18;
     }
 ```
 
-Le constructeur est appelé lorsque le contrat est créé pour la première fois. Par convention, les paramètres de fonction sont nommés `<something>_`.
+Le constructeur est appelé lors de la création initiale du contrat. Par convention, les paramètres de fonction sont nommés `<quelquechose>_`.
 
 ### Fonctions de l'interface utilisateur {#user-interface-functions}
 
@@ -335,24 +398,24 @@ Le constructeur est appelé lorsque le contrat est créé pour la première fois
     }
 
     /**
-     * @dev Returns the symbol of the token, usually a shorter version of the
-     * name.
+     * @dev Renvoie le symbole du jeton, généralement une version plus courte du
+     * nom.
      */
     function symbol() public view returns (string memory) {
         return _symbol;
     }
 
     /**
-     * @dev Returns the number of decimals used to get its user representation.
-     * Par exemple, si `decimals` est égal à `2`, un solde de jetons `505` devrait
-     * être affiché comme suit pour un utilisateur : `5,05` (`505 / 10 ** 2`).
+     * @dev Renvoie le nombre de décimales utilisées pour obtenir sa représentation utilisateur.
+     * Par exemple, si `decimals` est égal à `2`, un solde de `505` jetons devrait
+     * être affiché à un utilisateur comme `5,05` (`505 / 10 ** 2`).
      *
-     * Les jetons optent généralement pour une valeur de 18, qui correspond à la relation entre
-     * éther et wei. C'est la valeur {ERC20} utilisée, sauf si {_setupDecimals} est
-     * appelé.
+     * Les jetons optent généralement pour une valeur de 18, imitant la relation entre
+     * l'ether et le wei. C'est la valeur que {ERC20} utilise, à moins que {_setupDecimals} ne soit
+     * appelée.
      *
-     * REMARQUE : Cette information n'est utilisée qu'à des fins _affichage_ : 
-     * elle n'affecte en aucune façon l'arithmétique du contrat, y compris
+     * NOTE : Cette information n'est utilisée qu'à des fins d'_affichage_ : elle n'affecte
+     * en aucun cas l'arithmétique du contrat, y compris
      * {IERC20-balanceOf} et {IERC20-transfer}.
      */
     function decimals() public view returns (uint8) {
@@ -360,61 +423,67 @@ Le constructeur est appelé lorsque le contrat est créé pour la première fois
     }
 ```
 
-Ces fonctions, `name`, `symbol`, et `decimal` aident les interfaces utilisateur à connaître votre contrat afin qu'elles puissent l'afficher correctement.
+Ces fonctions, `name`, `symbol` et `decimals` aident les interfaces utilisateur à connaître votre contrat afin qu'elles puissent l'afficher correctement.
 
-Le type de retour est `string memory`, ce qui signifie retourner une chaîne de caractères stockée en mémoire. Les variables telles que les chaînes peuvent être stockées à trois endroits :
+Le type de retour est `string memory`, ce qui signifie renvoyer une chaîne de caractères stockée en mémoire. Les variables, telles que les
+chaînes de caractères, peuvent être stockées à trois endroits :
 
-|                 | Durée de vie         | Accès au contrat | Coût énergétique                                                                           |
-| --------------- | -------------------- | ---------------- | ------------------------------------------------------------------------------------------ |
-| Mémoire         | Appel de la fonction | Lecture/Écriture | Dix ou des centaines (plus pour des endroits plus élevés)                                  |
-| Données d'appel | Appel de la fonction | Lecture seule    | Ne peut pas être utilisé comme type de retour, uniquement un type de paramètre de fonction |
-| Stockage        | Jusqu'au changement  | Lecture/Écriture | Haut (800 pour la lecture, 20k pour l'écriture)                                            |
+|                 | Durée de vie         | Accès au contrat | Coût du gaz                                                                                  |
+| --------------- | -------------------- | ---------------- | -------------------------------------------------------------------------------------------- |
+| Memory          | Appel de fonction    | Lecture/écriture | Dizaines ou centaines (plus élevé pour les emplacements plus élevés)      |
+| Données d'appel | Appel de fonction    | Lecture seule    | Ne peut pas être utilisé comme type de retour, seulement comme type de paramètre de fonction |
+| Stockage        | Jusqu'à modification | Lecture/écriture | Élevé (800 pour la lecture, 20k pour l'écriture)                          |
 
 Dans ce cas, `memory` est le meilleur choix.
 
-### Lire les informations du jeton {#read-token-information}
+### Lire les informations sur le jeton {#read-token-information}
 
-Ce sont des fonctions qui fournissent des informations sur le jeton, soit l'offre totale, soit le solde d'un compte.
+Ce sont des fonctions qui fournissent des informations sur le jeton, soit l'offre totale, soit le
+solde d'un compte.
 
 ```solidity
     /**
-     * @dev See {IERC20-totalSupply}.
+     * @dev Voir {IERC20-totalSupply}.
      */
     function totalSupply() public view override returns (uint256) {
         return _totalSupply;
     }
 ```
 
-La fonction `totalSupply` fournit la quantité totale de jetons.
+La fonction `totalSupply` renvoie l'offre totale de jetons.
 
 &nbsp;
 
 ```solidity
     /**
-     * @dev See {IERC20-balanceOf}.
+     * @dev Voir {IERC20-balanceOf}.
      */
     function balanceOf(address account) public view override returns (uint256) {
         return _balances[account];
     }
 ```
 
-Lit le solde d'un compte. Notez que n'importe qui est autorisé à obtenir le solde du compte de n'importe qui d'autre. Il est inutile d'essayer de masquer cette information car de toute façon, elle est disponible sur tous les nœuds. _Il n'existe aucun secret sur la blockchain._
+Lire le solde d'un compte. Notez que n'importe qui est autorisé à obtenir le solde du compte
+de n'importe qui d'autre. Il est inutile d'essayer de cacher cette information, car elle est de toute façon disponible sur chaque
+nœud. _Il n'y a pas de secrets sur la blockchain._
 
 ### Transférer des jetons {#transfer-tokens}
 
 ```solidity
     /**
-     * @dev See {IERC20-transfer}.
+     * @dev Voir {IERC20-transfer}.
      *
-     * Pré-requis:
+     * Exigences :
      *
-     * - le `bénéficiaire ' ne peut pas être l'adresse zéro.
-     * - l'appelant doit avoir un solde au moins égal au `montant`.
+     * - `recipient` ne peut pas être l'adresse zéro.
+     * - l'appelant doit avoir un solde d'au moins `amount`.
      */
     function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
 ```
 
-La fonction `transfer` est appelée pour transférer des jetons depuis le compte de l'expéditeur vers un autre compte. Remarquez que même si elle fournit une valeur booléenne, cette valeur est toujours **true**. Si le transfert échoue, le contrat reprend l'appel.
+La fonction `transfer` est appelée pour transférer des jetons du compte de l'expéditeur vers un autre. Notez
+que même si elle renvoie une valeur booléenne, cette valeur est toujours **true**. Si le transfert
+échoue, le contrat annule l'appel.
 
 &nbsp;
 
@@ -424,44 +493,51 @@ La fonction `transfer` est appelée pour transférer des jetons depuis le compte
     }
 ```
 
-La fonction `_transfer` fait le travail réel. C'est une fonction privée qui ne peut être appelée que par d'autres fonctions de contrat. Par convention les fonctions privées sont nommées `_<something>`, comme les variables d'état.
+La fonction `_transfer` fait le travail réel. C'est une fonction privée qui ne peut être appelée que par
+d'autres fonctions du contrat. Par convention, les fonctions privées sont nommées `_<quelquechose>`, comme les variables
+d'état.
 
-Habituellement avec Solidity nous utilisons `msg.sender` pour l'expéditeur du message. Cependant, cela casse [OpenGSN](http://opengsn.org/). Si nous voulons autoriser les transactions avec notre jeton, nous devons utiliser `_msgSender()`. Elle retournera `msg.sender` pour les transactions normales, en revanche pour les transactions sans ether elle indiquera le signataire original et non le contrat qui a relayé le message.
+Normalement, dans Solidity, nous utilisons `msg.sender` pour l'expéditeur du message. Cependant, cela casse
+[OpenGSN](http://opengsn.org/). Si nous voulons autoriser les transactions sans ether avec notre jeton, nous
+devons utiliser `_msgSender()`. Elle renvoie `msg.sender` pour les transactions normales, mais pour celles sans ether,
+elle renvoie le signataire original et non le contrat qui a relayé le message.
 
-### Fonctions de provision {#allowance-functions}
+### Fonctions d'allocation {#allowance-functions}
 
-Ce sont les fonctions qui implémentent la fonctionnalité de provision : `allowance`, `approve`, `transferFrom`, et `_approve`. De plus, l'implémentation d'OpenZeppelin va au-delà du standard de base pour inclure certaines fonctionnalités qui améliorent la sécurité : `increaseAllowance`, et `decreaseAllowance`.
+Ce sont les fonctions qui implémentent la fonctionnalité d'allocation : `allowance`, `approve`, `transferFrom`,
+et `_approve`. De plus, l'implémentation d'OpenZeppelin va au-delà de la norme de base pour inclure certaines fonctionnalités qui améliorent la
+sécurité : `increaseAllowance` et `decreaseAllowance`.
 
 #### La fonction d'allocation {#allowance}
 
 ```solidity
     /**
-     * @dev See {IERC20-allowance}.
+     * @dev Voir {IERC20-allowance}.
      */
     function allowance(address owner, address spender) public view virtual override returns (uint256) {
         return _allowances[owner][spender];
     }
 ```
 
-La fonction `allowance` permet à quiconque de vérifier n'importe quelle allocation.
+La fonction `allowance` permet à tout le monde de vérifier n'importe quelle allocation.
 
 #### La fonction d'approbation {#approve}
 
 ```solidity
     /**
-     * @dev See {IERC20-approve}.
+     * @dev Voir {IERC20-approve}.
+     *
+     * Exigences :
      *
-     * Exigences :
-Pré-requis     *
      * - `spender` ne peut pas être l'adresse zéro.
      */
     function approve(address spender, uint256 amount) public virtual override returns (bool) {
 ```
 
-Cette fonction est appelée pour créer une provision. Elle est similaire à la fonction `transfer` ci-dessus :
+Cette fonction est appelée pour créer une allocation. Elle est similaire à la fonction `transfer` ci-dessus :
 
 - La fonction appelle simplement une fonction interne (dans ce cas, `_approve`) qui fait le travail réel.
-- La fonction retourne soit `true` (si réussi) ou retour (si ce n'est pas le cas).
+- La fonction renvoie soit `true` (en cas de succès), soit annule (sinon).
 
 &nbsp;
 
@@ -471,24 +547,26 @@ Cette fonction est appelée pour créer une provision. Elle est similaire à la
     }
 ```
 
-Nous utilisons des fonctions internes pour minimiser le nombre d'endroits où des changements d'état se produisent. _Toute_ fonction qui change l'état présente un risque potentiel de sécurité qui doit être audité pour déceler d'éventuelles failles de sécurité. De cette manière, nous avons moins de risques de nous tromper.
+Nous utilisons des fonctions internes pour minimiser le nombre d'endroits où des changements d'état se produisent. Toute fonction qui modifie l'état
+est un risque de sécurité potentiel qui doit être audité pour la sécurité. De cette façon, nous avons moins de chances de nous tromper.
 
-#### Fonction transferFrom {#transferFrom}
+#### La fonction transferFrom {#transferFrom}
 
-C'est la fonction que le client appelle pour dépenser une provision. Cela nécessite deux opérations : transférer le montant dépensé et réduire d'autant le montant de la provision.
+C'est la fonction qu'un dépensier appelle pour dépenser une allocation. Cela nécessite deux opérations : transférer le montant
+dépensé et réduire l'allocation de ce montant.
 
 ```solidity
     /**
-     * @dev See {IERC20-transferFrom}.
+     * @dev Voir {IERC20-transferFrom}.
      *
-     * Émet un événement {Approval} indiquant le montant de la provision mis à jour. This is not
-     * required by the EIP. Voir la note au début de {ERC20}.
+     * Émet un événement {Approval} indiquant l'allocation mise à jour. Ceci n'est pas
+     * requis par l'EIP. Voir la note au début de {ERC20}.
      *
-     * Pré-requis  :
-    *
-     * - `spender` et `recipient` ne peuvent pas correspondre à l'adresse zéro.
+     * Exigences :
+     *
+     * - `sender` et `recipient` ne peuvent pas être l'adresse zéro.
      * - `sender` doit avoir un solde d'au moins `amount`.
-     * - l'appelant doit avoir une allocation pour les jetons du ``sender`` d'au moins
+     * - l'appelant doit avoir une allocation pour les jetons de `sender` d'au moins
      * `amount`.
      */
     function transferFrom(address sender, address recipient, uint256 amount) public virtual
@@ -498,7 +576,9 @@ C'est la fonction que le client appelle pour dépenser une provision. Cela néce
 
 &nbsp;
 
-L'appel à la fonction `a.sub(b, "message")` fait deux choses. Tout d'abord, elle calcule `a-b`, qui est la nouvelle provision. Deuxièmement, elle vérifie que ce résultat n'est pas négatif. S'il est négatif, l'appel revient avec le message fourni. Veuillez noter que lorsqu'un appel annule tout traitement effectué précédemment pendant cet appel il est ignoré pour que nous n'ayons pas besoin d'annuler le `_transfer`.
+L'appel de fonction `a.sub(b, "message")` fait deux choses. Premièrement, il calcule `a-b`, qui est la nouvelle allocation.
+Deuxièmement, il vérifie que ce résultat n'est pas négatif. S'il est négatif, l'appel s'annule avec le message fourni. Notez que lorsqu'un appel s'annule, tout traitement effectué précédemment pendant cet appel est ignoré, nous n'avons donc pas besoin d'annuler
+le `_transfer`.
 
 ```solidity
         _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount,
@@ -507,48 +587,60 @@ L'appel à la fonction `a.sub(b, "message")` fait deux choses. Tout d'abord, ell
     }
 ```
 
-#### Ajouts de sécurité OpenZeppelin {#openzeppelin-safety-additions}
+#### Ajouts de sécurité d'OpenZeppelin {#openzeppelin-safety-additions}
 
-Il est dangereux d'attribuer à une provision non nulle une autre valeur non nulle parce que vous ne contrôlez que l'ordre de vos propres transactions, pas celles de quelqu'un d'autre. Imaginez que vous ayez deux utilisateurs, Alice qui est naïve et Bill qui est malhonnête. Alice souhaite solliciter un service de la part de Bill qui, selon elle, coûte cinq jetons - donc elle donne à Bill une provision de cinq jetons.
+Il est dangereux de définir une allocation non nulle sur une autre valeur non nulle,
+car vous ne contrôlez que l'ordre de vos propres transactions, pas celles de quelqu'un d'autre. Imaginez que vous
+ayez deux utilisateurs, Alice qui est naïve et Bill qui est malhonnête. Alice veut un service de la part de
+Bill, qui, selon elle, coûte cinq jetons. Elle donne donc à Bill une allocation de cinq jetons.
 
-Puis, quelque chose change et le prix de Bill monte à dix jetons. Alice, qui souhaite toujours le service, envoie une transaction qui fixe la provision de Bill à dix. Au moment où Bill voit cette nouvelle transaction dans le pool de transactions, il envoie une transaction qui dépense les cinq jetons d'Alice et a un coût énergétique bien plus élevé, donc elle sera épuisée plus rapidement. De cette façon, Bill peut dépenser les cinq premiers jetons puis, une fois que la nouvelle provision d'Alice est épuisée, en dépenser dix de plus pour un prix total de quinze jetons, plus qu'Alice est censée avoir autorisé. Cette technique est appelée [front-running](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/#front-running)
+Puis, quelque chose change et le prix de Bill passe à dix jetons. Alice, qui veut toujours le service,
+envoie une transaction qui définit l'allocation de Bill à dix. Dès que Bill voit cette nouvelle transaction
+dans le pool de transactions, il envoie une transaction qui dépense les cinq jetons d'Alice et a un prix de
+gaz beaucoup plus élevé pour qu'elle soit minée plus rapidement. De cette façon, Bill peut d'abord dépenser cinq jetons, puis,
+une fois que la nouvelle allocation d'Alice est minée, en dépenser dix de plus pour un prix total de quinze jetons, plus que ce qu'Alice
+voulait autoriser. Cette technique est appelée le
+[front-running](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/#front-running)
 
-| Transaction d'Alice | Nonce d'Alice | Transaction de Bill           | Nonce de Bill | Provision de Bill | Total facturé par Bill à Alice |
-| ------------------- | ------------- | ----------------------------- | ------------- | ----------------- | ------------------------------ |
-| approve(Bill, 5)    | 10            |                               |               | 5                 | 0                              |
-|                     |               | transferFrom(Alice, Bill, 5)  | 10 123        | 0                 | 5                              |
-| approve(Bill, 10)   | 11            |                               |               | 10                | 5                              |
-|                     |               | transferFrom(Alice, Bill, 10) | 10,124        | 0                 | 15                             |
+| Transaction d'Alice                  | Nonce d'Alice | Transaction de Bill                              | Nonce de Bill | Allocation de Bill | Revenu total de Bill provenant d'Alice |
+| ------------------------------------ | ------------- | ------------------------------------------------ | ------------- | ------------------ | -------------------------------------- |
+| approve(Bill, 5)  | 10            |                                                  |               | 5                  | 0                                      |
+|                                      |               | transferFrom(Alice, Bill, 5)  | 10,123        | 0                  | 5                                      |
+| approve(Bill, 10) | 11            |                                                  |               | 10                 | 5                                      |
+|                                      |               | transferFrom(Alice, Bill, 10) | 10,124        | 0                  | 15                                     |
 
-Pour éviter ce problème, ces deux fonctions (`increaseAllowance` et `decreaseAllowance`) vous permettent de modifier la provision d'un montant spécifique. Ainsi, si Bill a déjà dépensé cinq jetons, il ne sera autorisé à dépenser que cinq jetons de plus. En fonction du timing, il y a deux façons de procéder, les deux aboutissant au fait que Bill n'obtient que dix jetons :
+Pour éviter ce problème, ces deux fonctions (`increaseAllowance` et `decreaseAllowance`) vous permettent
+de modifier l'allocation d'un montant spécifique. Donc, si Bill a déjà dépensé cinq jetons, il ne
+pourra en dépenser que cinq de plus. Selon le moment, il y a deux façons dont cela peut fonctionner, les deux se terminant
+avec Bill n'obtenant que dix jetons :
 
 A :
 
-| Transaction d'Alice        | Nonce d'Alice | Transaction de Bill          | Nonce de Bill | Provision de Bill | Total facturé par Bill à Alice |
-| -------------------------- | -------------:| ---------------------------- | -------------:| -----------------:| ------------------------------ |
-| approve(Bill, 5)           |            10 |                              |               |                 5 | 0                              |
-|                            |               | transferFrom(Alice, Bill, 5) |        10,123 |                 0 | 5                              |
-| increaseAllowance(Bill, 5) |            11 |                              |               |           0+5 = 5 | 5                              |
-|                            |               | transferFrom(Alice, Bill, 5) |        10 124 |                 0 | 10                             |
+| Transaction d'Alice                           | Nonce d'Alice | Transaction de Bill                             | Nonce de Bill | Allocation de Bill | Revenu total de Bill provenant d'Alice |
+| --------------------------------------------- | ------------: | ----------------------------------------------- | ------------: | -----------------: | -------------------------------------- |
+| approve(Bill, 5)           |            10 |                                                 |               |                  5 | 0                                      |
+|                                               |               | transferFrom(Alice, Bill, 5) |        10,123 |                  0 | 5                                      |
+| increaseAllowance(Bill, 5) |            11 |                                                 |               |            0+5 = 5 | 5                                      |
+|                                               |               | transferFrom(Alice, Bill, 5) |        10,124 |                  0 | 10                                     |
 
 B :
 
-| Transaction d'Alice        | Nonce d'Alice | Transaction de Bill           | Nonce de Bill | Provision de Bill | Total facturé par Bill à Alice |
-| -------------------------- | -------------:| ----------------------------- | -------------:| -----------------:| ------------------------------:|
-| approve(Bill, 5)           |            10 |                               |               |                 5 |                              0 |
-| increaseAllowance(Bill, 5) |            11 |                               |               |          5+5 = 10 |                              0 |
-|                            |               | transferFrom(Alice, Bill, 10) |        10 124 |                 0 |                             10 |
+| Transaction d'Alice                           | Nonce d'Alice | Transaction de Bill                              | Nonce de Bill | Allocation de Bill | Revenu total de Bill provenant d'Alice |
+| --------------------------------------------- | ------------: | ------------------------------------------------ | ------------: | -----------------: | -------------------------------------: |
+| approve(Bill, 5)           |            10 |                                                  |               |                  5 |                                      0 |
+| increaseAllowance(Bill, 5) |            11 |                                                  |               |           5+5 = 10 |                                      0 |
+|                                               |               | transferFrom(Alice, Bill, 10) |        10,124 |                  0 |                                     10 |
 
 ```solidity
     /**
-     * @dev augmente atomiquement l'allocation accordée à `spender` par l'appelant.
+     * @dev Augmente atomiquement l'allocation accordée à `spender` par l'appelant.
      *
-     * C'est une alternative à {approve} qui peut être utilisée pour atténuer les
+     * Il s'agit d'une alternative à {approve} qui peut être utilisée comme atténuation des
      * problèmes décrits dans {IERC20-approve}.
      *
-     * Émet un événement {Approval} indiquant l'allocation telle que mise à jour.
+     * Émet un événement {Approval} indiquant l'allocation mise à jour.
      *
-     * Pré-requis :
+     * Exigences :
      *
      * - `spender` ne peut pas être l'adresse zéro.
      */
@@ -558,22 +650,23 @@ B :
     }
 ```
 
-La fonction `a.add(b)` est un ajout sûr. Dans le cas peu probable où `a`+`b`>=`2^256` il n'intègre pas la manière dont l'ajout normal doit se réaliser.
+La fonction `a.add(b)` est une addition sûre. Dans le cas peu probable où `a`+`b`>=`2^256`, elle ne boucle pas
+comme le fait une addition normale.
 
 ```solidity
 
     /**
-     * @dev diminue atomiquement l'allocation accordée par l'appelant à `spender`.
+     * @dev Diminue atomiquement l'allocation accordée à `spender` par l'appelant.
      *
-     * C'est une alternative à {approve} qui peut être utilisée pour atténuer les
+     * Il s'agit d'une alternative à {approve} qui peut être utilisée comme atténuation des
      * problèmes décrits dans {IERC20-approve}.
      *
-     * Émet un événement {Approval} indiquant le montant actualisé de l'allocation.
+     * Émet un événement {Approval} indiquant l'allocation mise à jour.
      *
-     * Pré-requis :
+     * Exigences :
      *
      * - `spender` ne peut pas être l'adresse zéro.
-     * - `spender` doit avoir une provision pour l'appelant d'au moins
+     * - `spender` doit avoir une allocation pour l'appelant d'au moins
      * `subtractedValue`.
      */
     function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
@@ -583,22 +676,22 @@ La fonction `a.add(b)` est un ajout sûr. Dans le cas peu probable où `a`+`b`>=
     }
 ```
 
-### Fonctions qui modifient les informations du jeton {#functions-that-modify-token-information}
+### Fonctions qui modifient les informations sur les jetons {#functions-that-modify-token-information}
 
-Voici les quatre fonctions qui font le travail réel : `_transfer`, `_mint`, `_burn`, et `_approve`.
+Ce sont les quatre fonctions qui font le travail réel : `_transfer`, `_mint`, `_burn` et `_approve`.
 
-#### La fonction \_transfer {#_transfer}
+#### La fonction _transfer {#_transfer}
 
 ```solidity
     /**
-     * @dev Déplace les jetons `amount` de `sender` à `recipient`.
+     * @dev Déplace un `montant` (`amount`) de jetons de `sender` à `recipient`.
      *
-     * Cette fonction interne équivaut à {transfer},  et peut être utilisée pour
-     * par ex. définir des frais de jetons automatiques, des mécanismes de réduction, etc.
+     * Cette fonction interne est équivalente à {transfer}, et peut être utilisée pour
+     * par exemple, implémenter des frais de jeton automatiques, des mécanismes de délestage, etc.
      *
      * Émet un événement {Transfer}.
      *
-     * Pré-requis :
+     * Exigences :
      *
      * - `sender` ne peut pas être l'adresse zéro.
      * - `recipient` ne peut pas être l'adresse zéro.
@@ -607,7 +700,9 @@ Voici les quatre fonctions qui font le travail réel : `_transfer`, `_mint`, `_b
     function _transfer(address sender, address recipient, uint256 amount) internal virtual {
 ```
 
-Cette fonction, `_transfer`, transfère des jetons d'un compte à un autre. Elle est appelée à la fois par `transfer` (pour les transferts depuis le compte de l'expéditeur) et `transferFrom` (pour utiliser les provisions à être transférée depuis le compte de quelqu'un d'autre).
+Cette fonction, `_transfer`, transfère des jetons d'un compte à un autre. Elle est appelée à la fois par
+`transfer` (pour les transferts depuis le propre compte de l'expéditeur) et `transferFrom` (pour utiliser des allocations
+pour transférer depuis le compte de quelqu'un d'autre).
 
 &nbsp;
 
@@ -616,7 +711,9 @@ Cette fonction, `_transfer`, transfère des jetons d'un compte à un autre. Elle
         require(recipient != address(0), "ERC20: transfer to the zero address");
 ```
 
-Personne ne possède réellement l'adresse zéro dans Ethereum (c'est-à-dire que personne ne connaît une clé privée dont la clé publique correspondante est transformée en une adresse zéro). Lorsque les personnes utilisent cette adresse, il s'agit généralement d'un bogue logiciel - donc nous échouons si l'adresse zéro est utilisée comme expéditeur ou destinataire.
+Personne ne possède réellement l'adresse zéro dans Ethereum (c'est-à-dire que personne ne connaît une clé privée dont la clé publique correspondante
+est transformée en adresse zéro). Lorsque les gens utilisent cette adresse, il s'agit généralement d'un bogue logiciel. Nous échouons donc
+si l'adresse zéro est utilisée comme expéditeur ou destinataire.
 
 &nbsp;
 
@@ -627,12 +724,15 @@ Personne ne possède réellement l'adresse zéro dans Ethereum (c'est-à-dire qu
 
 Il existe deux façons d'utiliser ce contrat :
 
-1. Utilisez-le comme modèle pour votre propre code
-1. [Héritez-en](https://www.bitdegree.org/learn/solidity-inheritance), et remplacez uniquement les fonctions que vous devez modifier
+1. L'utiliser comme modèle pour votre propre code
+2. [En hériter](https://www.bitdegree.org/learn/solidity-inheritance), et ne remplacer que les fonctions que vous devez modifier
 
-La seconde méthode est bien meilleure parce que le code ERC-20 d'OpenZeppelin a déjà été audité et s'avère sécurisé. Lorsque vous utilisez la méthode d'héritage, il est facile de distinguer quelles sont les fonctions que vous avez modifiées et ainsi pour faire confiance à vos contrats, les personnes n'ont besoin que de vérifier ces fonctions spécifiques.
+La deuxième méthode est bien meilleure car le code ERC-20 d'OpenZeppelin a déjà été audité et s'est avéré sécurisé. Lorsque vous utilisez l'héritage,
+les fonctions que vous modifiez sont claires, et pour faire confiance à votre contrat, les gens n'ont besoin que d'auditer ces fonctions spécifiques.
 
-Il est souvent utile d'exécuter une fonction chaque fois que des jetons changent de main. Cependant, `_transfer` est une fonction très importante et il est possible de l'écrire de manière non sécurisée (voir ci-dessous), Il est donc préférable de ne pas le remplacer. La solution est `_beforeTokenTransfer`, une fonction [hook](https://wikipedia.org/wiki/Hooking). Vous pouvez remplacer cette fonction et elle sera appelée pour chaque transfert.
+Il est souvent utile d'exécuter une fonction chaque fois que des jetons changent de mains. Cependant, `_transfer` est une fonction très importante et il est
+possible de l'écrire de manière non sécurisée (voir ci-dessous), il est donc préférable de ne pas la remplacer. La solution est `_beforeTokenTransfer`, une
+[fonction hook](https://wikipedia.org/wiki/Hooking). Vous pouvez remplacer cette fonction, et elle sera appelée à chaque transfert.
 
 &nbsp;
 
@@ -641,7 +741,10 @@ Il est souvent utile d'exécuter une fonction chaque fois que des jetons changen
         _balances[recipient] = _balances[recipient].add(amount);
 ```
 
-Ce sont les lignes qui exécutent réellement le transfert. Notez qu'il n'y a **rien** entre elles et que nous soustrayons le montant transféré du solde de l'expéditeur avant de l'ajouter au destinataire. Ceci est important car s'il y a eu entre temps un appel à un contrat différent, il aurait pu être utilisé pour abuser de ce contrat. De cette façon, le transfert est atomique, rien ne peut se produire en cours de route.
+Ce sont les lignes qui effectuent réellement le transfert. Notez qu'il n'y a **rien** entre elles, et que nous soustrayons
+le montant transféré de l'expéditeur avant de l'ajouter au destinataire. C'est important car s'il y avait un
+appel à un contrat différent entre les deux, il aurait pu être utilisé pour tromper ce contrat. De cette façon, le transfert
+est atomique, rien ne peut se produire au milieu de celui-ci.
 
 &nbsp;
 
@@ -650,23 +753,32 @@ Ce sont les lignes qui exécutent réellement le transfert. Notez qu'il n'y a **
     }
 ```
 
-Enfin, émettre un événement `Transfert`. Les événements ne sont pas accessibles par les contrats intelligents, mais le code exécuté en dehors de la blockchain peut lire les événements et réagir. Par exemple, un portefeuille peut garder une trace du moment où le propriétaire obtient plus de jetons.
+Enfin, émettre un événement `Transfer`. Les événements ne sont pas accessibles aux contrats intelligents, mais le code s'exécutant en dehors de la blockchain
+peut écouter les événements et y réagir. Par exemple, un portefeuille peut suivre le moment où le propriétaire obtient plus de jetons.
 
-#### La fonction \_mint and \_burn {#_mint-and-_burn}
+#### Les fonctions _mint et _burn {#_mint-and-_burn}
 
-Ces deux fonctions (`_mint` et `_burn`) modifient la quantité totale de jetons. Elles sont internes et il n'y a pas de fonction qui les appelle dans ce contrat, ainsi elles ne sont utiles que si vous héritez du contrat et ajoutez votre propre logique pour décider dans quelles conditions générer de nouveaux jetons ou utiliser les jetons existants.
+Ces deux fonctions (`_mint` et `_burn`) modifient l'offre totale de jetons.
+Elles sont internes et aucune fonction ne les appelle dans ce contrat,
+elles ne sont donc utiles que si vous héritez du contrat et ajoutez votre propre
+logique pour décider dans quelles conditions frapper de nouveaux jetons ou brûler des jetons
+existants.
 
-**REMARQUE :** Chaque jeton ERC-20 a sa propre logique commerciale qui dicte la gestion des jetons. Par exemple, un contrat d'approvisionnement fixe ne peut appeler que `_mint` dans le constructeur et jamais `_burn`. Un contrat qui vend des jetons appellera `_mint` lorsqu'il sera payé, et probablement `_burn` à un certain point pour éviter une inflation galopante.
+**NOTE :** Chaque jeton ERC-20 a sa propre logique métier qui dicte la gestion des jetons.
+Par exemple, un contrat à offre fixe peut n'appeler `_mint`
+que dans le constructeur et ne jamais appeler `_burn`. Un contrat qui vend des jetons
+appellera `_mint` lorsqu'il sera payé, et appellera vraisemblablement `_burn` à un certain moment
+pour éviter une inflation galopante.
 
 ```solidity
-    /** @dev Crée des jetons `amount` et les affecte à `account`, augmentant ainsi
+    /** @dev Crée un `montant` (`amount`) de jetons et les assigne à un `compte` (`account`), augmentant
      * l'offre totale.
      *
-     * Émet un événement {Transfer} avec `from` défini à l'adresse zéro.
+     * Émet un événement {Transfer} avec `from` défini sur l'adresse zéro.
      *
-     * Pré-requis:
+     * Exigences :
      *
-     * - `to' ne peut pas être l'adresse zéro.
+     * - `to` ne peut pas être l'adresse zéro.
      */
     function _mint(address account, uint256 amount) internal virtual {
         require(account != address(0), "ERC20: mint to the zero address");
@@ -677,21 +789,21 @@ Ces deux fonctions (`_mint` et `_burn`) modifient la quantité totale de jetons.
     }
 ```
 
-Veillez à mettre à jour `_totalSupply` lorsque le nombre total de jetons change.
+Assurez-vous de mettre à jour `_totalSupply` lorsque le nombre total de jetons change.
 
 &nbsp;
 
-```
+```solidity
     /**
-     * @dev Détruit les jetons `amount` de l'account`, réduisant ainsi
+     * @dev Détruit un `montant` (`amount`) de jetons du `compte` (`account`), réduisant
      * l'offre totale.
      *
-     * Émet un événement {Transfer} avec `to` défini à l'adresse zéro.
+     * Émet un événement {Transfer} avec `to` défini sur l'adresse zéro.
      *
-     * Pré-requis:
+     * Exigences :
      *
-     * - `account' ne peut pas être l'adresse zéro.
-     * - `account` doit au moins avoir un nombre de jetons correspondant à l'`amount`.
+     * - `account` ne peut pas être l'adresse zéro.
+     * - `account` doit avoir au moins un `montant` (`amount`) de jetons.
      */
     function _burn(address account, uint256 amount) internal virtual {
         require(account != address(0), "ERC20: burn from the zero address");
@@ -704,22 +816,25 @@ Veillez à mettre à jour `_totalSupply` lorsque le nombre total de jetons chang
     }
 ```
 
-La fonction `_burn` est presque identique à `_mint` sauf qu'elle fonctionne en sens inverse.
+La fonction `_burn` est presque identique à `_mint`, sauf qu'elle va dans l'autre sens.
 
-#### Fonction \_approve {#_approve}
+#### La fonction _approve {#_approve}
 
-C'est la fonction qui spécifie les provisions. Notez qu'elle permet à un propriétaire de spécifier une provision supérieure au solde actuel du propriétaire. Cela ne pose pas de problème car le solde est vérifié au moment du transfert dans la mesure où il pourrait être différent du solde existant au moment de la création de la provision.
+C'est la fonction qui spécifie réellement les allocations. Notez qu'elle permet à un propriétaire de spécifier
+une allocation supérieure au solde actuel du propriétaire. Ce n'est pas un problème car le solde est
+vérifié au moment du transfert, alors qu'il pourrait être différent du solde au moment de la création de l'allocation
+.
 
 ```solidity
     /**
-     * @dev  Définit le `montant` comme étant l'allocation que le `spender` attribue aux jetons de l'`owner`.
+     * @dev Définit un `montant` (`amount`) comme allocation de `spender` sur les jetons de `owner`.
      *
      * Cette fonction interne est équivalente à `approve`, et peut être utilisée pour
-     * par ex. définir des allocations automatiques pour certains sous-systèmes, etc.
+     * par exemple, définir des allocations automatiques pour certains sous-systèmes, etc.
      *
      * Émet un événement {Approval}.
      *
-     * Pré-requis :
+     * Exigences :
      *
      * - `owner` ne peut pas être l'adresse zéro.
      * - `spender` ne peut pas être l'adresse zéro.
@@ -733,7 +848,8 @@ C'est la fonction qui spécifie les provisions. Notez qu'elle permet à un propr
 
 &nbsp;
 
-Émettre un événement `Approval`. Selon la façon dont l'application est écrite, le contrat du client peut être informé de l'approbation soit par le propriétaire, soit par un serveur qui lit ces événements.
+Émettre un événement `Approval`. Selon la façon dont l'application est écrite, le contrat du dépensier peut être informé de l'approbation
+soit par le propriétaire, soit par un serveur qui écoute ces événements.
 
 ```solidity
         emit Approval(owner, spender, amount);
@@ -747,50 +863,68 @@ C'est la fonction qui spécifie les provisions. Notez qu'elle permet à un propr
 
 
     /**
-     * @dev Définit {decimals} à une valeur autre que la valeur par défaut de 18.
+     * @dev Définit {decimals} sur une valeur autre que celle par défaut de 18.
      *
-     * AVERTISSEMENT : Cette fonction ne doit être appelée qu'à partir du constructeur. La plupart des
-     * applications qui interagissent avec des contrats de jetons ne s'attendent pas à ce que
-     * {decimals} change jamais, et peuvent mal fonctionner si c'est le cas.
+     * AVERTISSEMENT : Cette fonction ne doit être appelée que depuis le constructeur. La plupart des
+     * applications qui interagissent avec les contrats de jeton ne s'attendront pas à ce que
+     * {decimals} change, et pourraient fonctionner de manière incorrecte si c'est le cas.
      */
     function _setupDecimals(uint8 decimals_) internal {
         _decimals = decimals_;
     }
 ```
 
-Cette fonction modifie la variable `_decimals` qui est utilisée pour dicter aux interfaces utilisateur comment interpréter le montant. Vous devez l'appeler depuis le constructeur. Il serait malhonnête de l'appeler à n'importe quel moment ultérieur et les applications ne sont pas conçues pour le gérer.
+Cette fonction modifie la variable `_decimals` qui est utilisée pour indiquer aux interfaces utilisateur comment interpréter le montant.
+Vous devez l'appeler depuis le constructeur. Il serait malhonnête de l'appeler à un moment ultérieur, et les applications
+ne sont pas conçues pour le gérer.
 
-### Hooks {#hooks}
+### Crochets {#hooks}
 
 ```solidity
 
     /**
-     * @dev Hook appelé avant tout transfert de jetons.      * frappe et brûlage compris.
+     * @dev Hook appelé avant tout transfert de jetons. Cela inclut
+     * la frappe et la brûlure.
      *
      * Conditions d'appel :
      *
-     * - lorsque `from` et `to` ne sont pas à zéro, `amount` jetons de ``from``
-     * seront transférés à `to`.
-     * - lorsque `from` est zéro, les jetons `amount` seront frappés pour `to`.
-     * - lorsque `to` est zéro, `amount` jetons de ``from`` seront brûlés.
+     * - lorsque `from` et `to` sont tous deux non nuls, un `montant` de jetons de `from`
+     * sera transféré à `to`.
+     * - lorsque `from` est zéro, un `montant` de jetons sera frappé pour `to`.
+     * - lorsque `to` est zéro, un `montant` de jetons de `from` sera brûlé.
      * - `from` et `to` ne sont jamais tous les deux nuls.
      *
-     * Pour en savoir plus sur les hook, rendez-vous sur xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+     * Pour en savoir plus sur les hooks, rendez-vous sur xref:ROOT:extending-contracts.adoc#using-hooks[Utilisation des hooks].
      */
     function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
 }
 ```
 
-Il s'agit de la fonction hook à appeler pendant les transferts. Elle est ici vide, mais si vous en avez besoin pour accomplir quelque chose, vous avez juste à la remplacer.
+Il s'agit de la fonction hook à appeler pendant les transferts. Elle est vide ici, mais si vous avez besoin
+qu'elle fasse quelque chose, il vous suffit de la remplacer.
 
 ## Conclusion {#conclusion}
 
-Pour résumer, voici quelques-unes des idées les plus importantes de ce contrat (selon moi et les vôtres pourraient ne pas être les mêmes) :
-
-- _Il n'y a pas de secret sur la blockchain._ Toute information accessible par un contrat intelligent l'est pour le monde entier.
-- Vous pouvez contrôler l'ordre de vos propres transactions, mais pas lorsque les transactions d'autres personnes sont en cours. C'est la raison pour laquelle un changement de provision peut être dangereux car il permet à la personne qui dépense de dépenser la somme des deux provisions.
-- Valeurs de type `uint256` enveloppent autour. En d'autres termes, _0-1=2^256-1_. Si ce comportement n'est pas souhaité, vous devez le vérifier (ou utiliser la bibliothèque SafeMath qui le fera pour vous). Notez que cela a changé avec [Solidity 0.8.0](https://docs.soliditylang.org/en/breaking/080-breaking-changes.html).
-- Effectuez tous les changements d'état d'un type spécifique en un emplacement spécifique, car cela facilite la vérification. C'est la raison pour laquelle nous disposons par exemple de `_approve`, appelée par `approve` `transferFrom`, `increaseAllowance`, et `decreaseAllowance`
-- Les changements d'état doivent être atomiques, sans aucune autre action au milieu (comme c'est le cas avec `_transfer`). Ceci parce que pendant le changement d'état, l'état est incohérent. Par exemple, entre le moment où vous déduisez du solde de la personne qui dépense et le moment où vous ajoutez au solde du bénéficiaire il y a moins de jeton existants qu'il ne devrait y en avoir. Ce laps de temps pourrait être utilisé à mauvais escient si des opérations interviennent entre eux, en particulier des appels à un contrat différent.
-
-Maintenant que vous avez pu constater comment le contrat OpenZeppelin ERC-20 est rédigé et surtout comment il est rendu plus sûr, rédigez vos propres contrats et applications sécurisés.
+Pour résumer, voici quelques-unes des idées les plus importantes de ce contrat (à mon avis, le vôtre est susceptible de varier) :
+
+- _Il n'y a pas de secret sur la blockchain_. Toute information à laquelle un contrat intelligent peut accéder
+  est disponible pour le monde entier.
+- Vous pouvez contrôler l'ordre de vos propres transactions, mais pas quand les transactions d'autres personnes
+  ont lieu. C'est la raison pour laquelle la modification d'une allocation peut être dangereuse, car elle permet
+  au dépensier de dépenser la somme des deux allocations.
+- Les valeurs de type `uint256` se bouclent. En d'autres termes, _0-1=2^256-1_. Si ce n'est pas le comportement souhaité,
+  vous devez le vérifier (ou utiliser la bibliothèque SafeMath qui le fait pour vous). Notez que cela a changé dans
+  [Solidity 0.8.0](https://docs.soliditylang.org/en/breaking/080-breaking-changes.html).
+- Effectuez tous les changements d'état d'un type spécifique à un endroit spécifique, car cela facilite l'audit.
+  C'est la raison pour laquelle nous avons, par exemple, `_approve`, qui est appelé par `approve`, `transferFrom`,
+  `increaseAllowance` et `decreaseAllowance`
+- Les changements d'état doivent être atomiques, sans aucune autre action au milieu (comme vous pouvez le voir
+  dans `_transfer`). C'est parce que pendant le changement d'état, vous avez un état incohérent. Par exemple,
+  entre le moment où vous déduisez du solde de l'expéditeur et le moment où vous ajoutez au solde du
+  destinataire, il y a moins de jetons en circulation qu'il ne devrait y en avoir. Cela pourrait être potentiellement exploité s'il y a
+  des opérations entre eux, en particulier des appels à un contrat différent.
+
+Maintenant que vous avez vu comment le contrat OpenZeppelin ERC-20 est écrit, et surtout comment il est
+rendu plus sécurisé, allez écrire vos propres contrats et applications sécurisés.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/erc20-with-safety-rails/index.md b/public/content/translations/fr/developers/tutorials/erc20-with-safety-rails/index.md
index 28edfe029b7..b36c194adf2 100644
--- a/public/content/translations/fr/developers/tutorials/erc20-with-safety-rails/index.md
+++ b/public/content/translations/fr/developers/tutorials/erc20-with-safety-rails/index.md
@@ -1,62 +1,64 @@
 ---
-title: ERC-20 en sécurité
-description: Comment aider les gens à éviter des erreurs bêtes
+title: ERC-20 avec des garde-fous
+description: "Comment aider les gens à éviter des erreurs bêtes"
 author: Ori Pomerantz
 lang: fr
-tags:
-  - "erc-20"
+tags: [ "erc-20" ]
 skill: beginner
 published: 2022-08-15
 ---
 
 ## Introduction {#introduction}
 
-L'un des grands avantages avec Ethereum est qu'il n'y a pas d'autorité centrale qui peut modifier ou annuler vos transactions. L'un des grands problèmes avec Ethereum est qu'il n'y a pas d'autorité centrale ayant le pouvoir d'annuler les erreurs des utilisateurs ou les transactions illicites. Dans cet article, vous apprendrez quelques-unes des erreurs courantes que commettent les utilisateurs avec les jetons [ERC-20](/developers/docs/standards/tokens/erc-20/), ainsi que comment créer des contrats ERC-20 qui aident les utilisateurs à éviter ces erreurs, ou qui donnent à une autorité centrale certains pouvoirs (par exemple, geler des comptes).
+L'un des grands avantages d'Ethereum est qu'il n'y a pas d'autorité centrale qui peut modifier ou annuler vos transactions. L'un des grands problèmes d'Ethereum est qu'il n'y a pas d'autorité centrale ayant le pouvoir d'annuler les erreurs des utilisateurs ou les transactions illicites. Dans cet article, vous apprendrez quelques-unes des erreurs courantes que commettent les utilisateurs avec les jetons [ERC-20](/developers/docs/standards/tokens/erc-20/), ainsi que comment créer des contrats ERC-20 qui aident les utilisateurs à éviter ces erreurs, ou qui donnent à une autorité centrale certains pouvoirs (par exemple, geler des comptes).
 
-Notez que bien que nous utiliserons le [contrat de jeton ERC-20 d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20), cet article n'explique pas en détail son fonctionnement. Vous pouvez trouver ces informations [ici](/developers/tutorials/erc20-annotated-code).
+Notez que bien que nous utilisions le [contrat de jeton ERC-20 d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20), cet article ne l'explique pas en détail. Vous pouvez trouver ces informations [ici](/developers/tutorials/erc20-annotated-code).
 
 Si vous souhaitez consulter le code source complet :
 
 1. Ouvrez l'[IDE Remix](https://remix.ethereum.org/).
-2. Cliquez sur l'icône de clonage GitHub (![clone GitHub icon](icon-clone.png)).
-3. Clonez le référentiel GitHub `https://github.com/qbzzt/20220815-erc20-safety-rails`.
-4. Ouvrez **contrats > erc20-safety-rails.sol**.
+2. Cliquez sur l'icône de clonage de GitHub (![icône de clonage de GitHub](icon-clone.png)).
+3. Clonez le dépôt GitHub `https://github.com/qbzzt/20220815-erc20-safety-rails`.
+4. Ouvrez **contracts > erc20-safety-rails.sol**.
 
 ## Création d'un contrat ERC-20 {#creating-an-erc-20-contract}
 
-Avant de pouvoir ajouter la fonctionnalité de sécurité, nous avons besoin d'un contrat ERC-20. Dans cet article, nous utiliserons [l'assistant de contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/wizard). Ouvrez-le dans un autre navigateur et suivez ces instructions :
+Avant de pouvoir ajouter la fonctionnalité de garde-fou, nous avons besoin d'un contrat ERC-20. Dans cet article, nous utiliserons [l'assistant de contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/wizard). Ouvrez-le dans un autre navigateur et suivez ces instructions :
 
 1. Sélectionnez **ERC20**.
+
 2. Entrez ces paramètres :
 
    | Paramètre        | Valeur           |
    | ---------------- | ---------------- |
    | Nom              | SafetyRailsToken |
    | Symbole          | SAFE             |
-   | Pré-génère       | 1000             |
-   | Fonctionnalités  | Aucune           |
-   | Contrôle d'accès | Propriétaire     |
-   | Mise à jour      | Aucune           |
+   | Prémint          | 1000             |
+   | Fonctionnalités  | Aucun            |
+   | Contrôle d'accès | Ownable          |
+   | Évolutivité      | Aucun            |
+
+3. Faites défiler vers le haut et cliquez sur **Ouvrir dans Remix** (pour Remix) ou sur **Télécharger** pour utiliser un autre environnement. Je vais supposer que vous utilisez Remix. Si vous utilisez autre chose, faites simplement les modifications appropriées.
 
-3. Remontez et cliquez sur **Ouvrir dans Remix** (pour Remix) ou **Télécharger** pour utiliser un environnement différent. Je vais supposer que vous utilisez Remix, si vous utilisez autre chose, faites simplement les modifications appropriées.
-4. Nous avons maintenant un contrat ERC-20 pleinement fonctionnel. Vous pouvez développer `.deps` > ` npm` pour voir le code importé.
-5. Compilez, déployez et jouez avec le contrat pour voir qu'il fonctionne comme un contrat ERC-20. Si vous devez apprendre à utiliser Remix, [utilisez ce tutoriel](https://remix.ethereum.org/?#activate=udapp,solidity,LearnEth).
+4. Nous avons maintenant un contrat ERC-20 pleinement fonctionnel. Vous pouvez développer `.deps` > `npm` pour voir le code importé.
+
+5. Compilez, déployez et interagissez avec le contrat pour voir qu'il fonctionne comme un contrat ERC-20. Si vous avez besoin d'apprendre à utiliser Remix, [consultez ce tutoriel](https://remix.ethereum.org/?#activate=udapp,solidity,LearnEth).
 
 ## Erreurs courantes {#common-mistakes}
 
 ### Les erreurs {#the-mistakes}
 
-Les utilisateurs envoient parfois des tokens à la mauvaise adresse. Bien que nous ne puissions pas lire dans leurs pensées pour savoir ce qu'ils voulaient faire, il existe deux types d'erreurs qui se produisent souvent et sont faciles à détecter :
+Les utilisateurs envoient parfois des jetons à la mauvaise adresse. Bien que nous ne puissions pas lire dans leurs pensées pour savoir ce qu'ils voulaient faire, il existe deux types d'erreurs qui se produisent souvent et qui sont faciles à détecter :
 
-1. Envoyer les jetons à l'adresse du contrat lui-même. Par exemple, [le token OP d'Optimism](https://optimism.mirror.xyz/qvd0WfuLKnePm1Gxb9dpGchPf5uDz5NSMEFdgirDS4c) a réussi à accumuler [plus de 120 000 tokens OP](https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000042#tokentxns) en moins de deux mois. Cela représente une somme d'argent considérable que, vraisemblablement, des gens ont simplement perdue.
+1. Envoi des jetons à la propre adresse du contrat. Par exemple, le [jeton OP d'Optimism](https://optimism.mirror.xyz/qvd0WfuLKnePm1Gxb9dpGchPf5uDz5NSMEFdgirDS4c) a accumulé [plus de 120 000](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000042) jetons OP en moins de deux mois. Cela représente une somme d'argent considérable que, vraisemblablement, des personnes ont simplement perdue.
 
-2. Envoyer les tokens à une adresse vide, une adresse qui ne correspond pas à [un compte possédé extérieurement](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs) ou [à un contrat intelligent](/developers/docs/smart-contracts). Bien que je n'aie pas de statistiques sur la fréquence à laquelle cela se produit, [un incident aurait pu coûter 20 000 000 tokens](https://gov.optimism.io/t/message-to-optimism-community-from-wintermute/2595).
+2. Envoi de jetons à une adresse vide, c'est-à-dire une adresse qui ne correspond ni à un [compte externe](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs) ni à un [contrat intelligent](/developers/docs/smart-contracts). Bien que je n'aie pas de statistiques sur la fréquence à laquelle cela se produit, [un incident aurait pu coûter 20 000 000 de jetons](https://gov.optimism.io/t/message-to-optimism-community-from-wintermute/2595).
 
-### Prévenir les transferts {#preventing-transfers}
+### Prévention des transferts {#preventing-transfers}
 
-Le contrat ERC-20 d'OpenZeppelin comprend [un crochet`, _beforeTokenTransfer`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol#L364-L368), qui est appelé avant qu'un token soit transféré. Par défaut, ce crochet ne fait rien, mais nous pouvons y ajouter notre propre fonctionnalité, comme des vérifications qui annulent le transfert s'il y a un problème.
+Le contrat ERC-20 d'OpenZeppelin inclut [un hook, `_beforeTokenTransfer`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol#L364-L368), qui est appelé avant le transfert d'un jeton. Par défaut, ce hook ne fait rien, mais nous pouvons y ajouter notre propre fonctionnalité, comme des vérifications qui annulent la transaction en cas de problème.
 
-Pour utiliser le crochet, ajoutez cette fonction après le constructeur :
+Pour utiliser le hook, ajoutez cette fonction après le constructeur :
 
 ```solidity
     function _beforeTokenTransfer(address from, address to, uint256 amount)
@@ -67,42 +69,42 @@ Pour utiliser le crochet, ajoutez cette fonction après le constructeur :
     }
 ```
 
-Certaines parties de cette fonction peuvent vous être nouvelles si vous n'êtes pas très familiarisé avec Solidity :
+Certaines parties de cette fonction peuvent vous paraître nouvelles si vous n'êtes pas très familier avec Solidity :
 
 ```solidity
         internal virtual
 ```
 
-Le mot-clé `virtual` signifie que tout comme nous avons hérité de la fonctionnalité `d'ERC20` et avons surchargé cette fonction, d'autres contrats peuvent hériter de nous et surcharger aussi cette fonction.
+Le mot-clé `virtual` signifie que, tout comme nous avons hérité de la fonctionnalité de `ERC20` et avons substitué cette fonction, d'autres contrats peuvent hériter de nous et substituer également cette fonction.
 
 ```solidity
         override(ERC20)
 ```
 
-Nous devons explicitement spécifier que nous [surchargeons](https://docs.soliditylang.org/en/v0.8.15/contracts.html#function-overriding) la définition du jeton ERC20 de `_beforeTokenTransfer`. En général, les définitions explicites sont bien meilleures, du point de vue de la sécurité, que les définitions implicites : vous ne pouvez pas oublier que vous avez fait quelque chose si cela se trouve juste devant vous. C'est aussi la raison pour laquelle nous devons spécifier quelle surclasse de `_beforeTokenTransfer` nous surchargeons.
+Nous devons spécifier explicitement que nous [substituons](https://docs.soliditylang.org/en/v0.8.15/contracts.html#function-overriding) la définition de `_beforeTokenTransfer` du jeton ERC20. En général, les définitions explicites sont bien meilleures du point de vue de la sécurité que les définitions implicites : vous ne pouvez pas oublier que vous avez fait quelque chose si cela se trouve juste devant vous. C'est aussi la raison pour laquelle nous devons spécifier de quelle superclasse nous substituons la fonction `_beforeTokenTransfer`.
 
 ```solidity
         super._beforeTokenTransfer(from, to, amount);
 ```
 
-Cette ligne appelle la fonction `_beforeTokenTransfer` du ou des contrats dont nous avons hérité et qui la possèdent. Dans ce cas, il s'agit uniquement `d'ERC20`, `Ownable` n'a pas ce crochet. Bien qu'actuellement `ERC20._beforeTokenTransfer` ne fasse rien, nous l'appelons au cas où une fonctionnalité serait ajoutée à l'avenir (et nous décidons alors de redéployer le contrat, car les contrats ne changent pas après le déploiement).
+Cette ligne appelle la fonction `_beforeTokenTransfer` du ou des contrats dont nous avons hérité qui la possèdent. Dans ce cas, il s'agit uniquement de `ERC20`, car `Ownable` n'a pas ce hook. Même si `ERC20._beforeTokenTransfer` ne fait rien actuellement, nous l'appelons au cas où une fonctionnalité serait ajoutée à l'avenir (et que nous décidions alors de redéployer le contrat, car les contrats ne changent pas après leur déploiement).
 
-### Codage des exigences {#coding-the-requirements}
+### Coder les exigences {#coding-the-requirements}
 
 Nous voulons ajouter ces exigences à la fonction :
 
-- L'adresse `to` ne peut pas être égale à cette `address`, l'adresse du contrat ERC-20 lui-même.
+- L'adresse `to` ne peut pas être égale à `address(this)`, l'adresse du contrat ERC-20 lui-même.
 - L'adresse `to` ne peut pas être vide, elle doit être soit :
-  - Un compte détenu extérieurement (EOA). Nous ne pouvons pas vérifier directement si une adresse est un EOA, mais nous pouvons vérifier le solde ETH d'une adresse. Les EOA ont presque toujours un solde, même s'ils ne sont plus utilisés - il est difficile de les vider jusqu'au dernier wei.
-  - Un contrat intelligent. Tester si une adresse est un contrat intelligent est un peu plus difficile. Il existe un opcode qui vérifie la longueur du code externe, appelé [`EXTCODESIZE`](https://www.evm.codes/#3b), mais il n'est pas directement disponible en Solidity. Nous devons utiliser [Yul](https://docs.soliditylang.org/en/v0.8.15/yul.html), qui est l'assembleur EVM, pour cela. Il existe d'autres valeurs que nous pourrions utiliser depuis Solidity ([`<address>.code` et `<address>.codehash`](https://docs.soliditylang.org/en/v0.8.15/units-and-global-variables.html#members-of-address-types)), mais elles coûtent plus cher.
+  - Un compte externe (EOA). Nous ne pouvons pas vérifier directement si une adresse est un EOA, mais nous pouvons vérifier le solde en ETH d'une adresse. Les EOA ont presque toujours un solde, même s'ils ne sont plus utilisés. Il est difficile de les vider jusqu'au dernier wei.
+  - Un contrat intelligent. Vérifier si une adresse est un contrat intelligent est un peu plus difficile. Il existe un opcode qui vérifie la longueur du code externe, appelé [`EXTCODESIZE`](https://www.evm.codes/#3b), mais il n'est pas disponible directement dans Solidity. Pour cela, nous devons utiliser [Yul](https://docs.soliditylang.org/en/v0.8.15/yul.html), qui est l'assembleur de l'EVM. Il existe d'autres valeurs que nous pourrions utiliser à partir de Solidity ([`<address>.code` et `<address>.codehash`](https://docs.soliditylang.org/en/v0.8.15/units-and-global-variables.html#members-of-address-types)), mais elles coûtent plus cher.
 
-Examinons le nouveau code ligne par ligne :
+Passons en revue le nouveau code, ligne par ligne :
 
 ```solidity
-        require(to != address(this), "Can't send tokens to the contract address");
+        require(to != address(this), "Impossible d'envoyer des jetons à l'adresse du contrat");
 ```
 
-C'est la première exigence, vérifier que `to` et `cette(address)` ne sont pas la même chose.
+C'est la première exigence : vérifier que `to` et `address(this)` ne sont pas la même chose.
 
 ```solidity
         bool isToContract;
@@ -111,53 +113,53 @@ C'est la première exigence, vérifier que `to` et `cette(address)` ne sont pas
         }
 ```
 
-C'est ainsi que nous vérifions si une adresse est un contrat. Nous ne pouvons pas recevoir de réponse directement de Yul, nous définissons donc une variable pour contenir le résultat (`isToContract` dans ce cas). La façon dont Yul fonctionne est que chaque opcode est considéré comme une fonction. Nous appelons donc d'abord [`EXTCODESIZE`](https://www.evm.codes/#3b) pour obtenir la taille du contrat, puis utilisons [`GT`](https://www.evm.codes/#11) pour vérifier qu'elle n'est pas nulle (nous travaillons avec des entiers non signés, donc bien sûr elle ne peut pas être négative). Nous écrivons ensuite le résultat dans `isToContract`.
+Voici comment nous vérifions si une adresse est un contrat. Nous ne pouvons pas recevoir de sortie directement de Yul. À la place, nous définissons donc une variable pour conserver le résultat (`isToContract` dans ce cas). Yul fonctionne de telle manière que chaque opcode est considéré comme une fonction. Donc, nous appelons d'abord [`EXTCODESIZE`](https://www.evm.codes/#3b) pour obtenir la taille du contrat, puis nous utilisons [`GT`](https://www.evm.codes/#11) pour vérifier qu'elle n'est pas nulle (nous avons affaire à des entiers non signés, donc bien sûr, elle ne peut pas être négative). Nous écrivons ensuite le résultat dans `isToContract`.
 
 ```solidity
-        require(to.balance != 0 || isToContract, "Can't send tokens to an empty address");
+        require(to.balance != 0 || isToContract, "Impossible d'envoyer des jetons à une adresse vide");
 ```
 
-Et enfin, nous avons la vérification réelle des adresses vides.
+Et enfin, nous avons la vérification effective des adresses vides.
 
 ## Accès administratif {#admin-access}
 
-Parfois, il est utile d'avoir un administrateur qui peut annuler des erreurs. Pour réduire le potentiel d'abus, cet administrateur peut être géré par une [multisig](https://blog.logrocket.com/security-choices-multi-signature-wallets/), ce qui signifie que plusieurs personnes doivent accepter une action. Dans cet article, nous aurons deux fonctionnalités administratives :
+Il est parfois utile d'avoir un administrateur qui peut annuler des erreurs. Pour réduire le potentiel d'abus, cet administrateur peut être un [multisig](https://blog.logrocket.com/security-choices-multi-signature-wallets/), de sorte que plusieurs personnes doivent approuver une action. Dans cet article, nous verrons deux fonctionnalités administratives :
 
 1. Le gel et le dégel des comptes. Ceci peut être utile, par exemple, lorsqu'un compte pourrait être compromis.
 2. Nettoyage des actifs.
 
-   Parfois, des fraudeurs envoient des jetons frauduleux au vrai contrat pour gagner en légitimité. Par exemple, [regardez ici](https://optimistic.etherscan.io/token/0x2348b1a1228ddcd2db668c3d30207c3e1852fbbe?a=0x4200000000000000000000000000000000000042). Le contrat ERC-20 légitime est [0x4200....0042](https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000042). L'arnaque qui prétend l'être est [0x234....bbe](https://optimistic.etherscan.io/address/0x2348b1a1228ddcd2db668c3d30207c3e1852fbbe).
+   Parfois, des fraudeurs envoient des jetons frauduleux au contrat du jeton réel pour gagner en légitimité. Par exemple, [voir ici](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe?tab=holders). Le contrat ERC-20 légitime est [0x4200....0042](https://optimism.blockscout.com/token/0x4200000000000000000000000000000000000042). L'arnaque qui prétend être ce contrat est [0x234....bbe](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe).
 
    Il est également possible que des personnes envoient par erreur des jetons ERC-20 légitimes à notre contrat, ce qui est une autre raison de vouloir trouver un moyen de les retirer.
 
 OpenZeppelin fournit deux mécanismes pour activer l'accès administratif :
 
-- Les contrats [`Ownable`](https://docs.openzeppelin.com/contracts/5.x/access-control#ownership-and-ownable) ont un seul propriétaire. Les fonctions ayant le [modificateur](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) `onlyOwner` ne peuvent être appelées que par ce propriétaire. Les propriétaires peuvent transférer la propriété à quelqu'un d'autre ou y renoncer complètement. Les droits de tous les autres comptes sont généralement identiques.
-- Les contrats [`AccessControl`](https://docs.openzeppelin.com/contracts/5.x/access-control#role-based-access-control) ont [un contrôle d'accès basé sur les rôles (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control).
+- Les contrats `Ownable` ont un propriétaire unique. Les fonctions qui ont le [modificateur](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) `onlyOwner` ne peuvent être appelées que par ce propriétaire. Les propriétaires peuvent transférer la propriété à quelqu'un d'autre ou y renoncer complètement. Les droits de tous les autres comptes sont généralement identiques.
+- Les contrats `AccessControl` ont un [contrôle d'accès basé sur les rôles (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control).
 
-Pour simplifier, dans cet article, nous utilisons `Ownable`.
+Par souci de simplicité, nous utilisons `Ownable` dans cet article.
 
-### Geler et dégeler les contrats {#freezing-and-thawing-contracts}
+### Gel et dégel des contrats {#freezing-and-thawing-contracts}
 
 Le gel et le dégel des contrats nécessitent plusieurs modifications :
 
-- Un [mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) d'adresses à des [booléens](https://en.wikipedia.org/wiki/Boolean_data_type) pour suivre quelles adresses sont gelées. Toutes les valeurs sont initialement à zéro, ce qui, pour les valeurs booléennes, est interprété comme faux. C'est ce que nous voulons, car par défaut, les comptes ne sont pas gelés.
+- Un [mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) des adresses vers des [booléens](https://en.wikipedia.org/wiki/Boolean_data_type) pour suivre les adresses qui sont gelées. Toutes les valeurs sont initialement à zéro, ce qui, pour les valeurs booléennes, est interprété comme faux. C'est ce que nous voulons, car par défaut, les comptes ne sont pas gelés.
 
   ```solidity
       mapping(address => bool) public frozenAccounts;
   ```
 
-- Des [événements](https://www.tutorialspoint.com/solidity/solidity_events.htm) pour informer quiconque intéressé lorsqu'un compte est gelé ou dégelé. Techniquement, ces événements ne sont pas nécessaires pour ces actions, mais cela aide le code hors chaîne à pouvoir écouter ces événements et savoir ce qui se passe. Il est considéré comme une bonne manière pour un contrat intelligent de les émettre lorsque quelque chose qui pourrait être pertinent pour quelqu'un d'autre se produit.
+- Des [événements](https://www.tutorialspoint.com/solidity/solidity_events.htm) pour informer toute personne intéressée lorsqu'un compte est gelé ou dégelé. Techniquement, les événements ne sont pas requis pour ces actions, mais ils aident le code hors chaîne à écouter ces événements et à savoir ce qui se passe. Il est de bon ton pour un contrat intelligent de les émettre lorsque quelque chose qui pourrait intéresser quelqu'un d'autre se produit.
 
-  Les événements sont indexés, il sera donc possible de rechercher toutes les fois qu'un compte a été gelé ou dégelé.
+  Les événements sont indexés, il sera donc possible de rechercher toutes les fois où un compte a été gelé ou dégelé.
 
   ```solidity
-    // When accounts are frozen or unfrozen
+    // Lorsque les comptes sont gelés ou dégelés
     event AccountFrozen(address indexed _addr);
     event AccountThawed(address indexed _addr);
   ```
 
-- Fonctions pour geler et dégeler les comptes. Ces deux fonctions sont presque identiques, nous n'expliquerons donc que la fonction de gel.
+- Fonctions pour geler et dégeler les comptes. Ces deux fonctions sont presque identiques, nous n'examinerons donc que la fonction de gel.
 
   ```solidity
       function freezeAccount(address addr)
@@ -165,27 +167,27 @@ Le gel et le dégel des contrats nécessitent plusieurs modifications :
         onlyOwner
   ```
 
-  Les fonctions marquées comme [`public`](https://www.tutorialspoint.com/solidity/solidity_contracts.htm) peuvent être appelées à partir d'autres contrats intelligents ou directement par une transaction.
+  Les fonctions marquées comme [`public`](https://www.tutorialspoint.com/solidity/solidity_contracts.htm) peuvent être appelées depuis d'autres contrats intelligents ou directement par une transaction.
 
   ```solidity
     {
-        require(!frozenAccounts[addr], "Account already frozen");
+        require(!frozenAccounts[addr], "Compte déjà gelé");
         frozenAccounts[addr] = true;
         emit AccountFrozen(addr);
     }  // freezeAccount
   ```
 
-  Si le compte est déjà gelé, annulez. Sinon, gelez-le et `émettez` un événement.
+  Si le compte est déjà gelé, la transaction est annulée. Sinon, gelez-le et `émettez` un événement.
 
-- Modifiez `_beforeTokenTransfer` pour empêcher le transfert d'argent depuis un compte gelé. Notez que l'argent peut toujours être transféré vers le compte gelé.
+- Modifiez `_beforeTokenTransfer` pour empêcher que des fonds ne soient déplacés depuis un compte gelé. Notez que des fonds peuvent toujours être transférés vers le compte gelé.
 
   ```solidity
-       require(!frozenAccounts[from], "The account is frozen");
+       require(!frozenAccounts[from], "Le compte est gelé");
   ```
 
 ### Nettoyage des actifs {#asset-cleanup}
 
-Pour libérer les jetons ERC-20 détenus par ce contrat, nous devons appeler une fonction sur le contrat token auquel ils appartiennent, soit [`transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer) soit [`approve`](https://eips.ethereum.org/EIPS/eip-20#approve). Cela ne sert à rien de gaspiller du gaz dans ce cas en quotas, autant transférer directement.
+Pour libérer les jetons ERC-20 détenus par ce contrat, nous devons appeler une fonction sur le contrat de jeton auquel ils appartiennent, soit [`transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer) soit [`approve`](https://eips.ethereum.org/EIPS/eip-20#approve). Il est inutile de gaspiller du gaz sur des allocations dans ce cas, autant transférer directement.
 
 ```solidity
     function cleanupERC20(
@@ -198,7 +200,7 @@ Pour libérer les jetons ERC-20 détenus par ce contrat, nous devons appeler une
         IERC20 token = IERC20(erc20);
 ```
 
-C'est la syntaxe pour créer un objet pour un contrat lorsque nous recevons l'adresse. Nous pouvons faire cela parce que nous avons la définition des jetons ERC20 dans le code source (voir ligne 4), et ce fichier inclut [la définition pour IERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol), l'interface pour un contrat ERC-20 d'OpenZeppelin.
+C'est la syntaxe pour créer un objet pour un contrat lorsque nous recevons l'adresse. Nous pouvons le faire parce que nous avons la définition des jetons ERC20 dans le code source (voir la ligne 4), et ce fichier inclut [la définition de IERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol), l'interface pour un contrat ERC-20 OpenZeppelin.
 
 ```solidity
         uint balance = token.balanceOf(address(this));
@@ -206,8 +208,10 @@ C'est la syntaxe pour créer un objet pour un contrat lorsque nous recevons l'ad
     }
 ```
 
-C'est une fonction de nettoyage, nous ne voulons donc probablement laisser aucun jeton. Au lieu d'obtenir le solde de l'utilisateur manuellement, autant automatiser le processus.
+Il s'agit d'une fonction de nettoyage, donc nous ne voulons vraisemblablement laisser aucun jeton. Au lieu de demander manuellement le solde à l'utilisateur, nous pouvons tout aussi bien automatiser le processus.
 
 ## Conclusion {#conclusion}
 
-Ce n'est pas une solution parfaite - il n'existe pas de solution parfaite au problème « l'utilisateur a fait une erreur ». Cependant, utiliser ce type de vérifications peut au moins prévenir certaines erreurs. La capacité à geler des comptes, bien que dangereuse, peut être utilisée pour limiter les dégâts de certaines attaques en refusant au pirate les fonds volés.
+Ce n'est pas une solution parfaite. Il n'y a pas de solution parfaite au problème « l'utilisateur a fait une erreur ». Cependant, l'utilisation de ce type de vérifications peut au moins éviter certaines erreurs. La possibilité de geler des comptes, bien que dangereuse, peut être utilisée pour limiter les dégâts de certains piratages en refusant au pirate les fonds volés.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/ethereum-for-web2-auth/index.md b/public/content/translations/fr/developers/tutorials/ethereum-for-web2-auth/index.md
new file mode 100644
index 00000000000..0eb12e3b3e8
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/ethereum-for-web2-auth/index.md
@@ -0,0 +1,886 @@
+---
+title: Utiliser Ethereum pour l'authentification web2
+description: "Après avoir lu ce tutoriel, un développeur sera en mesure d'intégrer la connexion Ethereum (web3) à la connexion SAML, une norme utilisée dans le web2 pour fournir une authentification unique et d'autres services connexes. Cela permet d'authentifier l'accès aux ressources web2 par le biais de signatures Ethereum, les attributs de l'utilisateur provenant d'attestations."
+author: Ori Pomerantz
+tags: [ "web2", "authentification", "eas" ]
+skill: beginner
+lang: fr
+published: 2025-04-30
+---
+
+## Introduction
+
+[SAML](https://www.onelogin.com/learn/saml) est une norme utilisée sur le web2 pour permettre à un [fournisseur d'identité (IdP)](https://en.wikipedia.org/wiki/Identity_provider#SAML_identity_provider) de fournir des informations sur l'utilisateur aux [fournisseurs de services (SP)](https://en.wikipedia.org/wiki/Service_provider_\(SAML\)).
+
+Dans ce tutoriel, vous apprendrez comment intégrer les signatures Ethereum avec SAML pour permettre aux utilisateurs d'utiliser leurs portefeuilles Ethereum pour s'authentifier auprès de services web2 qui ne prennent pas encore en charge Ethereum de manière native.
+
+Notez que ce tutoriel s'adresse à deux publics distincts :
+
+- Les personnes familières avec Ethereum qui comprennent Ethereum et qui ont besoin d'apprendre SAML
+- Les personnes familières avec le Web2 qui comprennent SAML et l'authentification web2 et qui ont besoin d'apprendre Ethereum
+
+Par conséquent, il contiendra beaucoup de matériel d'introduction que vous connaissez déjà. N'hésitez pas à le sauter.
+
+### SAML pour les personnes familières avec Ethereum
+
+SAML est un protocole centralisé. Un fournisseur de services (SP) n'accepte les assertions (telles que « voici mon utilisateur John, il devrait avoir les permissions pour faire A, B et C ») d'un fournisseur d'identité (IdP) que s'il a une relation de confiance préexistante soit avec lui, soit avec [l'autorité de certification](https://www.ssl.com/article/what-is-a-certificate-authority-ca/) qui a signé le certificat de cet IdP.
+
+Par exemple, le SP peut être une agence de voyage fournissant des services de voyage aux entreprises, et l'IdP peut être le site web interne d'une entreprise. Lorsque des employés doivent réserver un voyage d'affaires, l'agence de voyage les envoie pour une authentification par l'entreprise avant de les laisser réserver le voyage.
+
+![Processus SAML étape par étape](./fig-01-saml.png)
+
+C'est ainsi que les trois entités, le navigateur, le SP et l'IdP, négocient l'accès. Le SP n'a pas besoin de connaître à l'avance quoi que ce soit sur l'utilisateur qui utilise le navigateur, il lui suffit de faire confiance à l'IdP.
+
+### Ethereum pour les personnes familières avec SAML
+
+Ethereum est un système décentralisé.
+
+![Connexion Ethereum](./fig-02-eth-logon.png)
+
+Les utilisateurs ont une clé privée (généralement conservée dans une extension de navigateur). À partir de la clé privée, vous pouvez dériver une clé publique, et à partir de celle-ci, une adresse de 20 octets. Lorsque les utilisateurs doivent se connecter à un système, il leur est demandé de signer un message avec un nonce (une valeur à usage unique). Le serveur peut vérifier que la signature a été créée par cette adresse.
+
+![Obtenir des données supplémentaires à partir des attestations](./fig-03-eas-data.png)
+
+La signature ne vérifie que l'adresse Ethereum. Pour obtenir d'autres attributs utilisateur, vous utilisez généralement des [attestations](https://attest.org/). Une attestation comporte généralement les champs suivants :
+
+- **Attestateur**, l'adresse qui a fait l'attestation
+- **Destinataire**, l'adresse à laquelle s'applique l'attestation
+- **Données**, les données attestées, telles que le nom, les permissions, etc.
+- **Schéma**, l'ID du schéma utilisé pour interpréter les données.
+
+En raison de la nature décentralisée d'Ethereum, tout utilisateur peut faire des attestations. L'identité de l'attestateur est importante pour identifier les attestations que nous considérons comme fiables.
+
+## Configuration
+
+La première étape consiste à avoir un SP SAML et un IdP SAML qui communiquent entre eux.
+
+1. Téléchargez le logiciel. L'exemple de logiciel pour cet article se trouve [sur github](https://github.com/qbzzt/250420-saml-ethereum). Les différentes étapes sont stockées dans différentes branches, pour cette étape, vous voulez `saml-only`
+
+    ```sh
+    git clone https://github.com/qbzzt/250420-saml-ethereum -b saml-only
+    cd 250420-saml-ethereum
+    pnpm install
+    ```
+
+2. Créez des clés avec des certificats auto-signés. Cela signifie que la clé est sa propre autorité de certification et doit être importée manuellement chez le fournisseur de services. Consultez [la documentation OpenSSL](https://docs.openssl.org/master/man1/openssl-req/) pour plus d'informations.
+
+    ```sh
+    mkdir keys
+    cd keys
+    openssl req -new -x509 -days 365 -nodes -sha256 -out saml-sp.crt -keyout saml-sp.pem -subj /CN=sp/
+    openssl req -new -x509 -days 365 -nodes -sha256 -out saml-idp.crt -keyout saml-idp.pem -subj /CN=idp/
+    cd ..
+    ```
+
+3. Démarrez les serveurs (à la fois SP et IdP)
+
+    ```sh
+    pnpm start
+    ```
+
+4. Naviguez vers le SP à l'URL [http://localhost:3000/](http://localhost:3000/) et cliquez sur le bouton pour être redirigé vers l'IdP (port 3001).
+
+5. Fournissez à l'IdP votre adresse e-mail et cliquez sur **Se connecter au fournisseur de services**. Constatez que vous êtes redirigé vers le fournisseur de services (port 3000) et qu'il vous reconnaît par votre adresse e-mail.
+
+### Explication détaillée
+
+Voici ce qui se passe, étape par étape :
+
+![Connexion SAML normale sans Ethereum](./fig-04-saml-no-eth.png)
+
+#### src/config.mts
+
+Ce fichier contient la configuration du fournisseur d'identité et du fournisseur de services. Normalement, il s'agirait de deux entités différentes, mais ici, nous pouvons partager le code par souci de simplicité.
+
+```typescript
+const fs = await import("fs")
+
+const protocol="http"
+```
+
+Pour l'instant, nous ne faisons que des tests, il est donc acceptable d'utiliser HTTP.
+
+```typescript
+export const spCert = fs.readFileSync("keys/saml-sp.crt").toString()
+export const idpCert = fs.readFileSync("keys/saml-idp.crt").toString()
+```
+
+Lisez les clés publiques, qui sont normalement disponibles pour les deux composants (et soit directement approuvées, soit signées par une autorité de certification de confiance).
+
+```typescript
+export const spPort = 3000
+export const spHostname = "localhost"
+export const spDir = "sp"
+
+export const idpPort = 3001
+export const idpHostname = "localhost"
+export const idpDir = "idp"
+
+export const spUrl = `${protocol}://${spHostname}:${spPort}/${spDir}`
+export const idpUrl = `${protocol}://${idpHostname}:${idpPort}/${idpDir}`
+```
+
+Les URL des deux composants.
+
+```typescript
+export const spPublicData = {
+```
+
+Les données publiques pour le fournisseur de services.
+
+```typescript
+    entityID: `${spUrl}/metadata`,
+```
+
+Par convention, en SAML, l'`entityID` est l'URL où les métadonnées de l'entité sont disponibles. Ces métadonnées correspondent aux données publiques ici, sauf qu'elles sont sous forme XML.
+
+```typescript
+    wantAssertionsSigned: true,
+    authnRequestsSigned: false,
+    signingCert: spCert,
+    allowCreate: true,
+    assertionConsumerService: [{
+        Binding: 'urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST',
+        Location: `${spUrl}/assertion`,
+    }]
+  }
+```
+
+La définition la plus importante pour nos besoins est `assertionConsumerServer`. Cela signifie que pour affirmer quelque chose (par exemple, « l'utilisateur qui vous envoie cette information est quelqu'un@exemple.com ») au fournisseur de services, nous devons utiliser [HTTP POST](https://www.w3schools.com/tags/ref_httpmethods.asp) à l'URL `http://localhost:3000/sp/assertion`.
+
+```typescript
+export const idpPublicData = {
+    entityID: `${idpUrl}/metadata`,
+    signingCert: idpCert,
+    wantAuthnRequestsSigned: false,
+    singleSignOnService: [{
+      Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+      Location: `${idpUrl}/login`
+    }],
+    singleLogoutService: [{
+      Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+      Location: `${idpUrl}/logout`
+    }],
+  }
+```
+
+Les données publiques pour le fournisseur d'identité sont similaires. Il spécifie que pour connecter un utilisateur, vous devez faire une requête POST sur `http://localhost:3001/idp/login` et pour déconnecter un utilisateur, vous devez faire une requête POST sur `http://localhost:3001/idp/logout`.
+
+#### src/sp.mts
+
+Ceci est le code qui implémente un fournisseur de services.
+
+```typescript
+import * as config from "./config.mts"
+const fs = await import("fs")
+const saml = await import("samlify")
+```
+
+Nous utilisons la bibliothèque [`samlify`](https://www.npmjs.com/package/samlify) pour implémenter SAML.
+
+```typescript
+import * as validator from "@authenio/samlify-node-xmllint"
+saml.setSchemaValidator(validator)
+```
+
+La bibliothèque `samlify` s'attend à ce qu'un paquet valide que le XML est correct, signé avec la clé publique attendue, etc. Nous utilisons [`@authenio/samlify-node-xmllint`](https://www.npmjs.com/package/@authenio/samlify-node-xmllint) à cette fin.
+
+```typescript
+const express = (await import("express")).default
+const spRouter = express.Router()
+const app = express()
+```
+
+Un [`Router`](https://expressjs.com/en/5x/api.html#router) [`express`](https://expressjs.com/) est un « mini site web » qui peut être monté à l'intérieur d'un site web. Dans ce cas, nous l'utilisons pour regrouper toutes les définitions du fournisseur de services.
+
+```typescript
+const spPrivateKey = fs.readFileSync("keys/saml-sp.pem").toString()
+
+const sp = saml.ServiceProvider({
+  privateKey: spPrivateKey,  
+  ...config.spPublicData
+})
+```
+
+La propre représentation du fournisseur de services est l'ensemble des données publiques et la clé privée qu'il utilise pour signer les informations.
+
+```typescript
+const idp = saml.IdentityProvider(config.idpPublicData);
+```
+
+Les données publiques contiennent tout ce que le fournisseur de services doit savoir sur le fournisseur d'identité.
+
+```typescript
+spRouter.get(`/metadata`, 
+  (req, res) => res.header("Content-Type", "text/xml").send(sp.getMetadata())
+)
+```
+
+Pour permettre l'interopérabilité avec d'autres composants SAML, les fournisseurs de services et d'identité doivent rendre leurs données publiques (appelées métadonnées) disponibles au format XML dans `/metadata`.
+
+```typescript
+spRouter.post(`/assertion`,
+```
+
+C'est la page à laquelle le navigateur accède pour s'identifier. L'assertion inclut l'identifiant de l'utilisateur (ici, nous utilisons l'adresse e-mail) et peut inclure des attributs supplémentaires. C'est le gestionnaire de l'étape 7 du diagramme de séquence ci-dessus.
+
+```typescript
+  async (req, res) => {
+    // console.log(`Réponse SAML :\n${Buffer.from(req.body.SAMLResponse, 'base64').toString('utf-8')}`)
+```
+
+Vous pouvez utiliser la commande commentée pour voir les données XML fournies dans l'assertion. Il est [encodé en base64](https://en.wikipedia.org/wiki/Base64).
+
+```typescript
+    try {
+      const loginResponse = await sp.parseLoginResponse(idp, 'post', req);
+```
+
+Analysez la demande de connexion provenant du serveur d'identité.
+
+```typescript
+      res.send(`
+        <html>
+          <body>
+            <h2>Bonjour ${loginResponse.extract.nameID}</h2>
+          </body>
+        </html>
+      `)
+      res.send();
+```
+
+Envoyez une réponse HTML, juste pour montrer à l'utilisateur que nous avons bien reçu la connexion.
+
+```typescript
+    } catch (err) {
+      console.error('Erreur lors du traitement de la réponse SAML :', err);
+      res.status(400).send('L\'authentification SAML a échoué');
+    }
+  }
+)
+```
+
+Informez l'utilisateur en cas d'échec.
+
+```typescript
+spRouter.get('/login',
+```
+
+Créez une demande de connexion lorsque le navigateur tente d'accéder à cette page. C'est le gestionnaire de l'étape 1 du diagramme de séquence ci-dessus.
+
+```typescript
+  async (req, res) => {
+    const loginRequest = await sp.createLoginRequest(idp, "post")
+```
+
+Obtenez les informations pour poster une demande de connexion.
+
+```typescript
+    res.send(`
+      <html>
+        <body>
+          <script>
+            window.onload = function () { document.forms[0].submit(); }            
+          </script>
+```
+
+Cette page soumet le formulaire (voir ci-dessous) automatiquement. De cette façon, l'utilisateur n'a rien à faire pour être redirigé. C'est l'étape 2 du diagramme de séquence ci-dessus.
+
+```typescript
+          <form method="post" action="${loginRequest.entityEndpoint}">
+```
+
+Faites une requête POST à `loginRequest.entityEndpoint` (l'URL du point de terminaison du fournisseur d'identité).
+
+```typescript
+            <input type="hidden" name="${loginRequest.type}" value="${loginRequest.context}" />
+```
+
+Le nom de l'entrée est `loginRequest.type` (`SAMLRequest`). Le contenu de ce champ est `loginRequest.context`, qui est à nouveau du XML encodé en base64.
+
+```typescript
+          </form>
+        </body>
+      </html>
+    `)    
+  }
+)
+
+app.use(express.urlencoded({extended: true}))
+```
+
+[Ce middleware](https://expressjs.com/en/5x/api.html#express.urlencoded) lit le corps de la [requête HTTP](https://www.tutorialspoint.com/http/http_requests.htm). Par défaut, express l'ignore, car la plupart des requêtes ne le nécessitent pas. Nous en avons besoin car POST utilise le corps de la requête.
+
+```typescript
+app.use(`/${config.spDir}`, spRouter)
+```
+
+Montez le routeur dans le répertoire du fournisseur de services (`/sp`).
+
+```typescript
+app.get("/", (req, res) => {
+  res.send(`
+    <html>
+      <body>
+        <button onClick="document.location.href='${config.spUrl}/login'">
+           Cliquez ici pour vous connecter
+        </button>
+      </body>
+    </html>
+  `)
+})
+```
+
+Si un navigateur tente d'accéder au répertoire racine, fournissez-lui un lien vers la page de connexion.
+
+```typescript
+app.listen(config.spPort, () => {
+  console.log(`le fournisseur de services fonctionne sur http://${config.spHostname}:${config.spPort}`)
+})
+```
+
+Écoutez le `spPort` avec cette application express.
+
+#### src/idp.mts
+
+C'est le fournisseur d'identité. Il est très similaire au fournisseur de services, les explications ci-dessous concernent les parties qui sont différentes.
+
+```typescript
+const xmlParser = new (await import("fast-xml-parser")).XMLParser(
+  {
+    ignoreAttributes: false, // Préserver les attributs
+    attributeNamePrefix: "@_", // Préfixe pour les attributs
+  }
+)
+```
+
+Nous devons lire et comprendre la requête XML que nous recevons du fournisseur de services.
+
+```typescript
+const getLoginPage = requestId => `
+```
+
+Cette fonction crée la page avec le formulaire auto-soumis qui est retourné à l'étape 4 du diagramme de séquence ci-dessus.
+
+```typescript
+<html>
+  <head>
+    <title>Page de connexion</title>
+  </head>
+  <body>
+    <h2>Page de connexion</h2>
+    <form method="post" action="./loginSubmitted">
+      <input type="hidden" name="requestId" value="${requestId}" />
+      Adresse e-mail : <input name="email" />
+      <br />
+      <button type="Submit">
+        Se connecter au fournisseur de services
+      </button>
+```
+
+Nous envoyons deux champs au fournisseur de services :
+
+1. Le `requestId` auquel nous répondons.
+2. L'identifiant de l'utilisateur (nous utilisons pour l'instant l'adresse e-mail fournie par l'utilisateur).
+
+```typescript
+    </form>
+  </body>
+</html>
+
+const idpRouter = express.Router()
+
+idpRouter.post("/loginSubmitted", async (req, res) => {
+  const loginResponse = await idp.createLoginResponse(
+```
+
+C'est le gestionnaire de l'étape 5 du diagramme de séquence ci-dessus. [`idp.createLoginResponse`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L73-L125) crée la réponse de connexion.
+
+```typescript
+    sp, 
+    {
+      authnContextClassRef: 'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+      audience: sp.entityID,
+```
+
+L'audience est le fournisseur de services.
+
+```typescript
+      extract: {
+        request: {
+          id: req.body.requestId
+        }
+      },
+```
+
+Informations extraites de la requête. Le seul paramètre qui nous intéresse dans la requête est le requestId, qui permet au fournisseur de services de faire correspondre les requêtes et leurs réponses.
+
+```typescript
+      signingKey: { privateKey: idpPrivateKey, publicKey: config.idpCert }  // Assurer la signature
+```
+
+Nous avons besoin de `signingKey` pour avoir les données nécessaires à la signature de la réponse. Le fournisseur de services ne fait pas confiance aux requêtes non signées.
+
+```typescript
+    },
+    "post",
+    {
+      email: req.body.email
+```
+
+C'est le champ contenant les informations de l'utilisateur que nous renvoyons au fournisseur de services.
+
+```typescript
+    }
+  );
+
+  res.send(`
+    <html>
+      <body>
+        <script>
+          window.onload = function () { document.forms[0].submit(); }
+        </script>
+        
+        <form method="post" action="${loginResponse.entityEndpoint}">
+          <input type="hidden" name="${loginResponse.type}" value="${loginResponse.context}" />
+        </form>
+      </body>
+    </html>
+  `)
+})
+```
+
+Encore une fois, utilisez un formulaire auto-soumis. C'est l'étape 6 du diagramme de séquence ci-dessus.
+
+```typescript
+
+// Point de terminaison IdP pour les requêtes de connexion
+idpRouter.post(`/login`,
+```
+
+C'est le point de terminaison qui reçoit une demande de connexion du fournisseur de services. C'est le gestionnaire de l'étape 3 du diagramme de séquence ci-dessus.
+
+```typescript
+  async (req, res) => {
+    try {
+      // Solution de contournement car je n'ai pas réussi à faire fonctionner parseLoginRequest.
+      // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+      const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+      res.send(getLoginPage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+```
+
+Nous devrions pouvoir utiliser [`idp.parseLoginRequest`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L127-L144) pour lire l'ID de la demande d'authentification. Cependant, je n'ai pas réussi à le faire fonctionner et cela ne valait pas la peine de passer beaucoup de temps dessus, alors j'utilise simplement un [analyseur XML générique](https://www.npmjs.com/package/fast-xml-parser). L'information dont nous avons besoin est l'attribut `ID` à l'intérieur de la balise `<samlp:AuthnRequest>`, qui se trouve au niveau supérieur du XML.
+
+## Utilisation des signatures Ethereum
+
+Maintenant que nous pouvons envoyer une identité d'utilisateur au fournisseur de services, la prochaine étape est d'obtenir l'identité de l'utilisateur de manière fiable. Viem nous permet de simplement demander au portefeuille l'adresse de l'utilisateur, mais cela signifie demander l'information au navigateur. Nous ne contrôlons pas le navigateur, nous ne pouvons donc pas faire confiance automatiquement à la réponse que nous en recevons.
+
+Au lieu de cela, l'IdP va envoyer au navigateur une chaîne de caractères à signer. Si le portefeuille dans le navigateur signe cette chaîne, cela signifie qu'il s'agit bien de cette adresse (c'est-à-dire qu'il connaît la clé privée qui correspond à l'adresse).
+
+Pour voir cela en action, arrêtez l'IdP et le SP existants et exécutez ces commandes :
+
+```sh
+git checkout eth-signatures
+pnpm install
+pnpm start
+```
+
+Ensuite, naviguez vers [le SP](http://localhost:3000) et suivez les instructions.
+
+Notez qu'à ce stade, nous ne savons pas comment obtenir l'adresse e-mail à partir de l'adresse Ethereum, donc à la place nous signalons `<adresse ethereum>@bad.email.address` au SP.
+
+### Explication détaillée
+
+Les changements se situent aux étapes 4-5 du diagramme précédent.
+
+![SAML avec une signature Ethereum](./fig-05-saml-w-signature.png)
+
+Le seul fichier que nous avons modifié est `idp.mts`. Voici les parties modifiées.
+
+```typescript
+import { v4 as uuidv4 } from 'uuid'
+import { verifyMessage } from 'viem'
+```
+
+Nous avons besoin de ces deux bibliothèques supplémentaires. Nous utilisons [`uuid`](https://www.npmjs.com/package/uuid) pour créer la valeur [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce). La valeur elle-même n'a pas d'importance, seulement le fait qu'elle n'est utilisée qu'une seule fois.
+
+La bibliothèque [`viem`](https://viem.sh/) nous permet d'utiliser les définitions d'Ethereum. Ici, nous en avons besoin pour vérifier que la signature est bien valide.
+
+```typescript
+const loginPrompt = "Pour accéder au fournisseur de services, signez ce nonce : "
+```
+
+Le portefeuille demande à l'utilisateur la permission de signer le message. Un message qui n'est qu'un nonce pourrait dérouter les utilisateurs, c'est pourquoi nous incluons cette invite.
+
+```typescript
+// Conserver les requestIDs ici
+let nonces = {}
+```
+
+Nous avons besoin des informations de la requête pour pouvoir y répondre. Nous pourrions l'envoyer avec la requête (étape 4) et la recevoir en retour (étape 5). Cependant, nous ne pouvons pas faire confiance aux informations que nous recevons du navigateur, qui est sous le contrôle d'un utilisateur potentiellement hostile. Il est donc préférable de le stocker ici, avec le nonce comme clé.
+
+Notez que nous le faisons ici en tant que variable par souci de simplicité. Cependant, cela présente plusieurs inconvénients :
+
+- Nous sommes vulnérables à une attaque par déni de service. Un utilisateur malveillant pourrait tenter de se connecter plusieurs fois, remplissant ainsi notre mémoire.
+- Si le processus IdP doit être redémarré, nous perdons les valeurs existantes.
+- Nous ne pouvons pas répartir la charge sur plusieurs processus, car chacun aurait sa propre variable.
+
+Sur un système de production, nous utiliserions une base de données et mettrions en œuvre un mécanisme d'expiration.
+
+```typescript
+const getSignaturePage = requestId => {
+  const nonce = uuidv4()
+  nonces[nonce] = requestId
+```
+
+Créez un nonce et stockez le `requestId` pour une utilisation future.
+
+```typescript
+  return `
+<html>
+  <head>
+    <script type="module">
+```
+
+Ce JavaScript s'exécute automatiquement lorsque la page est chargée.
+
+```typescript
+      import { createWalletClient, custom, getAddress } from 'https://esm.sh/viem'
+```
+
+Nous avons besoin de plusieurs fonctions de `viem`.
+
+```typescript
+      if (!window.ethereum) {
+          alert("Veuillez installer MetaMask ou un portefeuille compatible, puis recharger la page")
+      }
+```
+
+Nous ne pouvons travailler que s'il y a un portefeuille sur le navigateur.
+
+```typescript
+      const [account] = await window.ethereum.request({method: 'eth_requestAccounts'})
+```
+
+Demandez la liste des comptes au portefeuille (`window.ethereum`). Supposez qu'il y en a au moins un, et ne stockez que le premier.
+
+```typescript
+      const walletClient = createWalletClient({
+          account,
+          transport: custom(window.ethereum)
+      })
+```
+
+Créez un [client de portefeuille](https://viem.sh/docs/clients/wallet) pour interagir avec le portefeuille du navigateur.
+
+```typescript
+      window.goodSignature = () => {
+        walletClient.signMessage({
+            message: "${loginPrompt}${nonce}"
+```
+
+Demandez à l'utilisateur de signer un message. Comme tout ce HTML se trouve dans une [chaîne de caractères de modèle](https://viem.sh/docs/clients/wallet), nous pouvons utiliser des variables définies dans le processus idp. C'est l'étape 4.5 du diagramme de séquence.
+
+```typescript
+        }).then(signature => {
+            const path= "/${config.idpDir}/signature/${nonce}/" + account + "/" + signature
+            window.location.href = path
+        })
+      }
+```
+
+Redirigez vers `/idp/signature/<nonce>/<address>/<signature>`. C'est l'étape 5 du diagramme de séquence.
+
+```typescript
+      window.badSignature = () => {
+        const path= "/${config.idpDir}/signature/${nonce}/" + 
+          getAddress("0x" + "BAD060A7".padEnd(40, "0")) + 
+          "/0x" + "BAD0516".padStart(130, "0")
+        window.location.href = path
+      }
+```
+
+La signature est renvoyée par le navigateur, qui est potentiellement malveillant (rien ne vous empêche d'ouvrir simplement `http://localhost:3001/idp/signature/bad-nonce/bad-address/bad-signature` dans le navigateur). Par conséquent, il est important de vérifier que le processus IdP gère correctement les mauvaises signatures.
+
+```typescript
+    </script>
+  </head>
+  <body>
+    <h2>Veuillez signer</h2>
+    <button onClick="window.goodSignature()">
+      Soumettre une bonne signature (valide)
+    </button>
+    <br/>
+    <button onClick="window.badSignature()">
+      Soumettre une mauvaise signature (invalide)
+    </button>
+  </body>
+</html>  
+`
+}
+```
+
+Le reste n'est que du HTML standard.
+
+```typescript
+idpRouter.get("/signature/:nonce/:account/:signature", async (req, res) => {
+```
+
+C'est le gestionnaire de l'étape 5 du diagramme de séquence.
+
+```typescript
+  const requestId = nonces[req.params.nonce]
+  if (requestId === undefined) {
+    res.send("Mauvais nonce")
+    return ;
+  }  
+  
+  nonces[req.params.nonce] = undefined
+```
+
+Obtenez l'ID de la requête et supprimez le nonce de `nonces` pour vous assurer qu'il ne peut pas être réutilisé.
+
+```typescript
+  try {
+```
+
+Parce qu'il y a tant de façons pour que la signature soit invalide, nous l'enveloppons dans un `try ...` bloc `catch` pour intercepter toute erreur levée.
+
+```typescript
+    const validSignature = await verifyMessage({
+      address: req.params.account,
+      message: `${loginPrompt}${req.params.nonce}`,
+      signature: req.params.signature
+    })
+```
+
+Utilisez [`verifyMessage`](https://viem.sh/docs/actions/public/verifyMessage#verifymessage) pour implémenter l'étape 5.5 du diagramme de séquence.
+
+```typescript
+    if (!validSignature)
+      throw("Mauvaise signature")
+  } catch (err) {
+    res.send("Erreur :" + err)
+    return ;
+  }
+```
+
+Le reste du gestionnaire est équivalent à ce que nous avons fait dans le gestionnaire `/loginSubmitted` précédemment, à l'exception d'un petit changement.
+
+```typescript
+  const loginResponse = await idp.createLoginResponse(
+      .
+      .
+      .
+    {
+      email: req.params.account + "@bad.email.address"
+    }
+  );
+```
+
+Nous n'avons pas l'adresse e-mail réelle (nous l'obtiendrons dans la section suivante), donc pour l'instant nous retournons l'adresse Ethereum et la marquons clairement comme n'étant pas une adresse e-mail.
+
+```typescript
+// Point de terminaison IdP pour les requêtes de connexion
+idpRouter.post(`/login`,
+  async (req, res) => {
+    try {
+      // Solution de contournement car je n'ai pas réussi à faire fonctionner parseLoginRequest.
+      // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+      const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+      res.send(getSignaturePage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+    } catch (err) {
+      console.error('Erreur lors du traitement de la réponse SAML :', err);
+      res.status(400).send('L\'authentification SAML a échoué');
+    }
+  }
+)
+```
+
+Au lieu de `getLoginPage`, utilisez maintenant `getSignaturePage` dans le gestionnaire de l'étape 3.
+
+## Obtenir l'adresse e-mail
+
+La prochaine étape consiste à obtenir l'adresse e-mail, l'identifiant demandé par le fournisseur de services. Pour ce faire, nous utilisons le [service d'attestation Ethereum (EAS)](https://attest.org/).
+
+Le moyen le plus simple d'obtenir des attestations est d'utiliser [l'API GraphQL](https://docs.attest.org/docs/developer-tools/api). Nous utilisons cette requête :
+
+```
+query GetAttestationsByRecipient {
+  attestations(
+    where: { 
+      recipient: { equals: "${getAddress(ethAddr)}" }
+      schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+    }
+    take: 1
+  ) { 
+    data
+    id
+    attester
+  }
+}
+```
+
+Ce [`schemaId`](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) ne comprend qu'une adresse e-mail. Cette requête demande des attestations de ce schéma. Le sujet de l'attestation est appelé le `destinataire`. Il s'agit toujours d'une adresse Ethereum.
+
+Attention : la manière dont nous obtenons les attestations ici présente deux problèmes de sécurité.
+
+- Nous nous rendons au point de terminaison de l'API, `https://optimism.easscan.org/graphql`, qui est un composant centralisé. Nous pouvons obtenir l'attribut `id` et ensuite faire une recherche sur la chaîne pour vérifier qu'une attestation est réelle, mais le point de terminaison de l'API peut toujours censurer les attestations en ne nous informant pas à leur sujet.
+
+  Ce problème n'est pas impossible à résoudre, nous pourrions exécuter notre propre point de terminaison GraphQL et obtenir les attestations à partir des journaux de la chaîne, mais c'est excessif pour nos besoins.
+
+- Nous ne regardons pas l'identité de l'attestateur. N'importe qui peut nous fournir de fausses informations. Dans une implémentation réelle, nous aurions un ensemble d'attestateurs de confiance et ne regarderions que leurs attestations.
+
+Pour voir cela en action, arrêtez l'IdP et le SP existants et exécutez ces commandes :
+
+```sh
+git checkout email-address
+pnpm install
+pnpm start
+```
+
+Fournissez ensuite votre adresse e-mail. Vous avez deux façons de le faire :
+
+- Importez un portefeuille à l'aide d'une clé privée et utilisez la clé privée de test `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80`.
+
+- Ajoutez une attestation pour votre propre adresse e-mail :
+
+  1. Naviguez vers [le schéma dans l'explorateur d'attestation](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977).
+
+  2. Cliquez sur **Attester avec le schéma**.
+
+  3. Entrez votre adresse Ethereum comme destinataire, votre adresse e-mail comme adresse e-mail, et sélectionnez **Sur la chaîne**. Cliquez ensuite sur **Faire une attestation**.
+
+  4. Approuvez la transaction dans votre portefeuille. Vous aurez besoin de quelques ETH sur [la blockchain Optimism](https://app.optimism.io/bridge/deposit) pour payer le gaz.
+
+Dans tous les cas, après avoir fait cela, naviguez vers [http://localhost:3000](http://localhost:3000) et suivez les instructions. Si vous avez importé la clé privée de test, l'e-mail que vous recevez est `test_addr_0@example.com`. Si vous avez utilisé votre propre adresse, ce devrait être celle que vous avez attestée.
+
+### Explication détaillée
+
+![Passer de l'adresse Ethereum à l'e-mail](./fig-06-saml-sig-n-email.png)
+
+Les nouvelles étapes sont la communication GraphQL, étapes 5.6 et 5.7.
+
+Encore une fois, voici les parties modifiées de `idp.mts`.
+
+```typescript
+import { GraphQLClient } from 'graphql-request'
+import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk'
+```
+
+Importez les bibliothèques dont nous avons besoin.
+
+```typescript
+const graphqlEndpointUrl = "https://optimism.easscan.org/graphql"
+```
+
+Il existe [un point de terminaison distinct pour chaque blockchain](https://docs.attest.org/docs/developer-tools/api).
+
+```typescript
+const graphqlClient = new GraphQLClient(graphqlEndpointUrl, { fetch })
+```
+
+Créez un nouveau client `GraphQLClient` que nous pouvons utiliser pour interroger le point de terminaison.
+
+```typescript
+const graphqlSchema = 'string emailAddress'
+const graphqlEncoder = new SchemaEncoder(graphqlSchema)
+```
+
+GraphQL ne nous donne qu'un objet de données opaque avec des octets. Pour le comprendre, nous avons besoin du schéma.
+
+```typescript
+const ethereumAddressToEmail = async ethAddr => {
+```
+
+Une fonction pour passer d'une adresse Ethereum à une adresse e-mail.
+
+```typescript
+  const query = `
+    query GetAttestationsByRecipient {
+```
+
+C'est une requête GraphQL.
+
+```typescript
+      attestations(
+```
+
+Nous recherchons des attestations.
+
+```typescript
+        where: { 
+          recipient: { equals: "${getAddress(ethAddr)}" }
+          schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+        }
+```
+
+Les attestations que nous voulons sont celles de notre schéma, où le destinataire est `getAddress(ethAddr)`. La fonction [`getAddress`](https://viem.sh/docs/utilities/getAddress#getaddress) s'assure que notre adresse a la bonne [somme de contrôle](https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md). C'est nécessaire car GraphQL est sensible à la casse. "0xBAD060A7", "0xBad060A7", et "0xbad060a7" sont des valeurs différentes.
+
+```typescript
+        take: 1
+```
+
+Quel que soit le nombre d'attestations que nous trouvons, nous ne voulons que la première.
+
+```typescript
+      ) {
+        data
+        id
+        attester
+      }
+    }`
+```
+
+Les champs que nous voulons recevoir.
+
+- `attester` : l'adresse qui a soumis l'attestation. Normalement, cela est utilisé pour décider de faire confiance ou non à l'attestation.
+- `id` : l'ID de l'attestation. Vous pouvez utiliser cette valeur pour [lire l'attestation sur la chaîne](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000021?tab=read_proxy&source_address=0x4E0275Ea5a89e7a3c1B58411379D1a0eDdc5b088#0xa3112a64) afin de vérifier que les informations de la requête GraphQL sont correctes.
+- `data` : les données du schéma (dans ce cas, l'adresse e-mail).
+
+```typescript
+  const queryResult = await graphqlClient.request(query)
+
+  if (queryResult.attestations.length == 0)
+    return "no_address@available.is"
+```
+
+S'il n'y a pas d'attestation, retournez une valeur qui est manifestement incorrecte, mais qui semblerait valide pour le fournisseur de services.
+
+```typescript
+  const attestationDataFields = graphqlEncoder.decodeData(queryResult.attestations[0].data)
+  return attestationDataFields[0].value.value
+}
+```
+
+S'il y a une valeur, utilisez `decodeData` pour décoder les données. Nous n'avons pas besoin des métadonnées qu'il fournit, juste de la valeur elle-même.
+
+```typescript
+  const loginResponse = await idp.createLoginResponse(
+    sp, 
+    {
+      .
+      .
+      .
+    },
+    "post",
+    {
+      email: await ethereumAddressToEmail(req.params.account)
+    }
+  );
+```
+
+Utilisez la nouvelle fonction pour obtenir l'adresse e-mail.
+
+## Qu'en est-il de la décentralisation ?
+
+Dans cette configuration, les utilisateurs ne peuvent pas prétendre être quelqu'un qu'ils ne sont pas, tant que nous nous appuyons sur des attestateurs dignes de confiance pour la correspondance entre l'adresse Ethereum et l'adresse e-mail. Cependant, notre fournisseur d'identité est toujours un composant centralisé. Quiconque possède la clé privée du fournisseur d'identité peut envoyer de fausses informations au fournisseur de services.
+
+Il pourrait y avoir une solution utilisant le [calcul multipartite sécurisé (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation). J'espère en parler dans un futur tutoriel.
+
+## Conclusion
+
+L'adoption d'une norme de connexion, comme les signatures Ethereum, est confrontée au problème de l'œuf et de la poule. Les fournisseurs de services veulent s'adresser au marché le plus large possible. Les utilisateurs veulent pouvoir accéder aux services sans avoir à se soucier de la prise en charge de leur norme de connexion.
+La création d'adaptateurs, tels qu'un IdP Ethereum, peut nous aider à surmonter cet obstacle.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/fr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
index d2b4a64b74c..9e0b04c6fed 100644
--- a/public/content/translations/fr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
+++ b/public/content/translations/fr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
@@ -1,60 +1,62 @@
 ---
-title: Bien débuter avec le développement Ethereum
-description: "Ceci est un guide permettant aux débutants de s'initier avec le développement Ethereum. Nous allons vous guider de la création d'un point d'accès à l'API à l'écriture de votre premier script Web3, en passant par celle d'une requête en ligne de commande ! Aucune expérience préalable dans le développement de blockchain n'est requise !"
+title: "Bien débuter avec le développement Ethereum"
+description: "Ceci est un guide pour débutants pour se lancer dans le développement sur Ethereum. Nous allons vous guider de la création d'un point d'accès à l'API à l'écriture de votre premier script Web3, en passant par celle d'une requête en ligne de commande ! Aucune expérience préalable dans le développement de blockchain n'est requise !"
 author: "Elan Halpern"
 tags:
-  - "javascript"
-  - "ethers.js"
-  - "nœuds"
-  - "requêtes"
-  - "alchemy"
+  [
+    "JavaScript",
+    "ethers.js",
+    "nœuds",
+    "requêtes",
+    "Alchemy"
+  ]
 skill: beginner
 lang: fr
 published: 2020-10-30
-source: Moyen
+source: Medium
 sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f
 ---
 
-![Logos Ethereum et Alchemy](./ethereum-alchemy.png)
+![Logos d'Ethereum et d'Alchemy](./ethereum-alchemy.png)
 
-Ceci est un guide pour les débutants qui souhaitent se lancer dans le développement Ethereum. Pour ce tutoriel, nous allons utiliser [Alchemy](https://alchemyapi.io/), la principale plateforme de développement blockchain qui sert des millions d'utilisateurs parmi 70 % des principales applications blockchain, dont Maker, 0x, MyEtherWallet, Dharma et Kyber. Alchemy va nous permettre d'accéder à un point de terminaison API sur la chaîne Ethereum afin que nous puissions lire et écrire des transactions.
+Ceci est un guide pour débutants pour se lancer dans le développement sur Ethereum. Pour ce tutoriel, nous utiliserons [Alchemy](https://alchemyapi.io/), la principale plateforme de développement blockchain qui alimente des millions d'utilisateurs issus de 70 % des meilleures applications blockchain, notamment Maker, 0x, MyEtherWallet, Dharma et Kyber. Alchemy nous donnera accès à un point de terminaison d'API sur la chaîne Ethereum afin que nous puissions lire et écrire des transactions.
 
-Nous vous guiderons à travers toutes les étapes, de votre inscription sur Alchemy à votre premier script Web3 ! Aucune expérience préalable dans le développement de blockchain n'est requise !
+Nous vous guiderons de l'inscription sur Alchemy à l'écriture de votre premier script Web3 ! Aucune expérience préalable dans le développement de blockchain n'est requise !
 
-## 1. Créez votre compte Alchemy gratuit {#sign-up-for-a-free-alchemy-account}
+## 1. Créez un compte Alchemy gratuit {#sign-up-for-a-free-alchemy-account}
 
-Il est très facile de créer un compte sur Alchemy. [Inscrivez-vous gratuitement ici](https://auth.alchemyapi.io/signup).
+Créer un compte sur Alchemy est facile, [inscrivez-vous gratuitement ici](https://auth.alchemy.com/).
 
 ## 2. Créer une application Alchemy {#create-an-alchemy-app}
 
-Pour communiquer avec la chaîne Ethereum et utiliser les services d'Alchemy, vous aurez besoin d'une clé d'API pour authentifier vos requêtes.
+Pour communiquer avec la chaîne Ethereum et utiliser les produits d'Alchemy, vous avez besoin d'une clé d'API pour authentifier vos requêtes.
 
-Vous pouvez [créer vos clés API depuis le tableau de bord](http://dashboard.alchemyapi.io/). Pour créer un nouvelle clé, cliquez sur « Créer une application » comme indiqué ci-dessous :
+Vous pouvez [créer des clés d'API depuis le tableau de bord](https://dashboard.alchemy.com/). Pour créer une nouvelle clé, naviguez vers « Créer une application » comme indiqué ci-dessous :
 
-Un grand merci à [_ShapeShift_](https://shapeshift.com/) _de nous laisser utiliser leur tableau de bord à titre d'exemple !_
+Remerciements spéciaux à [_ShapeShift_](https://shapeshift.com/) _de nous avoir permis de montrer leur tableau de bord !_
 
-![Tableau de bord Alchemy](./alchemy-dashboard.png)
+![Tableau de bord d'Alchemy](./alchemy-dashboard.png)
 
-Remplissez les détails sous « Créer une application » pour obtenir votre nouvelle clé. Vous pouvez également voir les applications que vous avez faites précédemment et celles faites par votre équipe ici. Tirez les clés existantes en cliquant sur « Voir la clé » pour n'importe quelle application.
+Remplissez les champs sous « Créer une application » pour obtenir votre nouvelle clé. Vous pouvez également voir ici les applications que vous avez créées précédemment et celles créées par votre équipe. Récupérez les clés existantes en cliquant sur « Voir la clé » pour n'importe quelle application.
 
-![Créer une application avec Alchemy : capture d'écran](./create-app.png)
+![Capture d'écran de la création d'application avec Alchemy](./create-app.png)
 
-Vous pouvez également extraire les clés API existantes en passant la souris sur « Apps » et en en sélectionnant une. Vous pouvez « Voir la clé » ici, ainsi que « Modifier l'application » pour mettre des domaines spécifiques sur la liste blanche, voir plusieurs outils de développement et consulter les analyses.
+Vous pouvez également récupérer des clés d'API existantes en passant le curseur sur « Apps » et en sélectionnant une. Vous pouvez « Voir la clé » ici, ainsi que « Modifier l'application » pour ajouter des domaines spécifiques à la liste blanche, voir plusieurs outils de développement et consulter les analyses.
 
-![Gif montrant à un utilisateur comment tirer des clés d'API](./pull-api-keys.gif)
+![GIF montrant comment un utilisateur peut récupérer des clés d'API](./pull-api-keys.gif)
 
-## 3. Faire une demande en ligne de commande {#make-a-request-from-the-command-line}
+## 3. Faire une requête depuis la ligne de commande {#make-a-request-from-the-command-line}
 
 Interagissez avec la blockchain Ethereum via Alchemy en utilisant JSON-RPC et curl.
 
-Pour les demandes manuelles, nous recommandons d'interagir avec les `JSON-RPC` via des demandes `POST`. Il suffit de passer l'en-tête `Content-Type : application/json` et votre requête comme corps `POST` avec les champs suivants :
+Pour les requêtes manuelles, nous recommandons d'interagir avec le `JSON-RPC` via des requêtes `POST`. Il suffit de transmettre l'en-tête `Content-Type: application/json` et votre requête en tant que corps `POST` avec les champs suivants :
 
-- `jsonrpc` : La version de JSON-RPC - actuellement, seule `2.0` est supportée.
-- `méthode` : La méthode de l'API de l'ETH. [Voir la référence API.](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc)
-- `params` : Une liste de paramètres à transmettre à la méthode.
-- `id` : L'ID de votre demande. Sera retourné par la réponse afin que vous puissiez garder la trace de la demande à laquelle une réponse appartient.
+- `jsonrpc` : la version JSON-RPC (actuellement, seule la version `2.0` est prise en charge).
+- `method` : la méthode de l'API ETH. [Voir la référence de l'API.](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc)
+- `params` : une liste de paramètres à transmettre à la méthode.
+- `id` : l'ID de votre requête. Cet ID sera renvoyé dans la réponse afin que vous puissiez savoir à quelle requête elle correspond.
 
-Voici un exemple que vous pouvez exécuter à partir de la ligne de commande pour obtenir le prix actuel du gaz :
+Voici un exemple que vous pouvez exécuter depuis la ligne de commande pour récupérer le prix actuel du gaz :
 
 ```bash
 curl https://eth-mainnet.alchemyapi.io/v2/demo \
@@ -63,7 +65,7 @@ curl https://eth-mainnet.alchemyapi.io/v2/demo \
 -d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}'
 ```
 
-_**REMARQUE :** Remplacez [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) par votre propre clé API `https://eth-mainnet.alchemyapi.io/v2/**votre-cle-api`._
+_**NOTE :** Remplacez [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) par votre propre clé d'API `https://eth-mainnet.alchemyapi.io/v2/**votre-clé-api`._
 
 **Résultats :**
 
@@ -73,13 +75,13 @@ _**REMARQUE :** Remplacez [https://eth-mainnet.alchemyapi.io/v2/demo](https://et
 
 ## 4. Configurer votre client Web3 {#set-up-your-web3-client}
 
-**Si vous avez un client existant,** changez votre URL actuelle de fournisseur de nœuds en une URL Alchemy avec votre clé API : `"https://eth-mainnet.alchemyapi.io/v2/your-api-key"`
+**Si vous avez un client existant,** remplacez l'URL de votre fournisseur de nœud actuel par une URL Alchemy avec votre clé d'API : `"https://eth-mainnet.alchemyapi.io/v2/votre-clé-api"`
 
-**_NOTE :_** Les scripts ci-dessous doivent être exécutés dans un **contexte de nœud** ou **sauvegardé dans un fichier**, et non exécutés en ligne de commande. Si vous n'avez pas encore installé Node ou npm, consultez ce rapide [guide d'installation pour macs](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs).
+**_NOTE :** Les scripts ci-dessous doivent être exécutés dans un **contexte de nœud** ou **enregistrés dans un fichier**, et non depuis la ligne de commande. Si Node ou npm ne sont pas déjà installés, consultez ce [guide d'installation rapide pour Mac](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs).
 
-De nombreuses [bibliothèques Web3](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) peuvent être intégrées à Alchemy, cependant, nous recommandons d'utiliser [Alchemy Web3](https://docs.alchemy.com/reference/api-overview), un remplacement drop-in pour Web3.js, construit et configuré pour fonctionner de façon transparente avec Alchemy. Cela présente de nombreux avantages, comme les tentatives automatiques et la prise en charge robuste de WebSocket.
+Il existe de nombreuses [bibliothèques Web3](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) que vous pouvez intégrer à Alchemy. Cependant, nous vous recommandons d'utiliser [Alchemy Web3](https://docs.alchemy.com/reference/api-overview), un remplacement direct de web3.js, conçu et configuré pour fonctionner de manière transparente avec Alchemy. Cela offre de multiples avantages, tels que des tentatives de reconnexion automatiques et une prise en charge robuste des WebSockets.
 
-Pour installer AlchemyWeb3.js, **accédez au répertoire de votre projet** et exécutez :
+Pour installer AlchemyWeb3.js, **accédez au répertoire de votre projet** et exécutez la commande suivante :
 
 **Avec Yarn :**
 
@@ -93,62 +95,62 @@ yarn add @alch/alchemy-web3
 npm install @alch/alchemy-web3
 ```
 
-Pour interagir avec l'infrastructure de nœuds d'Alchemy, exécutez en NodeJS ou ajoutez ceci à un fichier JavaScript :
+Pour interagir avec l'infrastructure de nœuds d'Alchemy, exécutez la commande dans NodeJS ou ajoutez ce qui suit à un fichier JavaScript :
 
 ```js
 const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
 const web3 = createAlchemyWeb3(
-  "https://eth-mainnet.alchemyapi.io/v2/your-api-key"
+  "https://eth-mainnet.alchemyapi.io/v2/votre-clé-api"
 )
 ```
 
 ## 5. Écrivez votre premier script Web3 ! {#write-your-first-web3-script}
 
-Maintenant pour nous salir les mains avec un peu de programmation Web3, nous allons écrire un script simple qui affiche le dernier numéro de bloc du réseau principal Ethereum.
+Maintenant, pour mettre la main à la pâte avec un peu de programmation web3, nous allons écrire un script simple qui affiche le dernier numéro de bloc du réseau principal Ethereum.
 
-**1. Si vous ne l'avez pas déjà fait, dans votre terminal, créez un nouveau répertoire de projet et cd dedans :**
+\*\*1. **Si ce n'est pas déjà fait, créez un nouveau répertoire de projet dans votre terminal et accédez-y avec la commande `cd` :**
 
 ```
 mkdir web3-example
 cd web3-example
 ```
 
-**2. Installez la dépendance Alchemy Web3 (ou toute dépendance Web3) dans votre projet si vous ne l'avez pas déjà fait :**
+\*\*2. **Installez la dépendance Alchemy Web3 (ou toute autre dépendance Web3) dans votre projet si ce n'est pas déjà fait :**
 
 ```
 npm install @alch/alchemy-web3
 ```
 
-**3. Créez un fichier nommé `index.js` et ajoutez le contenu suivant :**
+\*\*3. **Créez un fichier nommé `index.js` et ajoutez-y le contenu suivant :**
 
-> Vous devrez remplacer `demo` avec votre clé API Alchemy HTTP.
+> Vous devrez à terme remplacer `demo` par votre clé d'API HTTP Alchemy.
 
 ```js
 async function main() {
   const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
   const web3 = createAlchemyWeb3("https://eth-mainnet.alchemyapi.io/v2/demo")
   const blockNumber = await web3.eth.getBlockNumber()
-  console.log("The latest block number is " + blockNumber)
+  console.log("Le dernier numéro de bloc est " + blockNumber)
 }
 main()
 ```
 
-Vous n'êtes pas familiarisé avec l'asynchronisme ? Consultez ce [Medium post](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c).
+Vous n'êtes pas familier avec le concept d'asynchronisme ? Consultez cet [article de Medium](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c).
 
-**4. Exécutez-le dans votre terminal en utilisant le nœud**
+\*\*4. **Exécutez-le dans votre terminal à l'aide de node :**
 
 ```
 node index.js
 ```
 
-**5. Vous devriez maintenant voir apparaître le dernier numéro de bloc dans votre console !**
+\*\*5. **Vous devriez maintenant voir le dernier numéro de bloc s'afficher dans votre console !**
 
 ```
-The latest block number is 11043912
+Le dernier numéro de bloc est 11043912
 ```
 
-**Wahou ! Félicitations ! Vous venez de rédiger votre premier script Web3 avec Alchemy 🎉**
+**Bravo !** Félicitations ! **Vous venez d'écrire votre premier script web3 avec Alchemy 🎉**
 
-Vous ne savez pas quoi faire ensuite ? Essayez de déployer votre premier contrat intelligent et mettez la main à la pâte avec un peu de programmation Solidity dans notre [Guide de contrats intelligents « Hello World »](https://docs.alchemyapi.io/tutorials/hello-world-smart-contract), ou testez vos connaissances avec le [Tableau de bord de démonstration](https://docs.alchemyapi.io/tutorials/demo-app) !
+Vous n'êtes pas sûr de la prochaine étape ? Essayez de déployer votre premier contrat intelligent et de vous familiariser avec la programmation Solidity dans notre [guide sur les contrats intelligents Hello World](https://www.alchemy.com/docs/hello-world-smart-contract), ou testez vos connaissances sur le tableau de bord avec l'[application de démonstration du tableau de bord](https://docs.alchemyapi.io/tutorials/demo-app) !
 
-_[S'inscrire gratuitement à Alchemy](https://auth.alchemyapi.io/signup), consulter notre [documentation](https://docs.alchemyapi.io/), et pour les dernières nouvelles, nous suivre sur [Twitter](https://twitter.com/AlchemyPlatform)_.
+_[Inscrivez-vous gratuitement sur Alchemy](https://auth.alchemy.com/), consultez notre [documentation](https://www.alchemy.com/docs/) et, pour connaître les dernières actualités, suivez-nous sur [Twitter](https://twitter.com/AlchemyPlatform)_.
diff --git a/public/content/translations/fr/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/fr/developers/tutorials/guide-to-smart-contract-security-tools/index.md
index f0f08208a73..b385a4e2140 100644
--- a/public/content/translations/fr/developers/tutorials/guide-to-smart-contract-security-tools/index.md
+++ b/public/content/translations/fr/developers/tutorials/guide-to-smart-contract-security-tools/index.md
@@ -1,105 +1,102 @@
 ---
-title: Un guide des outils de sécurité pour les contrats intelligents
-description: Un aperçu de trois différentes techniques de test et d'analyse de programme
+title: "Un guide des outils de sécurité pour les contrats intelligents"
+description: "Un aperçu de trois différentes techniques de test et d'analyse de programme"
 author: "Trailofbits"
 lang: fr
-tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "sécurité"
+tags: [ "Solidity", "contrats intelligents", "sécurité" ]
 skill: intermediate
 published: 2020-09-07
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis
 ---
 
-Nous allons utiliser trois techniques distinctes de test et d'analyse de programme :
+Nous allons utiliser trois techniques de test et d'analyse de programme distinctes :
 
-- **Analyse statique avec [Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/).** Tous les chemins du programme sont approximés et analysés en même temps, à travers différentes présentations du programme (ex. control-flow-graph)
+- **Analyse statique avec [Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/).** Tous les chemins du programme sont approchés et analysés en même temps, à travers différentes présentations du programme (p. ex., graphe de contrôle de flux)
 - **Fuzzing avec [Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/).** Le code est exécuté avec une génération pseudo-aléatoire de transactions. Le fuzzer tentera de trouver une séquence de transactions pour violer une propriété donnée.
 - **Exécution symbolique avec [Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/).** Une technique de vérification formelle qui traduit chaque chemin d'exécution en une formule mathématique, sur laquelle on pourra vérifier les contraintes.
 
-Chaque technique comporte ses avantages et ses inconvénients, et trouve son utilité dans des [situations spécifiques](#determining-security-properties) :
+Chaque technique a ses avantages et ses inconvénients, et sera utile dans des [cas spécifiques](#determining-security-properties) :
 
-| Technique          | Outil     | Utilisation                   | Rapidité  | Bogues manqués | Faux positifs |
-| ------------------ | --------- | ----------------------------- | --------- | -------------- | ------------- |
-| Analyse statique   | Slither   | CLI & scripts                 | secondes  | modérément     | faible        |
-| Fuzzing            | Echidna   | Propriétés Solidity           | minutes   | rarement       | aucun         |
-| Symbolic Execution | Manticore | Propriétés Solidity & scripts | en heures | aucun\*      | aucun         |
+| Technique            | Outil     | Utilisation                    | Rapidité  | Bogues manqués | Faux positifs |
+| -------------------- | --------- | ------------------------------ | --------- | -------------- | ------------- |
+| Analyse statique     | Slither   | CLI et scripts                 | secondes  | modéré         | faible        |
+| Fuzzing              | Echidna   | Propriétés Solidity            | minutes   | faible         | aucun         |
+| Exécution symbolique | Manticore | Propriétés Solidity et scripts | en heures | aucun\*        | aucun         |
 
-\* si tous les chemins sont analysés sans coupure
+\* si tous les chemins sont explorés sans expiration de délai
 
-**Slither** analyse les contrats en quelques secondes, cependant, une analyse statique peut conduire à de fausses alertes et sera moins appropriée pour des vérifications complexes (ex. vérifications arithmétiques). Exécutez Slither via l'API pour accéder aux détecteurs intégrés ou via l'API pour des vérifications définies par l'utilisateur.
+**Slither** analyse les contrats en quelques secondes. Cependant, l'analyse statique peut générer des faux positifs et sera moins adaptée aux vérifications complexes (p. ex., les vérifications arithmétiques). Exécutez Slither via l'API pour un accès en un clic aux détecteurs intégrés ou via l'API pour des vérifications définies par l'utilisateur.
 
-**Echidna** a besoin de travailler pendant plusieurs minutes et ne produira que de vrais positifs. Echidna vérifie les propriétés de sécurité fournies par les utilisateurs et écrites en Solidity. Il peut rater des bogues dans la mesure où il est basé sur une exploration aléatoire.
+**Echidna** doit s'exécuter pendant plusieurs minutes et ne produit que de vrais positifs. Echidna vérifie les propriétés de sécurité fournies par l'utilisateur, écrites en Solidity. Il peut passer à côté de bogues, car il est basé sur une exploration aléatoire.
 
-**Manticore** effectue l'analyse la plus poussée. Comme Echidna, Manticore vérifie les propriétés fournies par l'utilisateur. Il lui faudra plus de temps pour fonctionner, mais peut approuver la validité d'une propriété et ne signalera pas de fausses alertes.
+**Manticore** effectue l'analyse la plus poussée. Comme Echidna, Manticore vérifie les propriétés fournies par l'utilisateur. Son exécution prendra plus de temps, mais il peut prouver la validité d'une propriété et ne signalera pas de faux positifs.
 
-## Flux de travail conseillé {#suggested-workflow}
+## Flux de travail suggéré {#suggested-workflow}
 
-Commencez avec les détecteurs intégrés de Slither pour vous assurer qu'aucun bogue mineur n'est présent ou ne sera introduit plus tard. Utilisez Slither pour vérifier les propriétés liées aux héritages, aux dépendances variables et aux problèmes structurels. Au fur et à mesure que le code base grossit, utilisez Echidna pour tester des propriétés plus complexes de la machine d'état. Revisitez Slither pour développer des contrôles personnalisés pour les protections non présentes dans Solidity comme la protection contre le remplacement d'une fonction. Enfin, utiliser Manticore pour effectuer des vérifications ciblées de propriétés critiques de sécurité, par exemple des opérations arithmétiques.
+Commencez par les détecteurs intégrés de Slither pour vous assurer qu'aucun bogue simple n'est présent ou ne sera introduit ultérieurement. Utilisez Slither pour vérifier les propriétés liées à l'héritage, aux dépendances entre les variables et aux problèmes structurels. À mesure que la base de code s'agrandit, utilisez Echidna pour tester les propriétés plus complexes de la machine d'état. Revenez à Slither pour développer des vérifications personnalisées pour des protections non disponibles dans Solidity, comme la protection contre la redéfinition d'une fonction. Enfin, utilisez Manticore pour effectuer une vérification ciblée des propriétés de sécurité critiques, p. ex., les opérations arithmétiques.
 
-- Utilisez le CLI de Slither pour relever les problèmes courants
-- Utilisez Echidna pour tester les propriétés de sécurité de haut niveau dans votre contrat
+- Utilisez la CLI de Slither pour détecter les problèmes courants
+- Utilisez Echidna pour tester les propriétés de sécurité de haut niveau de votre contrat
 - Utilisez Slither pour écrire des vérifications statiques personnalisées
-- Utilisez Manticore pour vous assurer de façon approfondie des propriétés critiques de sécurité
+- Utilisez Manticore lorsque vous souhaitez une assurance approfondie des propriétés de sécurité critiques
 
-**Note sur les tests unitaires**. Les tests unitaires sont nécessaires pour construire des logiciels de haute qualité. Cependant, ces techniques ne sont pas les mieux adaptées pour trouver des failles de sécurité. Ils sont généralement utilisés pour tester les comportements positifs du code (c.-à-d. que le code fonctionne comme prévu dans un contexte normal), tandis que les défauts de sécurité tendent à résider dans des cas particuliers que les développeurs ne considéraient pas. Dans notre étude de dizaines d'examens sur la sécurité des contrats intelligents, [la couverture des tests unitaires n'a eu aucun effet sur le nombre ou la gravité des failles de sécurité](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/) que nous avons trouvés dans le code de notre client.
+**Remarque sur les tests unitaires**. Les tests unitaires sont nécessaires pour créer des logiciels de haute qualité. Cependant, ces techniques ne sont pas les plus adaptées pour trouver des failles de sécurité. Ils sont généralement utilisés pour tester les comportements positifs du code (c'est-à-dire que le code fonctionne comme prévu dans le contexte normal), tandis que les failles de sécurité ont tendance à se trouver dans des cas limites que les développeurs n'ont pas envisagés. Dans notre étude portant sur des dizaines d'audits de sécurité de contrats intelligents, [la couverture des tests unitaires n'a eu aucun effet sur le nombre ou la gravité des failles de sécurité](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/) que nous avons trouvées dans le code de nos clients.
 
 ## Détermination des propriétés de sécurité {#determining-security-properties}
 
-Pour tester et vérifier efficacement votre code, vous devez identifier les zones qui nécessitent une attention particulière. Comme vos ressources consacrées à la sécurité sont limitées, il est important d’optimiser vos efforts pour déterminer la portée des parties faibles ou de grande valeur de votre code base. La modélisation des menaces peut vous aider. Envisagez la révision :
+Pour tester et vérifier efficacement votre code, vous devez identifier les zones qui nécessitent une attention particulière. Vos ressources en matière de sécurité étant limitées, il est important de cibler les parties faibles ou à forte valeur de votre base de code afin d'optimiser vos efforts. La modélisation des menaces peut vous aider. Envisagez de consulter :
 
-- [Évaluation Rapide des Risques](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html) (notre approche préférée lorsque le temps se fait court)
-- [Guide de modélisation des menaces du système centralisé de données](https://csrc.nist.gov/publications/detail/sp/800-154/draft) (aka NIST 800-154)
-- [Modélisation des fils de discussion Shostack](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998)
-- [STRIDE](https://wikipedia.org/wiki/STRIDE_(security)) / [DREAD](https://wikipedia.org/wiki/DREAD_(risk_assessment_model))
+- [Rapid Risk Assessments](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html) (notre approche privilégiée lorsque le temps est limité)
+- [Guide to Data-Centric System Threat Modeling](https://csrc.nist.gov/pubs/sp/800/154/ipd) (alias NIST 800-154)
+- [Shostack threat modeling](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998)
+- [STRIDE](https://wikipedia.org/wiki/STRIDE_\(security\)) / [DREAD](https://wikipedia.org/wiki/DREAD_\(risk_assessment_model\))
 - [PASTA](https://wikipedia.org/wiki/Threat_model#P.A.S.T.A.)
-- [Utilisation des affirmations](https://blog.regehr.org/archives/1091)
+- [Use of Assertions](https://blog.regehr.org/archives/1091)
 
 ### Composants {#components}
 
 Savoir ce que vous voulez vérifier vous aidera également à sélectionner le bon outil.
 
-Les grands domaines qui sont souvent pertinents pour les contrats intelligents comprennent :
+Les grands domaines qui sont souvent pertinents pour les contrats intelligents sont les suivants :
 
-- **Machine d'état.** La plupart des contrats peuvent être représentés comme une machine d’état. Pensez à vérifier que (1) aucun état non valide ne peut être atteint, (2) si un état est valide, qu’il peut être atteint, et (3) aucun état ne piège le contrat.
+- **Machine d'état.** La plupart des contrats peuvent être représentés comme une machine d'état. Envisagez de vérifier que (1) aucun état non valide ne peut être atteint, (2) si un état est valide, il peut être atteint, et (3) aucun état ne bloque le contrat.
 
-  - Echidna et Manticore sont les outils à privilégier pour tester les spécifications des machines d’état.
+  - Echidna et Manticore sont les outils à privilégier pour tester les spécifications des machines d'état.
 
-- **Contrôle d'accès.** Si votre système a des utilisateurs dotés de privilèges (par exemple, un propriétaire, des contrôleurs, ...) vous devez vous assurer que (1) chaque utilisateur ne peut effectuer que les actions autorisées et (2) aucun utilisateur ne peut bloquer les actions d’un utilisateur avec des privilèges supérieurs.
+- **Contrôles d'accès.** Si votre système a des utilisateurs privilégiés (p. ex., un propriétaire, des contrôleurs, etc.) vous devez vous assurer que (1) chaque utilisateur ne peut effectuer que les actions autorisées et (2) aucun utilisateur ne peut bloquer les actions d'un utilisateur plus privilégié.
 
-  - Slither, Echidna et Manticore peuvent vérifier les contrôles d’accès corrects. Par exemple, Slither peut vérifier que seules les fonctions de la liste blanche ne disposent pas du modificateur onlyOwner. Echidna et Manticore sont utiles pour un contrôle d’accès plus complexe, comme une autorisation donnée uniquement si le contrat atteint un état donné.
+  - Slither, Echidna et Manticore peuvent vérifier la correction des contrôles d'accès. Par exemple, Slither peut vérifier que seules les fonctions sur liste blanche n'ont pas le modificateur onlyOwner. Echidna et Manticore sont utiles pour un contrôle d'accès plus complexe, comme une autorisation accordée uniquement si le contrat atteint un état donné.
 
-- **Opérations arithmétiques.** Vérifier la solidité des opérations arithmétiques est absolument essentiel. L’utilisation de `SafeMath` partout est une bonne étape pour éviter les dépassements supérieurs et inférieurs, cependant, vous devez toujours prendre en compte d’autres défauts arithmétiques, y compris les problèmes d’arrondi et les défauts qui piègent le contrat.
+- **Opérations arithmétiques.** La vérification de la justesse des opérations arithmétiques est essentielle. L'utilisation de `SafeMath` partout est une bonne mesure pour empêcher les dépassements/soupassements de capacité. Cependant, vous devez toujours tenir compte des autres défauts arithmétiques, y compris les problèmes d'arrondi et les défauts qui bloquent le contrat.
 
-  - Manticore est ici le meilleur choix. Echidna peut être utilisé si l’arithmétique est hors du champ d’application du solveur SMT.
+  - Manticore est ici le meilleur choix. Echidna peut être utilisé si l'arithmétique est hors du champ d'application du solveur SMT.
 
-- **Exactitude de l'héritage.** Les contrats de solidity reposent fortement sur l’héritage multiple. Des erreurs telles qu’une fonction d’ombrage manquant d’un appel `super` et un ordre de linéarisation c3 mal interprété peuvent facilement être introduites.
+- **Correction de l'héritage.** Les contrats Solidity reposent fortement sur l'héritage multiple. Des erreurs telles qu'une fonction masquée omettant un appel `super` et un ordre de linéarisation C3 mal interprété peuvent facilement être introduites.
 
-  - Slither est l’outil pour assurer la détection de ces problèmes.
+  - Slither est l'outil qui permet de garantir la détection de ces problèmes.
 
-- **Interactions externes.** Les contrats interagissent les uns avec les autres, et certains contrats externes ne doivent pas être approuvés. Par exemple, si votre contrat repose sur des oracles externes, restera-t-il sécurisé si la moitié des oracles disponibles sont compromis ?
+- **Interactions externes.** Les contrats interagissent les uns avec les autres, et il ne faut pas faire confiance à certains contrats externes. Par exemple, si votre contrat dépend d'oracles externes, restera-t-il sécurisé si la moitié des oracles disponibles sont compromis ?
 
-  - Manticore et Echidna sont le meilleur choix pour tester les interactions externes avec vos contrats. Manticore dispose d’un mécanisme intégré pour talonner les contrats externes.
+  - Manticore et Echidna sont le meilleur choix pour tester les interactions externes avec vos contrats. Manticore dispose d'un mécanisme intégré pour simuler les contrats externes.
 
-- **Conformité standard.** Les normes Ethereum (par exemple ERC20) ont un historique de défauts dans leur conception. Soyez conscient des limites de la norme sur laquelle vous vous appuyez.
-  - Slither, Echidna et Manticore vous aideront à détecter les écarts par rapport à une norme donnée.
+- **Conformité aux standards.** Les standards Ethereum (p. ex., ERC20) ont un historique de failles dans leur conception. Soyez conscient des limites du standard sur lequel vous vous basez.
+  - Slither, Echidna et Manticore vous aideront à détecter les écarts par rapport à un standard donné.
 
-### Fiche mémo de sélection d’outils {#tool-selection-cheatsheet}
+### Aide-mémoire de sélection d'outils {#tool-selection-cheatsheet}
 
-| Composant               | Outils                      | Exemples                                                                                                                                                                                                                                                        |
-| ----------------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Machine d'état          | Echidna, Manticore          |                                                                                                                                                                                                                                                                 |
-| Access control          | Slither, Echidna, Manticore | [Slither exercise 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md), [Echidna exercise 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md)       |
-| Arithmetic operations   | Manticore, Echidna          | [Echidna exercise 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md), [Manticore exercises 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) |
-| Inheritance correctness | Slither                     | [Slither exercise 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md)                                                                                                                                     |
-| External interactions   | Manticore, Echidna          |                                                                                                                                                                                                                                                                 |
-| Standard conformance    | Slither, Echidna, Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance)                                                                                                                                                                                         |
+| Composant                | Outils                      | Exemples                                                                                                                                                                                                                                                                      |
+| ------------------------ | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Machine d'état           | Echidna, Manticore          |                                                                                                                                                                                                                                                                               |
+| Contrôle d'accès         | Slither, Echidna, Manticore | [Slither exercise 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md), [Echidna exercise 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) |
+| Opérations arithmétiques | Manticore, Echidna          | [Echidna exercise 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md), [Manticore exercises 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises)     |
+| Correction de l'héritage | Slither                     | [Slither exercise 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md)                                                                                                                                         |
+| Interactions externes    | Manticore, Echidna          |                                                                                                                                                                                                                                                                               |
+| Conformité aux standards | Slither, Echidna, Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance)                                                                                                                                                                                                       |
 
-D’autres domaines devront être vérifiés en fonction de vos objectifs, mais ces domaines généraux représentent un bon point de départ pour tout système de contrat intelligent.
+D'autres domaines devront être vérifiés en fonction de vos objectifs, mais ces grands axes de travail constituent un bon point de départ pour tout système de contrat intelligent.
 
-Nos audits publics contiennent des exemples de propriétés vérifiées ou testées. Envisagez de lire les sections `Test et vérification automatisées` des rapports suivants pour examiner les propriétés de sécurité dans le réel :
+Nos audits publics contiennent des exemples de propriétés vérifiées ou testées. Pensez à lire les sections `Test et vérification automatisés` des rapports suivants pour examiner des propriétés de sécurité du monde réel :
 
 - [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf)
 - [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf)
diff --git a/public/content/translations/fr/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/fr/developers/tutorials/hello-world-smart-contract-fullstack/index.md
index 649e554f42d..b9947928805 100644
--- a/public/content/translations/fr/developers/tutorials/hello-world-smart-contract-fullstack/index.md
+++ b/public/content/translations/fr/developers/tutorials/hello-world-smart-contract-fullstack/index.md
@@ -1,106 +1,93 @@
 ---
-title: Un Contrat intelligent « Hello World » pour les débutants - Fullstack
-description: Tutoriel d'introduction à l'écriture et au déploiement d'un contrat intelligent simple sur Ethereum.
+title: "Un contrat intelligent « Hello World » pour les débutants - Fullstack"
+description: "Tutoriel d'introduction à l'écriture et au déploiement d'un contrat intelligent simple sur Ethereum."
 author: "nstrike2"
 tags:
-  - "solidity"
-  - "hardhat"
-  - "alchemy"
-  - "contrats intelligents"
-  - "déployer"
-  - "explorateur de blockchain"
-  - "frontend"
-  - "transactions"
+  [
+    "solidité",
+    "hardhat",
+    "alchemy",
+    "contrats intelligents",
+    "déploiement",
+    "Explorateur de bloc",
+    "frontend",
+    "transactions"
+  ]
 skill: beginner
 lang: fr
 published: 2021-10-25
 ---
 
-Ce guide s'adresse à vous si vous êtes novice en matière de développement blockchain et que vous ne savez pas par où commencer ou comment déployer et interagir avec les contrats intelligents. Nous allons parcourir la création et le déploiement d'un contrat intelligent simple sur le réseau de test de Goerli à l'aide de [MetaMask](https://metamask.io), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org), et [Alchemy](https://alchemyapi.io/eth) .
+Ce guide s'adresse à vous si vous êtes novice en matière de développement blockchain et que vous ne savez pas par où commencer ou comment déployer et interagir avec les contrats intelligents. Nous allons vous guider dans la création et le déploiement d'un contrat intelligent simple sur le réseau de test Goerli en utilisant [MetaMask](https://metamask.io), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org), et [Alchemy](https://alchemy.com/eth).
 
-Vous aurez besoin d'un compte Alchemy pour achever ce tutoriel. [S'inscrire pour un compte gratuit](https://www.alchemy.com/).
+Vous aurez besoin d'un compte Alchemy pour achever ce tutoriel. [Inscrivez-vous pour un compte gratuit](https://www.alchemy.com/).
 
-Si vous avez des questions à un moment ou à un autre, n'hésitez pas à en discuter sur le [Discord Alchemy](https://discord.gg/gWuC7zB)!
+Si vous avez des questions à un moment ou à un autre, n'hésitez pas à nous contacter sur le [Discord d'Alchemy](https://discord.gg/gWuC7zB) !
 
 ## Partie 1 - Créer et déployer votre contrat intelligent avec Hardhat {#part-1}
 
 ### Se connecter au réseau Ethereum {#connect-to-the-ethereum-network}
 
-Il existe de nombreuses façons de faire des requêtes dans la chaîne d'Ethereum. Pour plus de simplicité, nous allons utiliser un compte gratuit sur Alchemy, une plateforme de blockchain et d'API pour développeur, nous permettant de communiquer avec la chaîne Ethereum sans avoir à exécuter notre propre nœud. Alchemy dispose également d'outils de développement pour la surveillance et l'analyse, dont nous allons tirer parti dans ce tutoriel, pour comprendre ce qui se passe sous le capot dans le déploiement de notre contrat intelligent.
+Il existe de nombreuses façons de faire des requêtes sur la chaîne Ethereum. Pour plus de simplicité, nous allons utiliser un compte gratuit sur Alchemy, une plateforme de développement blockchain et une API qui nous permet de communiquer avec la chaîne Ethereum sans avoir à exécuter notre propre nœud. Alchemy dispose également d'outils de développement pour la surveillance et l'analyse, dont nous allons tirer parti dans ce tutoriel, pour comprendre ce qui se passe sous le capot dans le déploiement de notre contrat intelligent.
 
 ### Créez votre application et votre clé API {#create-your-app-and-api-key}
 
-Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela va vous permettre d'émettre des requêtes sur le réseau de test Goerli. Si vous n'êtes pas familiarisé avec les réseaux de test, vous pouvez [lire le guide d'Alchemy sur le choix d'un réseau](https://docs.alchemyapi.io/guides/choosing-a-network).
+Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela va vous permettre d'émettre des requêtes sur le réseau de test Goerli. Si vous n'êtes pas familier avec les réseaux de test, vous pouvez [lire le guide d'Alchemy pour choisir un réseau](https://www.alchemy.com/docs/choosing-a-web3-network).
 
-Sur le tableau de bord Alchemy, trouvez le menu déroulant **Apps** dans la barre de navigation et cliquez sur **Créer une application**.
+Sur le tableau de bord Alchemy, trouvez le menu déroulant **Apps** dans la barre de navigation et cliquez sur **Create App**.
 
-![créer une application Hello world](./hello-world-create-app.png)
+![Création de l'application Hello world](./hello-world-create-app.png)
 
-Donnez à votre application le nom "_Hello World_" et écrivez une courte description. Sélectionnez **Staging** comme environnement et **Goerli** comme réseau.
+Donnez à votre application le nom « _Hello World_ » et écrivez une courte description. Sélectionnez **Staging** comme environnement et **Goerli** comme réseau.
 
-![créer une vue de l'application Hello world](./create-app-view-hello-world.png)
+![Vue de création de l'application Hello world](./create-app-view-hello-world.png)
 
 _Note : assurez-vous de sélectionner **Goerli**, sinon ce tutoriel ne fonctionnera pas._
 
-Cliquer sur **Create app**. Votre application apparaîtra dans le tableau ci-dessous.
+Cliquez sur **Créer une application**. Votre application apparaîtra dans le tableau ci-dessous.
 
 ### Créer un compte Ethereum {#create-an-ethereum-account}
 
 Vous avez besoin d'un compte Ethereum pour envoyer et recevoir des transactions. Nous utiliserons MetaMask, un portefeuille virtuel intégré au navigateur permettant aux utilisateurs de gérer l'adresse de leur compte Ethereum.
 
-Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer sur « Réseau de test Goerli » en haut à droite (afin de ne pas utiliser d'argent réel).
+Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer sur le « Réseau de test Goerli » en haut à droite (afin de ne pas utiliser d'argent réel).
 
-### Étape 4 : Ajouter des ethers depuis un faucet {#step-4-add-ether-from-a-faucet}
+### Étape 4 : Ajouter de l'ether à partir d'un robinet {#step-4-add-ether-from-a-faucet}
 
 Afin de déployer votre contrat intelligent sur le réseau de test, vous aurez besoin de faux ETH. Pour obtenir de l'ETH sur le réseau Goerli, rendez-vous sur un robinet Goerli et entrez l'adresse de votre compte Goerli. Notez que les robinets Goerli peuvent avoir quelques difficultés de fonctionnement ces derniers temps - consultez la [page des réseaux de test](/developers/docs/networks/#goerli) pour une liste d'options à essayer :
 
-_Note : en raison de la congestion du réseau, cela peut prendre un certain temps._ ``
+_Note : en raison de la congestion du réseau, cela peut prendre un certain temps._
+``
 
 ### Étape 5 : Vérifiez votre solde {#step-5-check-your-balance}
 
-Pour revérifier que l'ETH est dans votre portefeuille, créons une requête
-
-en utilisant [l'outil Composer d'Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va renvoyer la quantité d'ETH dans notre portefeuille. Pour en savoir plus, consultez [le court tutoriel d'Alchemy sur la manière d'utiliser l'outil Composer](https://youtu.be/r6sjRxBZJuU).
-
-Entrez votre adresse de compte MetaMask et cliquez sur **Envoyer la demande**. Vous verrez une réponse qui ressemble au morceau de code ci-dessous.
-
+Pour vérifier que les ETH sont bien dans votre portefeuille, nous allons effectuer une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant l'[outil Composer d'Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va renvoyer la quantité d'ETH dans notre portefeuille. Pour en savoir plus, consultez le [court tutoriel d'Alchemy sur la manière d'utiliser l'outil Composer](https://youtu.be/r6sjRxBZJuU).
 
+Saisissez l'adresse de votre compte MetaMask et cliquez sur **Envoyer la requête**. Vous verrez une réponse qui ressemble à l'extrait de code ci-dessous.
 
 ```json
 { "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
 ```
 
-
-
-
 > _Note : Ce résultat est en wei, pas en ETH. Le wei est utilisé comme la plus petite dénomination d'ether._
 
 Ouf ! Notre faux argent est bien là.
 
-
-
-### Étape 6 : Initialisons notre projet {#step-6-initialize-our-project}
+### Étape 6 : Initialiser notre projet {#step-6-initialize-our-project}
 
 Tout d'abord, nous devons créer un dossier pour notre projet. Accédez à votre ligne de commande et entrez ce qui suit.
 
-
-
 ```
 mkdir hello-world
 cd hello-world
 ```
 
+Maintenant que nous sommes dans notre dossier de projet, nous allons utiliser `npm init` pour initialiser le projet.
 
-Maintenant que nous sommes dans le dossier de notre projet, nous allons utiliser `npm init` pour initialiser le projet.
-
-
-
-> Si vous n'avez pas encore npm installé, suivez [ces instructions pour installer Node.js et npm](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm).
+> Si vous n'avez pas encore installé npm, suivez [ces instructions pour installer Node.js et npm](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm).
 
 Pour les besoins de ce tutoriel, peu importe comment vous répondez aux questions d'initialisation. Voici comment nous l'avons fait à titre de référence :
 
-
-
 ```
 package name: (hello-world)
 version: (1.0.0)
@@ -127,42 +114,29 @@ About to write to /Users/.../.../.../hello-world/package.json:
 }
 ```
 
+Approuvez le fichier package.json et nous sommes prêts !
 
-Approuvez le package.json et nous sommes prêts à démarrer !
-
-
-
-### Step 7 : Téléchargez Hardhat {#step-7-download-hardhat}
+### Étape 7 : Télécharger Hardhat {#step-7-download-hardhat}
 
 Hardhat est un environnement de développement qui permet de compiler, déployer, tester et déboguer votre logiciel Ethereum. Il aide les développeurs à construire des contrats intelligents et des dApps localement avant de les déployer sur la chaîne en production.
 
-À l'intérieur de notre projet `hello-world`, exécutez :
-
-
+Dans notre projet `hello-world`, exécutez :
 
 ```
 npm install --save-dev hardhat
 ```
 
-
-Consultez cette page pour plus de détails sur [les instructions d'installation](https://hardhat.org/getting-started/#overview).
-
-
+Consultez cette page pour plus de détails sur les [instructions d'installation](https://hardhat.org/getting-started/#overview).
 
 ### Étape 8 : Créer un projet Hardhat {#step-8-create-hardhat-project}
 
-Dans le dossier de notre projet`hello-world`, exécutez :
-
-
+Dans le dossier de notre projet `hello-world`, exécutez :
 
 ```
 npx hardhat
 ```
 
-
-Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour séléctionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :
-
-
+Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour sélectionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :
 
 ```
 888    888                      888 888               888
@@ -174,75 +148,65 @@ Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour s
 888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
 888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
 
-👷 Welcome to Hardhat v2.0.11 👷‍
+👷 Bienvenue dans Hardhat v2.0.11 👷‍
 
-What do you want to do? …
-Create a sample project
-❯ Create an empty hardhat.config.js
-Quit
+Que voulez-vous faire ? …
+Créer un projet d'exemple
+❯ Créer un fichier hardhat.config.js vide
+Quitter
 ```
 
-
 Cela générera un fichier `hardhat.config.js` dans le projet. Nous l'utiliserons plus tard dans le tutoriel pour spécifier la configuration de notre projet.
 
-
-
 ### Étape 9 : Ajouter les dossiers du projet {#step-9-add-project-folders}
 
-Pour garder le projet organisé, créons deux nouveaux dossiers. Dans la ligne de commande, naviguez vers le répertoire racine de votre projet `hello-world` et tapez :
-
-
+Pour garder le projet organisé, créons deux nouveaux dossiers. Dans la ligne de commande, naviguez vers le répertoire racine de votre projet hello-world et tapez :
 
 ```
 mkdir contracts
 mkdir scripts
 ```
 
-
-- `contrats/` est l'endroit où nous garderons notre fichier de code de contrat intelligent 'hello world'
-- `scripts/` est l'endroit où nous garderons les scripts à déployer et pour interagir avec notre contrat
-
-
+- `contracts/` est l'endroit où nous conserverons le fichier de code de notre contrat intelligent hello world.
+- `scripts/` est l'endroit où nous conserverons les scripts pour déployer notre contrat et interagir avec lui.
 
 ### Étape 10 : Écrire notre contrat {#step-10-write-our-contract}
 
-Vous vous demandez peut-être quand allons-nous enfin écrire du code ? C'est maintenant !
+Vous vous demandez peut-être : quand allons-nous écrire du code ? C'est maintenant !
 
-Ouvrez le projet hello-world dans votre éditeur préféré. Les contrats intelligents sont le plus souvent écrits en Solidity, que nous utiliserons pour écrire le notre.
+Ouvrez le projet hello-world dans votre éditeur préféré. Les contrats intelligents sont le plus souvent écrits en Solidity, que nous utiliserons pour écrire notre contrat intelligent.‌
 
 1. Naviguez vers le dossier `contracts` et créez un nouveau fichier appelé `HelloWorld.sol`
 2. Ci-dessous se trouve un exemple de contrat intelligent Hello World que nous utiliserons pour ce tutoriel. Copiez le contenu ci-dessous dans le fichier `HelloWorld.sol`.
 
 _Note : Assurez-vous de lire les commentaires pour comprendre ce que fait ce contrat._
 
-
-
 ```
-// Specifies the version of Solidity, using semantic versioning.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// Spécifie la version de Solidity, en utilisant le versionnage sémantique.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
 pragma solidity >=0.7.3;
 
-// Defines a contract named `HelloWorld`.
-// A contract is a collection of functions and data (its state). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// Définit un contrat nommé `HelloWorld`.
+// Un contrat est une collection de fonctions et de données (son état). Une fois déployé, un contrat réside à une adresse spécifique sur la blockchain Ethereum. En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
 contract HelloWorld {
 
-   //Emitted when update function is called
-   //Smart contract events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be 'listening' for certain events and take action when they happen.
+   //Émis lorsque la fonction de mise à jour est appelée
+   //Les événements de contrat intelligent sont un moyen pour votre contrat de communiquer que quelque chose s'est passé sur la blockchain à votre interface d'application, qui peut « écouter » certains événements et prendre des mesures lorsqu'ils se produisent.
    event UpdatedMessages(string oldStr, string newStr);
 
-   // Declares a state variable `message` of type `string`.
-   // State variables are variables whose values are permanently stored in contract storage. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+   // Déclare une variable d'état `message` de type `string`.
+   // Les variables d'état sont des variables dont les valeurs sont stockées en permanence dans le stockage du contrat. Le mot-clé `public` rend les variables accessibles depuis l'extérieur d'un contrat et crée une fonction que d'autres contrats ou clients peuvent appeler pour accéder à la valeur.
    string public message;
 
-   // Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
-   // Constructors are used to initialize the contract's data. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+   // Semblable à de nombreux langages orientés objet basés sur les classes, un constructeur est une fonction spéciale qui n'est exécutée qu'à la création du contrat.
+   // Les constructeurs sont utilisés pour initialiser les données du contrat. En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
    constructor(string memory initMessage) {
 
-      // Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
+      // Accepte un argument de chaîne `initMessage` et définit la valeur dans la variable de stockage `message` du contrat).
       message = initMessage;
    }
 
-   // A public function that accepts a string argument and updates the `message` storage variable.
+   // Une fonction publique qui accepte un argument de chaîne et met à jour la variable de stockage `message`.
    function update(string memory newMessage) public {
       string memory oldMsg = message;
       message = newMessage;
@@ -251,79 +215,59 @@ contract HelloWorld {
 }
 ```
 
-
 Il s'agit d'un contrat intelligent basique qui stocke un message lors de sa création. Il peut être mis à jour en appelant la fonction `update`.
 
+### Étape 11 : Connecter MetaMask et Alchemy à votre projet {#step-11-connect-metamask-alchemy-to-your-project}
 
-
-### Étape 11 : Connecter MetaMask & Alchemy à votre projet {#step-11-connect-metamask-alchemy-to-your-project}
-
-Maintenant que nous avons créé un portefeuille Metamask, un compte Alchemy et écrit notre contrat intelligent, il est temps de connecter les trois.
+Nous avons créé un portefeuille MetaMask, un compte Alchemy et rédigé notre contrat intelligent. Il est maintenant temps de connecter les trois.
 
 Chaque transaction envoyée depuis votre portefeuille nécessite une signature à l'aide de votre clé privée unique. Pour fournir cette autorisation à notre programme, nous pouvons stocker en toute sécurité notre clé privée dans un fichier d'environnement. Nous y stockerons également une clé API pour Alchemy.
 
-
-
-> Pour en savoir plus sur l'envoi de transactions, consultez [ce tutoriel](https://docs.alchemyapi.io/alchemy/tutorials/sending-transactions-using-web3-and-alchemy) sur l'envoi de transactions avec web3.
+> Pour en savoir plus sur l'envoi de transactions, consultez [ce tutoriel](https://www.alchemy.com/docs/hello-world-smart-contract#step-11-connect-metamask--alchemy-to-your-project) sur l'envoi de transactions à l'aide de web3.
 
 Premièrement, installez le paquet dotenv dans votre dossier de projet :
 
-
-
 ```
 npm install dotenv --save
 ```
 
-
 Ensuite, créez un fichier `.env` dans le répertoire racine du projet. Ajoutez-y votre clé privée MetaMask et l'URL API HTTP d'Alchemy.
 
 Votre fichier d'environnement doit être nommé `.env` ou il ne sera pas reconnu comme un fichier d'environnement.
 
-Ne le nommez pas `process.env` ou `.env-custom` ou autrement.
+Ne le nommez pas `process.env` ou `.env-custom` ou quoi que ce soit d'autre.
 
 - Suivez [ces instructions](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) pour exporter votre clé privée
 - Voir ci-dessous pour obtenir l'URL de l'API HTTP Alchemy
 
 ![](./get-alchemy-api-key.gif)
 
-Votre `.env` devrait ressembler à ceci :
-
-
+Votre `.env` devrait ressembler à ceci :
 
 ```
 API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
 PRIVATE_KEY = "your-metamask-private-key"
 ```
 
-
 Pour les relier à notre code, nous ferons référence à ces variables dans notre fichier `hardhat.config.js` à l'étape 13.
 
-
-
 ### Étape 12 : Installer Ethers.js {#step-12-install-ethersjs}
 
-Ethers.js est une bibliothèque qui permet facilement d'interagir et de faire des requêtes pour Ethereum en conditionnant les méthodes [standard JSON-RPC](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc) avec des méthodes plus conviviales d'utilisation.
+Ethers.js est une bibliothèque qui facilite l'interaction et les requêtes vers Ethereum en enveloppant les [méthodes JSON-RPC standard](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc) avec des méthodes plus conviviales.
 
-Hardhat nous permet d'intégrer des [plugins](https://hardhat.org/plugins/) pour des outils supplémentaires et des fonctionnalités étendues. Nous allons tirer parti du [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) pour le déploiement de contrats.
+Hardhat nous permet d'intégrer des [plugins](https://hardhat.org/plugins/) pour des outils supplémentaires et des fonctionnalités étendues. Nous allons profiter du [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) pour le déploiement de contrats.
 
 Dans votre dossier de projet, tapez :
 
-
-
 ```bash
 npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
 ```
 
-
-
-
 ### Étape 13 : Mettre à jour hardhat.config.js {#step-13-update-hardhat-configjs}
 
-A ce stade, nous avons ajouté plusieurs dépendances et plugins. Nous devons maintenant mettre à jour `hardhat.config.js` pour que notre projet les reconnaisse.
-
-Mettez à jour votre `hardhat.config.js` pour qu'il ressemble à ceci :
-
+À ce stade, nous avons ajouté plusieurs dépendances et plugins. Nous devons maintenant mettre à jour `hardhat.config.js` pour que notre projet les reconnaisse.
 
+Mettez à jour votre `hardhat.config.js` pour qu'il ressemble à ceci :
 
 ```javascript
 /**
@@ -348,25 +292,17 @@ module.exports = {
 }
 ```
 
-
-
-
 ### Étape 14 : Compiler notre contrat {#step-14-compile-our-contract}
 
-Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La tâche `compile` est une des tâches intégrées à hardhat.
+Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La tâche `compile` est l'une des tâches intégrées de hardhat.
 
 À partir de la ligne de commande, exécutez :
 
-
-
 ```bash
 npx hardhat compile
 ```
 
-
-Vous pourriez voir un avertissement du type `SPDX license identifier not provided in source file`, mais nul besoin de vous inquiéter — espérons que tout le reste fonctionne ! Si ce n'est pas le cas, vous pouvez toujours envoyer un message dans le Discord [Alchemy](https://discord.gg/u72VCg3).
-
-
+Vous pourriez recevoir un avertissement concernant l'« identifiant de licence SPDX non fourni dans le fichier source », mais ne vous inquiétez pas — espérons que tout le reste se passe bien ! Sinon, vous pouvez toujours envoyer un message sur le [Discord d'Alchemy](https://discord.gg/u72VCg3).
 
 ### Étape 15 : Écrire notre script de déploiement {#step-15-write-our-deploy-script}
 
@@ -374,15 +310,13 @@ Maintenant que notre contrat est codé et que notre fichier de configuration est
 
 Naviguez vers le dossier `scripts/` et créez un nouveau fichier appelé `deploy.js`, en y ajoutant le contenu suivant :
 
-
-
 ```javascript
 async function main() {
   const HelloWorld = await ethers.getContractFactory("HelloWorld")
 
-  // Start deployment, returning a promise that resolves to a contract object
+  // Démarrer le déploiement, en retournant une promesse qui se résout en un objet de contrat
   const hello_world = await HelloWorld.deploy("Hello World!")
-  console.log("Contract deployed to address:", hello_world.address)
+  console.log("Contrat déployé à l'adresse :", hello_world.address)
 }
 
 main()
@@ -393,52 +327,37 @@ main()
   })
 ```
 
-
-Hardhat est incroyable en ce sens qu'il explique clairement ce que fait chacune des lignes de code au travers de son [tutoriel sur les contrats](https://hardhat.org/tutorial/testing-contracts.html#writing-tests). Nous avons repris ces explications ici.
-
-
+Hardhat explique très bien ce que fait chacune de ces lignes de code dans son [tutoriel sur les contrats](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), nous avons repris leurs explications ici.
 
 ```javascript
 const HelloWorld = await ethers.getContractFactory("HelloWorld")
 ```
 
-
-Une `ContractFactory` dans ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents. Ainsi, `HelloWorld` est ici une [usine](https://en.wikipedia.org/wiki/Factory_(object-oriented_programming)) pour des exemples de notre contrat Hello world. Lors de l'utilisation du plugin `hardhat-ethers`, les instances `ContractFactory` et `Contract` sont connectées par défaut au premier signataire (propriétaire).
-
-
+Un `ContractFactory` dans ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents, donc `HelloWorld` ici est une [factory (fabrique)](https://en.wikipedia.org/wiki/Factory_\(object-oriented_programming\)) pour les instances de notre contrat hello world. Lors de l'utilisation du plugin `hardhat-ethers`, les instances `ContractFactory` et `Contract` sont connectées par défaut au premier signataire (propriétaire).
 
 ```javascript
 const hello_world = await HelloWorld.deploy()
 ```
 
-
-Appeler `deploy()` sur un `ContractFactory` va démarrer le déploiement et retourner une `Promise` qui corrige l'objet `Contract`. C'est l'objet qui a une méthode pour chacune de nos fonctions de contrat intelligent.
-
-
+Appeler `deploy()` sur une `ContractFactory` lancera le déploiement et retournera une `Promise` qui se résout en un objet `Contract`. C'est l'objet qui possède une méthode pour chacune des fonctions de notre contrat intelligent.
 
 ### Étape 16 : Déployer notre contrat {#step-16-deploy-our-contract}
 
 Nous sommes enfin prêts à déployer notre contrat intelligent ! Naviguez vers la ligne de commande et exécutez :
 
-
-
 ```bash
 npx hardhat run scripts/deploy.js --network goerli
 ```
 
-
-Vous devriez dès lors voir quelque chose comme :
-
-
+Vous devriez maintenant voir quelque chose comme :
 
 ```bash
-Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+Contrat déployé à l'adresse : 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
 ```
 
-
 **Veuillez sauvegarder cette adresse**. Nous l'utiliserons plus tard dans le tutoriel.
 
-Si nous allons sur l'[etherscan Goerli](https://goerli.etherscan.io) et que nous recherchons l'adresse de notre contrat, nous devrions constater qu'il a été déployé avec succès. La transaction ressemblera à ceci :
+Si nous allons sur [l'Etherscan de Goerli](https://goerli.etherscan.io) et que nous recherchons l'adresse de notre contrat, nous devrions être en mesure de voir qu'il a été déployé avec succès. La transaction ressemblera à quelque chose comme :
 
 ![](./etherscan-contract.png)
 
@@ -446,30 +365,24 @@ L'adresse `From` devrait correspondre à l'adresse de votre compte MetaMask et l
 
 ![](./etherscan-transaction.png)
 
-Félicitations ! Vous venez de déployer un contrat intelligent sur la chaîne de test d'Ethereum.
+Félicitations ! Vous venez de déployer un contrat intelligent sur un réseau de test Ethereum.
 
-Pour comprendre ce qui se passe sous le capot, naviguons dans l'onglet Explorer de notre [tableau de bord Alchemy](https://dashboard.alchemyapi.io/explorer). Si vous avez plusieurs applications Alchemy, assurez-vous de filtrer par application et sélectionnez **Hello World**.
+Pour comprendre ce qui se passe en coulisses, naviguons vers l'onglet Explorer dans notre [tableau de bord Alchemy](https://dashboard.alchemy.com/explorer). Si vous avez plusieurs applications Alchemy, assurez-vous de filtrer par application et de sélectionner **Hello World**.
 
 ![](./hello-world-explorer.png)
 
-Ici, vous verrez un certain nombre de méthodes JSON-RPC que Hardhat/Ethers a réalisés sous le capot pour nous lorsque nous avons appelé la fonction `.deploy()`. Ici, deux méthodes importantes sont [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), qui est la demande d'écriture de notre contrat sur la chaîne Goerli, et [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash) qui est une requête pour lire des informations sur notre transaction compte tenu du hachage. Pour en savoir plus sur l'envoi de transactions, consultez [notre tutoriel sur l'envoi de transactions avec web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
-
-
+Ici, vous verrez une poignée de méthodes JSON-RPC que Hardhat/Ethers ont créées en coulisses pour nous lorsque nous avons appelé la fonction `.deploy()`. Deux méthodes importantes ici sont [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), qui est la requête pour écrire notre contrat sur la chaîne Goerli, et [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), qui est une requête pour lire les informations sur notre transaction à partir du hachage. Pour en savoir plus sur l'envoi de transactions, consultez [notre tutoriel sur l'envoi de transactions à l'aide de Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
 
 ## Partie 2 : Interagir avec votre contrat intelligent {#part-2-interact-with-your-smart-contract}
 
 Maintenant que nous avons déployé avec succès un contrat intelligent sur le réseau Goerli, apprenons à interagir avec lui.
 
-
-
-### Créez un fichier interact.js {#create-a-interactjs-file}
+### Créer un fichier interact.js {#create-a-interactjs-file}
 
 C'est dans ce fichier que nous écrirons notre script d'interaction. Nous utiliserons la bibliothèque Ethers.js que vous avez précédemment installée dans la Partie 1.
 
 À l'intérieur du dossier `scripts/`, créez un nouveau fichier nommé `interact.js` et ajoutez le code suivant :
 
-
-
 ```javascript
 // interact.js
 
@@ -478,19 +391,14 @@ const PRIVATE_KEY = process.env.PRIVATE_KEY
 const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
 ```
 
-
-
-
 ### Mettez à jour votre fichier .env {#update-your-env-file}
 
-Nous utiliserons de nouvelles variables d'environnement, donc nous devons les définir dans le fichier `.env` que [nous avons créé précédemment](#step-11-connect-metamask-&-alchemy-to-your-project).
+Nous allons utiliser de nouvelles variables d'environnement, nous devons donc les définir dans le fichier `.env` que [nous avons créé précédemment](#step-11-connect-metamask-&-alchemy-to-your-project).
 
-Nous devrons ajouter une définition pour notre `API_KEY` Alchemy et la `CONTRACT_ADDRESS` où votre contrat intelligent a été déployé.
+Nous devrons ajouter une définition pour notre `API_KEY` Alchemy et le `CONTRACT_ADDRESS` où votre contrat intelligent a été déployé.
 
 Votre fichier `.env` devrait ressembler à ceci :
 
-
-
 ```bash
 # .env
 
@@ -500,66 +408,50 @@ PRIVATE_KEY = "<your-metamask-private-key>"
 CONTRACT_ADDRESS = "0x<your contract address>"
 ```
 
+### Récupérez l'ABI de votre contrat {#grab-your-contract-ABI}
 
-
-
-### Obtenez votre ABI de contrat {#grab-your-contract-ABI}
-
-Notre [ABI de contrat (Interface Binaire d'Application)](/glossary/#abi) est l'interface pour interagir avec notre contrat intelligent. Hardhat génère automatiquement un ABI et le sauvegarde dans `HelloWorld.json`. Pour utiliser l'ABI, nous devons en extraire le contenu en ajoutant les lignes de code suivantes à notre fichier `interact.js` :
-
-
+L'[ABI (Application Binary Interface)](/glossary/#abi) de notre contrat est l'interface pour interagir avec notre contrat intelligent. Hardhat génère automatiquement un ABI et le sauvegarde dans `HelloWorld.json`. Pour utiliser l'ABI, nous devons en extraire le contenu en ajoutant les lignes de code suivantes à notre fichier `interact.js` :
 
 ```javascript
 // interact.js
 const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
 ```
 
-
-Si vous voulez lire l'ABI, vous pouvez l'afficher dans votre console :
-
-
+Si vous voulez voir l'ABI, vous pouvez l'afficher dans votre console :
 
 ```javascript
 console.log(JSON.stringify(contract.abi))
 ```
 
-
-Pour voir votre ABI affiché dans la console, naviguez vers votre terminal et exécutez :
-
-
+Pour voir votre ABI s'afficher dans la console, naviguez vers votre terminal et exécutez :
 
 ```bash
 npx hardhat run scripts/interact.js
 ```
 
-
-
-
-### Créez une instance de votre contrat {#create-an-instance-of-your-contract}
+### Créer une instance de votre contrat {#create-an-instance-of-your-contract}
 
 Pour interagir avec notre contrat, nous devons créer une instance de contrat dans notre code. Pour ce faire avec Ethers.js, nous devrons travailler avec trois concepts :
 
 1. Fournisseur - un fournisseur de nœud qui vous donne un accès en lecture et écriture à la blockchain
-2. Signataire - représente un compte Ethereum pouvant signer des transactions
+2. Signataire - représente un compte Ethereum qui peut signer des transactions
 3. Contrat - un objet Ethers.js représentant un contrat spécifique déployé sur la chaîne
 
 Nous utiliserons l'ABI de contrat de l'étape précédente pour créer notre instance du contrat :
 
-
-
 ```javascript
 // interact.js
 
-// Provider
+// Fournisseur
 const alchemyProvider = new ethers.providers.AlchemyProvider(
   (network = "goerli"),
   API_KEY
 )
 
-// Signer
+// Signataire
 const signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider)
 
-// Contract
+// Contrat
 const helloWorldContract = new ethers.Contract(
   CONTRACT_ADDRESS,
   contract.abi,
@@ -567,12 +459,9 @@ const helloWorldContract = new ethers.Contract(
 )
 ```
 
+En savoir plus sur les Fournisseurs, les Signataires et les Contrats dans la [documentation d'ethers.js](https://docs.ethers.io/v5/).
 
-En savoir plus sur les Fournisseurs, les Signataires, et les Contrats dans la [documentation d'ethers.js](https://docs.ethers.io/v5/).
-
-
-
-### Lisez le message d'initialisation {#read-the-init-message}
+### Lire le message d'initialisation {#read-the-init-message}
 
 Vous souvenez-vous lorsque nous avons déployé notre contrat avec `initMessage = "Hello world!"` ? Nous allons maintenant lire ce message stocké dans notre contrat intelligent et l'afficher sur la console.
 
@@ -580,8 +469,6 @@ En JavaScript, des fonctions asynchrones sont utilisées lors de l'interaction a
 
 Utilisez le code ci-dessous pour appeler la fonction `message` dans notre contrat intelligent et lire le message d'initialisation :
 
-
-
 ```javascript
 // interact.js
 
@@ -589,32 +476,24 @@ Utilisez le code ci-dessous pour appeler la fonction `message` dans notre contra
 
 async function main() {
   const message = await helloWorldContract.message()
-  console.log("The message is: " + message)
+  console.log("Le message est : " + message)
 }
 main()
 ```
 
-
 Après avoir exécuté le fichier en utilisant `npx hardhat run scripts/interact.js` dans le terminal, nous devrions voir cette réponse :
 
-
-
 ```
-The message is: Hello world!
+Le message est : Hello world!
 ```
 
-
-Félicitations ! Vous venez de lire avec succès des données de contrat intelligent depuis la blockchain Ethereum, bravo !
-
-
+Félicitations ! Vous venez de lire avec succès des données de contrat intelligent depuis la blockchain Ethereum, bravo !
 
 ### Mettre à jour le message {#update-the-message}
 
 Au lieu de simplement lire le message, nous pouvons également mettre à jour le message sauvegardé dans notre contrat intelligent en utilisant la fonction `update` ! Plutôt cool, n'est-ce pas ?
 
-Pour mettre à jour le message, nous pouvons appeler directement la fonction `update` sur notre objet Contract :
-
-
+Pour mettre à jour le message, nous pouvons appeler directement la fonction `update` sur notre objet de Contrat instancié :
 
 ```javascript
 // interact.js
@@ -623,28 +502,23 @@ Pour mettre à jour le message, nous pouvons appeler directement la fonction `up
 
 async function main() {
   const message = await helloWorldContract.message()
-  console.log("The message is: " + message)
+  console.log("Le message est : " + message)
 
-  console.log("Updating the message...")
-  const tx = await helloWorldContract.update("This is the new message.")
+  console.log("Mise à jour du message...")
+  const tx = await helloWorldContract.update("Ceci est le nouveau message.")
   await tx.wait()
 }
 main()
 ```
 
+Notez qu'à la ligne 11, nous faisons un appel à `.wait()` sur l'objet de transaction renvoyé. Cela garantit que notre script attend que la transaction soit minée sur la blockchain avant de quitter la fonction. Si l'appel `.wait()` n'est pas inclus, le script risque de ne pas voir la valeur mise à jour du `message` dans le contrat.
 
-Notez qu'à la ligne 11, nous faisons un appel à `.wait()` sur l'objet de transaction renvoyé. Cela garantit que notre script attend que la transaction soit exécutée sur la blockchain avant de quitter la fonction. Si l'appel `.wait()` n'est pas inclus, le script peut ne pas voir la valeur du `message` mis à jour dans le contrat.
-
+### Lire le nouveau message {#read-the-new-message}
 
-
-### Lisez le nouveau message {#read-the-new-message}
-
-Vous devriez pouvoir répéter [l'étape précédente](#read-the-init-message) pour lire la valeur du `message` mis à jour. Prenez un moment et voyez si vous pouvez apporter les modifications nécessaires pour afficher cette nouvelle valeur !
+Vous devriez pouvoir répéter l'[étape précédente](#read-the-init-message) pour lire la valeur du `message` mis à jour. Prenez un moment et voyez si vous pouvez apporter les modifications nécessaires pour afficher cette nouvelle valeur !
 
 Si vous avez besoin d'un indice, voici à quoi devrait ressembler votre fichier `interact.js` à ce stade :
 
-
-
 ```javascript
 // interact.js
 
@@ -654,16 +528,16 @@ const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
 
 const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
 
-// provider - Alchemy
+// fournisseur - Alchemy
 const alchemyProvider = new ethers.providers.AlchemyProvider(
   (network = "goerli"),
   API_KEY
 )
 
-// signer - you
+// signataire - vous
 const signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider)
 
-// contract instance
+// instance de contrat
 const helloWorldContract = new ethers.Contract(
   CONTRACT_ADDRESS,
   contract.abi,
@@ -672,54 +546,46 @@ const helloWorldContract = new ethers.Contract(
 
 async function main() {
   const message = await helloWorldContract.message()
-  console.log("The message is: " + message)
+  console.log("Le message est : " + message)
 
-  console.log("Updating the message...")
-  const tx = await helloWorldContract.update("this is the new message")
+  console.log("Mise à jour du message...")
+  const tx = await helloWorldContract.update("ceci est le nouveau message")
   await tx.wait()
 
   const newMessage = await helloWorldContract.message()
-  console.log("The new message is: " + newMessage)
+  console.log("Le nouveau message est : " + newMessage)
 }
 
 main()
 ```
 
-
 Exécutez simplement le script et vous devriez pouvoir voir l'ancien message, le statut de la mise à jour, et le nouveau message affiché sur votre terminal !
 
 `npx hardhat run scripts/interact.js --network goerli`
 
-
-
 ```
-The message is: Hello World!
-Updating the message...
-The new message is: This is the new message.
+Le message est : Hello World!
+Mise à jour du message...
+Le nouveau message est : Ceci est le nouveau message.
 ```
 
+Lors de l'exécution de ce script, vous remarquerez peut-être que l'étape « Mise à jour du message... » prend du temps à charger avant que le nouveau message ne s'affiche. Cela est dû au processus de minage ; si vous êtes curieux de suivre les transactions pendant qu'elles sont en cours de minage, visitez la [mempool d'Alchemy](https://dashboard.alchemyapi.io/mempool) pour voir le statut d'une transaction. Si la transaction est abandonnée, il est également utile de consulter [l'Etherscan de Goerli](https://goerli.etherscan.io) et de rechercher le hachage de votre transaction.
 
-Lors de l'exécution de ce script, vous remarquerez peut-être que l'étape `Mise à jour du message...` prend du temps à charger avant que le nouveau message ne s'affiche. Cela est dû au processus de minage ; si vous êtes curieux de suivre les transactions pendant qu'elles sont en cours de minage, visitez la [mempool d'Alchemy](https://dashboard.alchemyapi.io/mempool) pour voir le statut d'une transaction. Si la transaction est abandonnée, il est également utile de consulter [Goerli Etherscan](https://goerli.etherscan.io) et de rechercher votre hash de transaction.
-
-
-
-## Partie 3 : Publier votre Contrat Intelligent sur Etherscan {#part-3-publish-your-smart-contract-to-etherscan}
+## Partie 3 : Publier votre contrat intelligent sur Etherscan {#part-3-publish-your-smart-contract-to-etherscan}
 
 Vous avez fait tout le travail difficile pour donner vie à votre contrat intelligent ; il est maintenant temps de le partager avec le monde !
 
-En vérifiant votre contrat intelligent sur Etherscan, tout le monde peut voir votre code source et interagir avec votre contrat intelligent. Commençons !
-
-
+En vérifiant votre contrat intelligent sur Etherscan, n'importe qui peut voir votre code source et interagir avec votre contrat intelligent. Commençons !
 
-### Étape 1 : Générez une clé API sur votre compte Etherscan {#step-1-generate-an-api-key-on-your-etherscan-account}
+### Étape 1 : Générer une clé API sur votre compte Etherscan {#step-1-generate-an-api-key-on-your-etherscan-account}
 
 Une clé API Etherscan est nécessaire pour vérifier que vous possédez le contrat intelligent que vous essayez de publier.
 
-Si vous n'avez pas encore de compte Etherscan, [inscrivez-vous](https://etherscan.io/register).
+Si vous n'avez pas encore de compte Etherscan, [inscrivez-vous pour un compte](https://etherscan.io/register).
 
-Une fois connecté, trouvez votre nom d'utilisateur dans la barre de navigation, passez votre souris dessus et sélectionnez le bouton **Mon profil**.
+Une fois connecté, trouvez votre nom d'utilisateur dans la barre de navigation, survolez-le et sélectionnez le bouton **Mon profil**.
 
-Sur votre page de profil, vous devriez voir une barre de navigation latérale. Dans cette barre de navigation, sélectionnez **Clés API**. Ensuite, appuyez sur le bouton « Ajouter » pour créer une nouvelle clé API, nommez votre application **hello-world** et appuyez sur le bouton **Créer une nouvelle clé API**.
+Sur votre page de profil, vous devriez voir une barre de navigation latérale. Depuis la barre de navigation latérale, sélectionnez **Clés API**. Ensuite, appuyez sur le bouton « Ajouter » pour créer une nouvelle clé API, nommez votre application **hello-world** et appuyez sur le bouton **Créer une nouvelle clé API**.
 
 Votre nouvelle clé API devrait apparaître dans le tableau des clés API. Copiez la clé API dans votre presse-papiers.
 
@@ -727,8 +593,6 @@ Ensuite, nous devons ajouter la clé API d'Etherscan à notre fichier `.env`.
 
 Après l'avoir ajoutée, votre fichier `.env` devrait ressembler à ceci :
 
-
-
 ```javascript
 API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
 PUBLIC_KEY = "your-public-account-address"
@@ -737,27 +601,17 @@ CONTRACT_ADDRESS = "your-contract-address"
 ETHERSCAN_API_KEY = "your-etherscan-key"
 ```
 
+### Contrats intelligents déployés par Hardhat {#hardhat-deployed-smart-contracts}
 
-
-
-### Contrats intelligents déployés avec Hardhat {#hardhat-deployed-smart-contracts}
-
-
-
-#### Installez hardhat-etherscan {#install-hardhat-etherscan}
+#### Installer hardhat-etherscan {#install-hardhat-etherscan}
 
 Publier votre contrat sur Etherscan à l'aide de Hardhat est simple. Vous devrez d'abord installer le plugin `hardhat-etherscan` pour commencer. `hardhat-etherscan` vérifiera automatiquement le code source et l'ABI du contrat intelligent sur Etherscan. Pour l'ajouter, dans le répertoire `hello-world`, exécutez :
 
-
-
 ```text
 npm install --save-dev @nomiclabs/hardhat-etherscan
 ```
 
-
-Une fois installé, incluez la déclaration suivante en haut de votre fichier `hardhat.config.js`, et ajoutez les options de configuration d'Etherscan :
-
-
+Une fois installé, incluez la déclaration suivante en haut de votre `hardhat.config.js`, et ajoutez les options de configuration d'Etherscan :
 
 ```javascript
 // hardhat.config.js
@@ -779,129 +633,100 @@ module.exports = {
     },
   },
   etherscan: {
-    // Your API key for Etherscan
-    // Obtain one at https://etherscan.io/
+    // Votre clé API pour Etherscan
+    // Obtenez-en une sur https://etherscan.io/
     apiKey: ETHERSCAN_API_KEY,
   },
 }
 ```
 
-
-
-
 #### Vérifiez votre contrat intelligent sur Etherscan {#verify-your-smart-contract-on-etherscan}
 
 Assurez-vous que tous les fichiers sont sauvegardés et que toutes les variables `.env` sont correctement configurées.
 
-Exécutez la tâche `verify`, en envoyant l'adresse du contrat et le réseau sur lequel il est déployé :
-
-
+Exécutez la tâche `verify`, en passant l'adresse du contrat et le réseau sur lequel il est déployé :
 
 ```text
 npx hardhat verify --network goerli DEPLOYED_CONTRACT_ADDRESS 'Hello World!'
 ```
 
-
-Assurez-vous que `DEPLOYED_CONTRACT_ADDRESS` est l'adresse de votre contrat intelligent déployé sur le réseau de test Goerli. De plus, le dernier argument (`Hello World!`) doit être la même valeur de chaîne utilisée lors de [l'étape de déploiement de la partie 1](#write-our-deploy-script).
+Assurez-vous que `DEPLOYED_CONTRACT_ADDRESS` est l'adresse de votre contrat intelligent déployé sur le réseau de test Goerli. De plus, l'argument final (`'Hello World!'`) doit être la même valeur de chaîne que celle utilisée [lors de l'étape de déploiement de la partie 1](#write-our-deploy-script).
 
 Si tout se passe bien, vous verrez le message suivant dans votre terminal :
 
-
-
 ```text
-Successfully submitted source code for contract
+Code source du contrat soumis avec succès
 contracts/HelloWorld.sol:HelloWorld at 0xdeployed-contract-address
-for verification on Etherscan. Waiting for verification result...
+pour vérification sur Etherscan. En attente du résultat de la vérification...
 
 
-Successfully verified contract HelloWorld on Etherscan.
+Contrat HelloWorld vérifié avec succès sur Etherscan.
 https://goerli.etherscan.io/address/<contract-address>#contracts
 ```
 
+Félicitations ! Votre code de contrat intelligent est sur Etherscan !
 
-Félicitations ! Votre code de contrat intelligent est sur Etherscan !
-
+### Consultez votre contrat intelligent sur Etherscan ! {#check-out-your-smart-contract-on-etherscan}
 
+Lorsque vous naviguez vers le lien fourni dans votre terminal, vous devriez pouvoir voir votre code de contrat intelligent et l'ABI publiés sur Etherscan !
 
-### Votre code de contrat intelligent est sur Etherscan ! {#check-out-your-smart-contract-on-etherscan}
+**Wahooo - vous l'avez fait, champion ! Désormais, n'importe qui peut appeler ou écrire dans votre contrat intelligent ! Nous sommes impatients de voir ce que vous construirez ensuite !**
 
-Lorsque vous naviguez vers le lien fourni dans votre terminal, vous devriez pouvoir voir votre code de contrat intelligent et ABI publié sur Etherscan !
-
-**Wahooo - vous l'avez fait, champion ! Désormais, n'importe qui peut appeler ou écrire à votre contrat intelligent ! Nous sommes impatients de voir ce que vous construirez ensuite !**
-
-
-
-## Partie 4 - Intégration de votre contrat intelligent avec l'interface utilisateur {#part-4-integrating-your-smart-contract-with-the-frontend}
+## Partie 4 - Intégration de votre contrat intelligent avec le frontend {#part-4-integrating-your-smart-contract-with-the-frontend}
 
 À la fin de ce tutoriel, vous saurez comment :
 
 - Connecter un portefeuille MetaMask à votre dapp
-- Lire les données de votre contrat intelligent en utilisant l'API [Web3 d'Alchemy](https://docs.alchemy.com/alchemy/documentation/alchemy-web3)
+- Lire des données de votre contrat intelligent en utilisant l'API [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3)
 - Signer des transactions Ethereum en utilisant MetaMask
 
-Pour cette DApp, nous utiliserons [React](https://reactjs.org/) comme cadre d'interface utilisateur ; cependant, il est important de noter que nous ne passerons pas beaucoup de temps à décomposer ses fondamentaux, car nous nous concentrerons principalement sur l'ajout de la fonctionnalité Web3 à notre projet.
-
-En prérequis, vous devriez avoir une compréhension de niveau débutant de React. Sinon, nous recommandons de compléter le tutoriel officiel [Introduction à React](https://reactjs.org/tutorial/tutorial.html).
-
+Pour cette dapp, nous utiliserons [React](https://react.dev/) comme notre framework frontend ; cependant, il est important de noter que nous ne passerons pas beaucoup de temps à décomposer ses fondamentaux, car nous nous concentrerons principalement sur l'intégration de la fonctionnalité Web3 à notre projet.
 
+En prérequis, vous devriez avoir une compréhension de niveau débutant de React. Sinon, nous vous recommandons de suivre le [tutoriel officiel d'introduction à React](https://react.dev/learn).
 
 ### Cloner les fichiers de démarrage {#clone-the-starter-files}
 
-Tout d'abord, allez au [dépôt GitHub hello-world-part-four](https://github.com/alchemyplatform/hello-world-part-four-tutorial) pour obtenir les fichiers de départ de ce projet et clonez ce dépôt sur votre machine locale.
+Tout d'abord, rendez-vous sur le [dépôt GitHub hello-world-part-four](https://github.com/alchemyplatform/hello-world-part-four-tutorial) pour obtenir les fichiers de démarrage de ce projet et clonez ce dépôt sur votre machine locale.
 
 Ouvrez le dépôt cloné localement. Remarquez qu'il contient deux dossiers : `starter-files` et `completed`.
 
-- `starter-files`-**nous travaillerons dans ce répertoire**, nous connecterons l'UI à votre portefeuille Ethereum et le contrat intelligent que nous avons publié sur Etherscan lors de la [Partie 3](#part-3).
-- `completed` contient l'ensemble du tutoriel terminé et ne doit être utilisé que comme référence si vous êtes bloqué.
+- `starter-files` - **nous travaillerons dans ce répertoire**, nous connecterons l'interface utilisateur à votre portefeuille Ethereum et au contrat intelligent que nous avons publié sur Etherscan dans la [Partie 3](#part-3).
+- `completed` contient le tutoriel complet et ne doit être utilisé que comme référence si vous êtes bloqué.
 
 Ensuite, ouvrez votre copie de `starter-files` avec votre éditeur de code préféré, puis naviguez dans le dossier `src`.
 
-Tout le code que nous allons écrire restera dans le dossier `src`. Nous modifierons le composant `HelloWorld.js` et les fichiers JavaScript `util/interact.js` pour donner à notre projet des fonctionnalités Web3.
-
-
+Tout le code que nous allons écrire se trouvera dans le dossier `src`. Nous modifierons le composant `HelloWorld.js` et les fichiers JavaScript `util/interact.js` pour donner à notre projet des fonctionnalités Web3.
 
-### Consultez les fichiers de départ {#check-out-the-starter-files}
+### Consultez les fichiers de démarrage {#check-out-the-starter-files}
 
 Avant de commencer à coder, explorons ce qui nous est fourni dans les fichiers de départ.
 
-
-
-#### Faites tourner votre projet de React {#get-your-react-project-running}
+#### Faire fonctionner votre projet React {#get-your-react-project-running}
 
 Commençons par exécuter le projet React dans notre navigateur. La beauté de React est qu'une fois que notre projet est en cours d'exécution dans notre navigateur, toutes les modifications que nous sauvegardons seront mises à jour en direct dans notre navigateur.
 
-Pour faire fonctionner le projet, accédez au répertoire racine du dossier `starter-files` et exécutez `npm install` dans votre terminal pour installer les dépendances du projet :
-
-
+Pour lancer le projet, naviguez vers le répertoire racine du dossier `starter-files`, et exécutez `npm install` dans votre terminal pour installer les dépendances du projet :
 
 ```bash
 cd starter-files
 npm install
 ```
 
-
 Une fois l'installation terminée, exécutez `npm start` dans votre terminal :
 
-
-
 ```bash
 npm start
 ```
 
-
-Cela devrait ouvrir [http://localhost:3000/](http://localhost:3000/) dans votre navigateur, où vous verrez l'interface utilisateur pour notre projet. Elle devrait se composer d'un champ \(a un endroit pour mettre à jour le message stocké dans votre contrat intelligent\), d'un bouton « Connecter le portefeuille » et d'un bouton « Mettre à jour ».
+Cela devrait ouvrir [http://localhost:3000/](http://localhost:3000/) dans votre navigateur, où vous verrez le frontend de notre projet. Il devrait se composer d'un champ (un endroit pour mettre à jour le message stocké dans votre contrat intelligent), d'un bouton « Connecter le portefeuille » et d'un bouton « Mettre à jour ».
 
 Si vous essayez de cliquer sur l'un ou l'autre des boutons, vous remarquerez qu'ils ne fonctionnent pas - c'est parce que nous devons encore programmer leur fonctionnalité.
 
-
-
 #### Le composant `HelloWorld.js` {#the-helloworld-js-component}
 
 Retournons dans le dossier `src` de notre éditeur et ouvrons le fichier `HelloWorld.js`. Il est très important de comprendre tout ce qui se trouve dans ce fichier, car c'est le composant principal de React sur lequel nous allons travailler.
 
-En haut de ce fichier, vous remarquerez que nous avons plusieurs instructions d'importation nécessaires pour faire fonctionner notre projet, notamment la bibliothèque React, les accroches useEffect et useState, certains éléments de `./util/interact.js` (nous les décrirons plus en détail bientôt !), et le logo Alchemy.
-
-
+En haut de ce fichier, vous remarquerez que nous avons plusieurs instructions d'importation nécessaires pour faire fonctionner notre projet, y compris la bibliothèque React, les hooks useEffect et useState, certains éléments de `./util/interact.js` (nous les décrirons plus en détail bientôt !), et le logo d'Alchemy.
 
 ```javascript
 // HelloWorld.js
@@ -919,136 +744,123 @@ import {
 import alchemylogo from "./alchemylogo.svg"
 ```
 
-
 Ensuite, nous avons nos variables d'état que nous mettrons à jour après des événements spécifiques.
 
-
-
 ```javascript
 // HelloWorld.js
 
-//State variables
+//Variables d'état
 const [walletAddress, setWallet] = useState("")
 const [status, setStatus] = useState("")
-const [message, setMessage] = useState("No connection to the network.")
+const [message, setMessage] = useState("Pas de connexion au réseau.")
 const [newMessage, setNewMessage] = useState("")
 ```
 
-
 Voici ce que chacune des variables représente :
 
-- `walletAddress` - une chaîne de caractère qui stocke l'adresse du portefeuille de l'utilisateur
-- `status` - une chaîne de caractères qui stocke un message utile guidant l'utilisateur sur la façon d'interagir avec la DApp
+- `walletAddress` : une chaîne qui stocke l'adresse du portefeuille de l'utilisateur
+- `status` - une chaîne de caractères qui stocke un message utile guidant l'utilisateur sur la façon d'interagir avec la dapp
 - `message` - une chaîne qui stocke le message actuel dans le contrat intelligent
 - `newMessage` - une chaîne qui stocke le nouveau message qui sera écrit dans le contrat intelligent
 
-Après les variables d'état, vous verrez cinq fonctions non implémentées : `useEffect` ,`addSmartContractListener`, `addWalletListener` , `connectWalletPressed`, et `onUpdatePressed`. Nous expliquerons ce qu'elles font ci-dessous :
-
-
+Après les variables d'état, vous verrez cinq fonctions non implémentées : `useEffect`, `addSmartContractListener`, `addWalletListener`, `connectWalletPressed`, et `onUpdatePressed`. Nous expliquerons ce qu'elles font ci-dessous :
 
 ```javascript
 // HelloWorld.js
 
-//called only once
+//appelé une seule fois
 useEffect(async () => {
-  //TODO: implement
+  //TODO: implémenter
 }, [])
 
 function addSmartContractListener() {
-  //TODO: implement
+  //TODO: implémenter
 }
 
 function addWalletListener() {
-  //TODO: implement
+  //TODO: implémenter
 }
 
 const connectWalletPressed = async () => {
-  //TODO: implement
+  //TODO: implémenter
 }
 
 const onUpdatePressed = async () => {
-  //TODO: implement
+  //TODO: implémenter
 }
 ```
 
-
-- [`useEffect`](https://reactjs.org/docs/hooks-effect.html) - c'est une accroche React qui est appelé après que votre composant est rendu. Comme il a un tableau vide `[]` passé en prop (voir ligne 4), il ne sera appelé qu'au _premier_ rendu du composant. Ici, nous chargerons le message actuel stocké dans notre contrat intelligent, appellerons nos écouteurs de contrat intelligent et de portefeuille, et mettrons à jour notre interface pour refléter si un portefeuille est déjà connecté.
-- `addSmartContractListener` - cette fonction configure un écouteur qui surveillera l'événement `UpdatedMessages` de notre contrat HelloWorld et mettra à jour notre interface lorsque le message sera modifié dans notre contrat intelligent.
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) - c'est un hook React qui est appelé après que votre composant est rendu. Comme il a un tableau vide `[]` passé en paramètre (voir ligne 4), il ne sera appelé qu'au _premier_ rendu du composant. Ici, nous chargerons le message actuel stocké dans notre contrat intelligent, appellerons nos écouteurs de contrat intelligent et de portefeuille, et mettrons à jour notre interface pour refléter si un portefeuille est déjà connecté.
+- `addSmartContractListener` - cette fonction configure un écouteur qui surveillera l'événement `UpdatedMessages` de notre contrat HelloWorld et mettra à jour notre interface utilisateur lorsque le message sera modifié dans notre contrat intelligent.
 - `addWalletListener` - cette fonction configure un écouteur qui détecte les changements dans l'état du portefeuille MetaMask de l'utilisateur, par exemple lorsque l'utilisateur déconnecte son portefeuille ou change d'adresse.
-- `connectWalletPressed`- cette fonction sera appelée pour connecter le portefeuille MetaMask de l'utilisateur à notre DApp.
+- `connectWalletPressed` - cette fonction sera appelée pour connecter le portefeuille MetaMask de l'utilisateur à notre dapp.
 - `onUpdatePressed` - cette fonction sera appelée lorsque l'utilisateur souhaite mettre à jour le message stocké dans le contrat intelligent.
 
 Vers la fin de ce fichier, nous avons l'interface utilisateur de notre composant.
 
-
-
 ```javascript
 // HelloWorld.js
 
-//the UI of our component
+//l'interface utilisateur de notre composant
 return (
   <div id="container">
     <img id="logo" src={alchemylogo}></img>
     <button id="walletButton" onClick={connectWalletPressed}>
       {walletAddress.length > 0 ? (
-        "Connected: " +
+        "Connecté : " +
         String(walletAddress).substring(0, 6) +
         "..." +
         String(walletAddress).substring(38)
       ) : (
-        <span>Connect Wallet</span>
+        <span>Connecter le portefeuille</span>
       )}
     </button>
 
-    <h2 style={{ paddingTop: "50px" }}>Current Message:</h2>
+    <h2 style={{ paddingTop: "50px" }}>Message actuel :</h2>
     <p>{message}</p>
 
-    <h2 style={{ paddingTop: "18px" }}>New Message:</h2>
+    <h2 style={{ paddingTop: "18px" }}>Nouveau message :</h2>
 
     <div>
       <input
         type="text"
-        placeholder="Update the message in your smart contract."
+        placeholder="Mettez à jour le message dans votre contrat intelligent."
         onChange={(e) => setNewMessage(e.target.value)}
         value={newMessage}
       />
       <p id="status">{status}</p>
 
       <button id="publishButton" onClick={onUpdatePressed}>
-        Update
+        Mettre à jour
       </button>
-    </div>
-  </div>
+</div>
+ 
+</div>
 )
 ```
 
+Si vous analysez attentivement ce code, vous remarquerez où nous utilisons nos différentes variables d'état dans notre interface utilisateur :
 
-Si vous examinez attentivement ce code, vous remarquerez où nous utilisons nos différentes variables d'état dans notre interface :
-
-- Aux lignes 6-12, si le portefeuille de l'utilisateur est connecté \(c'est-à-dire si `walletAddress.length > 0`\), nous affichons une version tronquée de `walletAddress` de l'utilisateur dans le bouton avec l'ID « walletButton » ; sinon, il indique simplement « Connecter le portefeuille. »
-- À la ligne 17, nous affichons le message actuel stocké dans le contrat intelligent, qui est inclus dans la chaîne de caractères `message`.
-- Aux lignes 23-26, nous utilisons un [composant contrôlé](https://reactjs.org/docs/forms.html#controlled-components) pour mettre à jour notre variable d'état `newMessage` lorsque l'entrée dans le champ de texte change.
+- Aux lignes 6-12, si le portefeuille de l'utilisateur est connecté (c'est-à-dire `walletAddress.length > 0`), nous affichons une version tronquée de l'`walletAddress` de l'utilisateur dans le bouton avec l'ID "walletButton"; sinon, il indique simplement "Connecter le portefeuille".
+- À la ligne 17, nous affichons le message actuel stocké dans le contrat intelligent, qui est capturé dans la chaîne `message`.
+- Aux lignes 23-26, nous utilisons un [composant contrôlé](https://legacy.reactjs.org/docs/forms.html#controlled-components) pour mettre à jour notre variable d'état `newMessage` lorsque l'entrée dans le champ de texte change.
 
 En plus de nos variables d'état, vous verrez également que les fonctions `connectWalletPressed` et `onUpdatePressed` sont appelées lorsque les boutons avec les ID `publishButton` et `walletButton` sont cliqués respectivement.
 
-Enfin, regardons où ce composant `HelloWorld.js` est ajouté.
-
-Si vous allez au fichier `App.js`, qui est le composant principal dans React qui sert de conteneur pour tous les autres composants, vous verrez que notre composant `HelloWorld.js` est injecté à la ligne 7.
-
-En dernier lieu, vérifions un autre fichier fourni pour vous, le fichier `interact.js`.
+Enfin, voyons où ce composant `HelloWorld.js` est ajouté.
 
+Si vous allez dans le fichier `App.js`, qui est le composant principal de React agissant comme un conteneur pour tous les autres composants, vous verrez que notre composant `HelloWorld.js` est injecté à la ligne 7.
 
+Enfin et surtout, examinons un autre fichier qui vous est fourni, le fichier `interact.js`.
 
 #### Le fichier `interact.js` {#the-interact-js-file}
 
-Pour respecter le paradigme [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) , nous voulons un fichier séparé qui contient toutes nos fonctions pour gérer la logique, les données, et les règles de notre DApp, puis nous pourrons passer ces fonctions à notre interface \(notre composant `HelloWorld.js` \).
+Parce que nous voulons adhérer au paradigme [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller), nous voudrons un fichier séparé qui contient toutes nos fonctions pour gérer la logique, les données et les règles de notre dapp, puis pouvoir exporter ces fonctions vers notre frontend (notre composant `HelloWorld.js`).
 
 👆🏽C'est exactement le but de notre fichier `interact.js` !
 
 Naviguez vers le dossier `util` dans votre répertoire `src`, et vous remarquerez que nous avons inclus un fichier appelé `interact.js` qui contiendra toutes nos fonctions et variables d'interaction avec le contrat intelligent et le portefeuille.
 
-
-
 ```javascript
 // interact.js
 
@@ -1063,71 +875,55 @@ const getCurrentWalletConnected = async () => {}
 export const updateMessage = async (message) => {}
 ```
 
-
 Vous remarquerez en haut du fichier que nous avons commenté l'objet `helloWorldContract`. Plus tard dans ce tutoriel, nous décommenterons cet objet et instancierons notre contrat intelligent dans cette variable, que nous exporterons ensuite dans notre composant `HelloWorld.js`.
 
 Les quatre fonctions non implémentées après notre objet `helloWorldContract` font ce qui suit :
 
-- `loadCurrentMessage` - cette fonction gère la logique du chargement du message actuel stocké dans le contrat intelligent. Elle effectuera un appel en _lecture_ au contrat intelligent Hello World en utilisant [l'API Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3).
-- `connectWallet` - cette fonction connectera le portefeuille MetaMask de l'utilisateur à notre DApp.
-- `getCurrentWalletConnected` - cette fonction vérifiera si un compte Ethereum est déjà connecté à notre DApp lors du chargement de la page et mettra à jour notre interface en conséquence.
+- `loadCurrentMessage` - cette fonction gère la logique de chargement du message actuel stocké dans le contrat intelligent. Elle effectuera un appel en _lecture_ au contrat intelligent Hello World en utilisant l'[API Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3).
+- `connectWallet` - cette fonction connectera le MetaMask de l'utilisateur à notre dapp.
+- `getCurrentWalletConnected` - cette fonction vérifiera si un compte Ethereum est déjà connecté à notre dapp lors du chargement de la page et mettra à jour notre interface utilisateur en conséquence.
 - `updateMessage` - cette fonction mettra à jour le message stocké dans le contrat intelligent. Elle effectuera un appel en _écriture_ au contrat intelligent Hello World, donc le portefeuille MetaMask de l'utilisateur devra signer une transaction Ethereum pour mettre à jour le message.
 
 Maintenant que nous comprenons avec quoi nous travaillons, voyons comment lire notre contrat intelligent !
 
-
-
 ### Étape 3 : Lire à partir de votre contrat intelligent {#step-3-read-from-your-smart-contract}
 
-Pour lire à partir de votre contrat intelligent, vous devrez configurer correctement :
+Pour lire à partir de votre contrat intelligent, vous devrez configurer avec succès :
 
 - Une connexion API à la chaîne Ethereum
 - Une instance chargée de votre contrat intelligent
-- Une fonction pour appeler votre fonction de contrat intelligent
-- Un écouteur pour surveiller les mises à jour lorsque les données que vous lisez du contrat intelligent changent
+- Une fonction pour appeler la fonction de votre contrat intelligent
+- Un écouteur pour surveiller les mises à jour lorsque les données que vous lisez à partir du contrat intelligent changent
 
 Cela peut sembler beaucoup d'étapes, mais ne vous inquiétez pas ! Nous allons vous guider étape par étape ! :\)
 
-
-
 #### Établir une connexion API à la chaîne Ethereum {#establish-an-api-connection-to-the-ethereum-chain}
 
-Rappelez-vous, dans la Partie 2 de ce tutoriel, comment nous avons utilisé notre clé [Web3 Alchemy pour lire à partir de notre contrat intelligent](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library) ? Vous aurez également besoin d'une clé Web3 Alchemy dans votre DApp pour lire à partir de la chaîne.
-
-Si vous ne l'avez pas déjà fait, installez d'abord [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) en naviguant vers le répertoire racine de vos `starter-files` et en exécutant la commande suivante dans votre terminal :
-
+Alors, souvenez-vous comment, dans la partie 2 de ce tutoriel, nous avons utilisé notre [clé Alchemy Web3 pour lire notre contrat intelligent](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library) ? Vous aurez également besoin d'une clé Alchemy Web3 dans votre dapp pour lire à partir de la chaîne.
 
+Si vous ne l'avez pas déjà, installez d'abord [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) en naviguant vers le répertoire racine de vos `starter-files` et en exécutant la commande suivante dans votre terminal :
 
 ```text
 npm install @alch/alchemy-web3
 ```
 
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) est un wrapper autour de [Web3.js](https://docs.web3js.org/), qui fournit des méthodes API améliorées et d'autres avantages cruciaux pour vous faciliter la vie en tant que développeur web3. Il est conçu pour nécessiter une configuration minimale afin que vous puissiez commencer à l'utiliser immédiatement dans votre application !
 
-[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) est un wrapper autour de [Web3.js](https://docs.web3js.org/), fournissant des méthodes API améliorées et d'autres avantages pour faciliter votre vie en tant que développeur Web3. Il est conçu pour nécessiter une configuration minimale afin que vous puissiez commencer à l'utiliser immédiatement dans votre application !
-
-Ensuite, installez le paquet [dotenv](https://www.npmjs.com/package/dotenv) dans le répertoire de votre projet, afin d'avoir un endroit sécurisé pour stocker notre clé API après l'avoir récupérée.
-
-
+Ensuite, installez le paquet [dotenv](https://www.npmjs.com/package/dotenv) dans le répertoire de votre projet, afin que nous ayons un endroit sécurisé pour stocker notre clé API après l'avoir récupérée.
 
 ```text
 npm install dotenv --save
 ```
 
+Pour notre dapp, **nous utiliserons notre clé API Websockets** au lieu de notre clé API HTTP, car cela nous permettra de mettre en place un écouteur qui détecte lorsque le message stocké dans le contrat intelligent change.
 
-Pour notre dapp, **nous utiliserons notre clé API Websockets** au lieu de notre clé API HTTP, car elle nous permettra d'écouteur pour détecter lorsque le message stocké dans le contrat intelligent change.
-
-Une fois que vous avez votre clé API, créez un fichier `.env` dans votre répertoire racine et ajoutez-y votre URL Websockets Alchemy. Ensuite, votre fichier `.env` devrait ressembler à cela :
-
-
+Une fois que vous avez votre clé API, créez un fichier `.env` dans votre répertoire racine et ajoutez-y votre URL Websockets Alchemy. Ensuite, votre fichier `.env` devrait ressembler à ceci :
 
 ```javascript
 REACT_APP_ALCHEMY_KEY = wss://eth-goerli.ws.alchemyapi.io/v2/<key>
 ```
 
-
-Maintenant, nous sommes prêts à configurer notre point de terminaison Web3 Alchemy dans notre DApp ! Retournons à notre `interact.js`, qui est niché à l'intérieur de notre dossier `util` et ajoutons le code suivant en haut du fichier :
-
-
+Maintenant, nous sommes prêts à configurer notre point de terminaison Alchemy Web3 dans notre dapp ! Retournons à notre `interact.js`, qui est imbriqué dans notre dossier `util`, et ajoutons le code suivant en haut du fichier :
 
 ```javascript
 // interact.js
@@ -1140,30 +936,23 @@ const web3 = createAlchemyWeb3(alchemyKey)
 //export const helloWorldContract;
 ```
 
+Ci-dessus, nous avons d'abord importé la clé Alchemy depuis notre fichier `.env`, puis nous avons passé notre `alchemyKey` à `createAlchemyWeb3` pour établir notre point de terminaison Alchemy Web3.
 
-Ci-dessus, nous avons d'abord importé la clé Alchemy de notre fichier `.env`, puis nous avons passé notre `alchemyKey` à `createAlchemyWeb3` pour établir notre point de terminaison Web3 Alchemy.
-
-Avec ce point de terminaison prêt, il est temps de charger notre contrat intelligent Hello World !
-
-
+Avec ce point de terminaison prêt, il est temps de charger notre contrat intelligent !
 
 #### Chargement de votre contrat intelligent Hello World {#loading-your-hello-world-smart-contract}
 
-Pour charger votre contrat intelligent Hello World, vous aurez besoin de son adresse de contrat et de son ABI, tous deux disponibles sur Etherscan si vous avez terminé [la Partie 3 de ce tutoriel.](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan)
-
-
+Pour charger votre contrat intelligent Hello World, vous aurez besoin de son adresse de contrat et de son ABI, qui peuvent tous deux être trouvés sur Etherscan si vous avez terminé la [Partie 3 de ce tutoriel](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan).
 
-#### Comment obtenir votre ABI de contrat depuis Etherscan {#how-to-get-your-contract-abi-from-etherscan}
+#### Comment obtenir l'ABI de votre contrat depuis Etherscan {#how-to-get-your-contract-abi-from-etherscan}
 
-Si vous avez ignoré la Partie 3 de ce tutoriel, vous pouvez utiliser le contrat HelloWorld avec l'adresse [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code). Son ABI se trouve [ici](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code).
+Si vous avez sauté la partie 3 de ce tutoriel, vous pouvez utiliser le contrat HelloWorld avec l'adresse [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code). Son ABI peut être trouvé [ici](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code).
 
-Un ABI de contrat est nécessaire pour spécifier quelle fonction un contrat invoquera et pour garantir que la fonction renverra des données dans le format que vous attendez. Une fois que nous avons copié notre ABI de contrat, sauvegardons-le en tant que fichier JSON appelé `contract-abi.json` dans votre répertoire `src`.
+L'ABI d'un contrat est nécessaire pour spécifier quelle fonction un contrat invoquera, ainsi que pour s'assurer que la fonction renverra des données dans le format que vous attendez. Une fois que nous avons copié l'ABI de notre contrat, sauvegardons-le en tant que fichier JSON appelé `contract-abi.json` dans votre répertoire `src`.
 
 Votre contract-abi.json doit être stocké dans votre dossier src.
 
-Armé de notre adresse de contrat, de notre ABI, et de notre point de terminaison Web3 Alchemy, nous pouvons utiliser [la méthode de contrat](https://docs.web3js.org/api/web3-eth-contract/class/Contract) pour charger une instance de notre contrat intelligent. Importez votre ABI de contrat dans le fichier `interact.js` et ajoutez votre adresse de contrat.
-
-
+Armés de l'adresse de notre contrat, de l'ABI et du point de terminaison Alchemy Web3, nous pouvons utiliser la [méthode de contrat](https://docs.web3js.org/api/web3-eth-contract/class/Contract) pour charger une instance de notre contrat intelligent. Importez l'ABI de votre contrat dans le fichier `interact.js` et ajoutez l'adresse de votre contrat.
 
 ```javascript
 // interact.js
@@ -1172,11 +961,8 @@ const contractABI = require("../contract-abi.json")
 const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
 ```
 
-
 Nous pouvons maintenant enfin décommenter notre variable `helloWorldContract` et charger le contrat intelligent en utilisant notre point de terminaison AlchemyWeb3 :
 
-
-
 ```javascript
 // interact.js
 export const helloWorldContract = new web3.eth.Contract(
@@ -1185,11 +971,8 @@ export const helloWorldContract = new web3.eth.Contract(
 )
 ```
 
-
 Pour récapituler, les 12 premières lignes de votre `interact.js` devraient maintenant ressembler à ceci :
 
-
-
 ```javascript
 // interact.js
 
@@ -1207,19 +990,15 @@ export const helloWorldContract = new web3.eth.Contract(
 )
 ```
 
+Maintenant que notre contrat est chargé, nous pouvons implémenter notre fonction `loadCurrentMessage` !
 
-Maintenant que nous avons notre contrat chargé, nous pouvons implémenter notre fonction `loadCurrentMessage` !
-
-
+#### Implémentation de `loadCurrentMessage` dans votre fichier `interact.js` {#implementing-loadCurrentMessage-in-your-interact-js-file}
 
-#### Implémenter `loadCurrentMessage` dans votre fichier `interact.js` {#implementing-loadCurrentMessage-in-your-interact-js-file}
-
-Cette fonction est très simple. Nous allons effectuer un simple appel web3 asynchrone pour lire notre contrat. Notre fonction renverra le message stocké dans le contrat intelligent :
+Cette fonction est très simple. Nous allons faire un simple appel web3 asynchrone pour lire notre contrat. Notre fonction renverra le message stocké dans le contrat intelligent :
 
 Mettez à jour la fonction `loadCurrentMessage` dans votre fichier `interact.js` comme suit :
 
 
-
 ```javascript
 // interact.js
 
@@ -1229,70 +1008,60 @@ export const loadCurrentMessage = async () => {
 }
 ```
 
-
 Puisque nous voulons afficher ce contrat intelligent dans notre interface utilisateur, mettons à jour la fonction `useEffect` dans notre composant `HelloWorld.js` comme suit :
 
-
-
 ```javascript
 // HelloWorld.js
 
-//called Orly once
+//appelé une seule fois
 useEffect(async () => {
   const message = await loadCurrentMessage()
-  sertissage(message)
+  setMessage(message)
 }, [])
 ```
 
+Notez que nous voulons que notre `loadCurrentMessage` ne soit appelé qu'une seule fois lors du premier rendu du composant. Nous allons bientôt implémenter `addSmartContractListener` pour mettre à jour automatiquement l'interface utilisateur après que le message dans le contrat intelligent a changé.
 
-Notez que nous voulons que notre `loadCurrentMessage` soit appelé une seule fois lors du premier rendu du composant. Nous allons bientôt implémenter `addSmartContractListener` pour mettre à jour automatiquement l'interface utilisateur après la modification du message dans le contrat intelligent.
-
-Avant de plonger dans notre système d'écoute, voyons ce que nous avons jusqu'à présent ! Sauvegardez vos fichiers `HelloWorld.js` et `interact.js`, puis allez sur [http://localhost:3000/](http://localhost:3000/)
-
-Vous remarquerez que le message actuel ne dit plus « Pas de connexion au réseau. » Au lieu de cela, il reflète le message stocké dans le contrat intelligent. C'est fou !
-
+Avant de nous plonger dans notre écouteur, voyons ce que nous avons jusqu'à présent ! Enregistrez vos fichiers `HelloWorld.js` et `interact.js`, puis allez sur [http://localhost:3000/](http://localhost:3000/)
 
+Vous remarquerez que le message actuel ne dit plus « Pas de connexion au réseau ». Au lieu de cela, il reflète le message stocké dans le contrat intelligent. Génial !
 
 #### Votre interface utilisateur devrait maintenant refléter le message stocké dans le contrat intelligent {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
 
-Maintenant, parlons de cet écouteur...
-
-
-
-#### Mettre en œuvre `addSmartContractListener` {#implement-addsmartcontractlistener}
-
-Si vous repensez au fichier `HelloWorld.sol` que nous avons écrit dans [la première partie de cette série de tutoriels](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract), vous vous souviendrez qu'il y a un événement de contrat intelligent appelé `UpdatedMessages` qui est émis après que la fonction `update` de notre contrat intelligent soit invoquée \(voir les lignes 9 et 27\) :
+Maintenant, en parlant de cet écouteur...
 
+#### Implémenter `addSmartContractListener` {#implement-addsmartcontractlistener}
 
+Si vous repensez au fichier `HelloWorld.sol` que nous avons écrit dans la [Partie 1 de cette série de tutoriels](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract), vous vous souviendrez qu'il y a un événement de contrat intelligent appelé `UpdatedMessages` qui est émis après l'invocation de la fonction `update` de notre contrat intelligent \(voir lignes 9 et 27\) :
 
 ```javascript
 // HelloWorld.sol
 
-// Specifies the version of Solidity, using semantic versioning.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// Spécifie la version de Solidity, en utilisant le versionnage sémantique.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
 pragma solidity ^0.7.3;
 
-// Defines a contract named `HelloWorld`.
-// A contract is a collection of functions and data (its state). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// Définit un contrat nommé `HelloWorld`.
+// Un contrat est une collection de fonctions et de données (son état). Une fois déployé, un contrat réside à une adresse spécifique sur la blockchain Ethereum. En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
 contract HelloWorld {
 
-   //Emitted when update function is called
-   //Smart contract events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be 'listening' for certain events and take action when they happen.
+   //Émis lorsque la fonction de mise à jour est appelée
+   //Les événements de contrat intelligent sont un moyen pour votre contrat de communiquer que quelque chose s'est passé sur la blockchain à votre interface d'application, qui peut « écouter » certains événements et prendre des mesures lorsqu'ils se produisent.
    event UpdatedMessages(string oldStr, string newStr);
 
-   // Declares a state variable `message` of type `string`.
-   // State variables are variables whose values are permanently stored in contract storage. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+   // Déclare une variable d'état `message` de type `string`.
+   // Les variables d'état sont des variables dont les valeurs sont stockées en permanence dans le stockage du contrat. Le mot-clé `public` rend les variables accessibles depuis l'extérieur d'un contrat et crée une fonction que d'autres contrats ou clients peuvent appeler pour accéder à la valeur.
    string public message;
 
-   // Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
-   // Constructors are used to initialize the contract's data. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+   // Semblable à de nombreux langages orientés objet basés sur les classes, un constructeur est une fonction spéciale qui n'est exécutée qu'à la création du contrat.
+   // Les constructeurs sont utilisés pour initialiser les données du contrat. En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
    constructor(string memory initMessage) {
 
-      // Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
+      // Accepte un argument de chaîne `initMessage` et définit la valeur dans la variable de stockage `message` du contrat).
       message = initMessage;
    }
 
-   // A public function that accepts a string argument and updates the `message` storage variable.
+   // Une fonction publique qui accepte un argument de chaîne et met à jour la variable de stockage `message`.
    function update(string memory newMessage) public {
       string memory oldMsg = message;
       message = newMessage;
@@ -1301,14 +1070,11 @@ contract HelloWorld {
 }
 ```
 
-
-Les événements de contrat intelligent sont un moyen pour votre contrat d'indiquer qu'un événement s'est produit (c'est-à-dire qu'il y a eu un _événement_) sur la blockchain à votre application front-end, qui peut « écouter » des événements spécifiques et agir lorsqu'ils se produisent.
+Les événements de contrat intelligent sont un moyen pour votre contrat de communiquer qu'un événement s'est produit (c'est-à-dire qu'il y a eu un _événement_) sur la blockchain à votre application frontale, qui peut être à l'« écoute » d'événements spécifiques et prendre des mesures lorsqu'ils se produisent.
 
 La fonction `addSmartContractListener` va spécifiquement écouter l'événement `UpdatedMessages` de notre contrat intelligent Hello World et mettre à jour notre interface utilisateur pour afficher le nouveau message.
 
-Modifiez `addSmartContractListener` de la manière suivante :
-
-
+Modifiez `addSmartContractListener` comme suit :
 
 ```javascript
 // HelloWorld.js
@@ -1320,21 +1086,18 @@ function addSmartContractListener() {
     } else {
       setMessage(data.returnValues[1])
       setNewMessage("")
-      setStatus("🎉 Your message has been updated!")
+      setStatus("🎉 Votre message a été mis à jour !")
     }
   })
 }
 ```
 
-
-Décortiquons ce qui se passe lorsque l'écouteur détecte un événement :
+Analysons ce qui se passe lorsque l'écouteur détecte un événement :
 
 - Si une erreur se produit lorsque l'événement est émis, elle sera reflétée dans l'interface utilisateur via notre variable d'état `status`.
-- Sinon, nous utiliserons l'objet `data` renvoyé. Le `data.returnValues` est un tableau indexé à zéro où le premier élément du tableau stocke le message précédent et le deuxième élément stocke le message mis à jour. En somme, lors d'un événement réussi, nous définirons notre chaîne de `message` sur le message mis à jour, effacerons la chaîne `newMessage` et mettrons à jour notre variable d'état `status` pour indiquer qu'un nouveau message a été publié sur notre contrat intelligent.
-
-Enfin, appelons notre écouteur dans notre fonction `useEffect` afin qu'il soit initialisé lors du premier rendu du composant `HelloWorld.js`. Dans l'ensemble, votre fonction `useEffect` devrait ressembler à ceci :
-
+- Sinon, nous utiliserons l'objet `data` renvoyé. L'objet `data.returnValues` est un tableau indexé à zéro où le premier élément du tableau contient le message précédent et le second le message mis à jour. En somme, lors d'un événement réussi, nous définirons notre chaîne `message` sur le message mis à jour, effacerons la chaîne `newMessage` et mettrons à jour notre variable d'état `status` pour indiquer qu'un nouveau message a été publié sur notre contrat intelligent.
 
+Enfin, appelons notre écouteur dans notre fonction `useEffect` afin qu'il soit initialisé lors du premier rendu du composant `HelloWorld.js`. Globalement, votre fonction `useEffect` devrait ressembler à ceci :
 
 ```javascript
 // HelloWorld.js
@@ -1346,64 +1109,46 @@ useEffect(async () => {
 }, [])
 ```
 
+Maintenant que nous pouvons lire notre contrat intelligent, il serait formidable de savoir comment y écrire aussi ! Cependant, pour écrire dans notre dapp, nous devons d'abord y connecter un portefeuille Ethereum.
 
-Maintenant que nous sommes capables de lire notre contrat intelligent, il serait bien de savoir comment y écrire aussi ! Cependant, pour écrire sur notre dapp, nous devons d'abord avoir un portefeuille Ethereum connecté à celle-ci.
-
-Alors, ensuite, nous aborderons la configuration de notre portefeuille Ethereum (MetaMask) et sa connexion à notre dapp !
-
-
-
-### Étape 4 : Configurez votre portefeuille Ethereum {#step-4-set-up-your-ethereum-wallet}
-
-Pour écrire quoi que ce soit sur la chaîne Ethereum, les utilisateurs doivent signer des transactions à l'aide des clés privées de leur portefeuille virtuel. Pour ce tutoriel, nous utiliserons [MetaMask](https://metamask.io/), un portefeuille virtuel dans le navigateur utilisé pour gérer votre adresse de compte Ethereum, car il rend cette signature de transaction très facile pour l'utilisateur final.
-
-Si vous voulez en savoir plus sur le fonctionnement des transactions sur Ethereum, consultez [cette page](/developers/docs/transactions/) de la fondation Ethereum.
+Donc, nous allons ensuite nous occuper de la configuration de notre portefeuille Ethereum \(MetaMask\) puis de sa connexion à notre dapp !
 
+### Étape 4 : Configurer votre portefeuille Ethereum {#step-4-set-up-your-ethereum-wallet}
 
+Pour écrire quoi que ce soit sur la chaîne Ethereum, les utilisateurs doivent signer des transactions à l'aide des clés privées de leur portefeuille virtuel. Pour ce tutoriel, nous utiliserons [MetaMask](https://metamask.io/), un portefeuille virtuel dans le navigateur utilisé pour gérer l'adresse de votre compte Ethereum, car il rend cette signature de transaction très facile pour l'utilisateur final.
 
-#### Téléchargez MetaMask {#download-metamask}
+Si vous voulez mieux comprendre le fonctionnement des transactions sur Ethereum, consultez [cette page](/developers/docs/transactions/) de la Fondation Ethereum.
 
-Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer vers le « Goerli Test Network » en haut à droite \(afin que nous ne traitions pas avec de l'argent réel\).
+#### Télécharger MetaMask {#download-metamask}
 
+Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer vers le « Réseau de test Goerli » en haut à droite \(afin de ne pas utiliser d'argent réel\).
 
+#### Ajouter de l'ether depuis un robinet {#add-ether-from-a-faucet}
 
-#### Ajoutez de l'ether depuis un Robinet {#add-ether-from-a-faucet}
-
-Pour signer une transaction sur la blockchain Ethereum, nous aurons besoin de faux Eth. Pour obtenir de l'Eth, vous pouvez aller sur [FaucETH](https://fauceth.komputing.org) et entrer votre adresse de compte Goerli, cliquer sur « Demander des fonds », puis sélectionner « Ethereum Testnet Goerli » dans le menu déroulant et enfin cliquer à nouveau sur le bouton « Demander des fonds ». Vous devriez voir les ETH dans votre compte MetaMask peu de temps après !
-
-
+Pour signer une transaction sur la blockchain Ethereum, nous aurons besoin de faux Eth. Pour obtenir de l'Eth, vous pouvez vous rendre sur [FaucETH](https://fauceth.komputing.org), saisir l'adresse de votre compte Goerli, cliquer sur « Request funds », puis sélectionner « Ethereum Testnet Goerli » dans le menu déroulant et enfin cliquer à nouveau sur le bouton « Request funds ». Vous devriez voir les ETH dans votre compte MetaMask peu de temps après !
 
 #### Vérifiez votre solde {#check-your-balance}
 
-Pour revérifier que votre solde est correct, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant [l'outil Alchemy Composer](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va retourner la quantité d'ETH que contient votre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
-
-
+Pour vérifier que notre solde est bien là, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant l'[outil de composition d'Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va retourner la quantité d'ETH que contient votre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
 
 ```text
 {"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
 ```
 
-
-**REMARQUE :** Ce résultat est en wei et non pas en ETH. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion de wei vers eth est : 1 eth = 10¹⁸ wei. Donc si on convertit 0xde0b6b3a7640000 en nombre décimal, nous obtenons 1\*10¹⁸ ce qui correspond à 1 eth.
+**REMARQUE :** ce résultat est en wei et non en eth. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion de wei vers eth est : 1 eth = 10¹⁸ wei. Donc si on convertit 0xde0b6b3a7640000 en nombre décimal, nous obtenons 1\*10¹⁸ ce qui correspond à 1 eth.
 
 Ouf ! Notre faux argent est bien là ! 🤑
 
-
-
-### Étape 5 : Connectez MetaMask à votre interface utilisateur {#step-5-connect-metamask-to-your-UI}
+### Étape 5 : Connecter MetaMask à votre interface utilisateur {#step-5-connect-metamask-to-your-UI}
 
 Maintenant que notre portefeuille MetaMask est configuré, connectons-y notre dApp !
 
-
-
 #### La fonction `connectWallet` {#the-connectWallet-function}
 
 Dans notre fichier `interact.js`, implémentons la fonction `connectWallet`, que nous pourrons ensuite appeler dans notre composant `HelloWorld.js`.
 
 Modifions `connectWallet` comme suit :
 
-
-
 ```javascript
 // interact.js
 
@@ -1414,7 +1159,7 @@ export const connectWallet = async () => {
         method: "eth_requestAccounts",
       })
       const obj = {
-        status: "👆🏽 Write a message in the text-field above.",
+        status: "👆🏽 Écrivez un message dans le champ de texte ci-dessus.",
         address: addressArray[0],
       }
       return obj
@@ -1432,8 +1177,8 @@ export const connectWallet = async () => {
           <p>
             {" "}
             🦊 <a target="_blank" href={`https://metamask.io/download`}>
-              You must install MetaMask, a virtual Ethereum wallet, in your
-              browser.
+              Vous devez installer MetaMask, un portefeuille Ethereum virtuel, dans votre
+              navigateur.
             </a>
           </p>
         </span>
@@ -1443,32 +1188,27 @@ export const connectWallet = async () => {
 }
 ```
 
+Alors, que fait exactement ce bloc de code géant ?
 
-Qu'est-ce que cet immense bloc de code fait exactement ?
-
-Eh bien, premièrement, il vérifie si `window.ethereum` est activé dans votre navigateur.
+Eh bien, d'abord, il vérifie si `window.ethereum` est activé dans votre navigateur.
 
-`window.ethereum` est une API globale injectée par MetaMask et d'autres fournisseurs de portefeuille qui permet aux sites web de faire des requêtes vers les comptes Ethereum des utilisateurs. Si approuvé, il peut lire des données des blockchains auxquelles l'utilisateur est connecté et suggérer que l'utilisateur signe des messages et des transactions. Consultez la [documentation MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) pour plus d'infos !
+`window.ethereum` est une API globale injectée par MetaMask et d'autres fournisseurs de portefeuilles qui permet aux sites Web de demander les comptes Ethereum des utilisateurs. S'il est approuvé, il peut lire des données des blockchains auxquelles l'utilisateur est connecté, et suggérer à l'utilisateur de signer des messages et des transactions. Consultez la [documentation de MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) pour plus d'informations !
 
-Si `window.ethereum` _n'est pas_ présent, alors cela signifie que Metamask n'est pas installé. Cela se traduit par un objet JSON retourné, où l'attribut `adresse` retourné est une chaîne vide, et le `status` de l'objet JSX indique que l'utilisateur doit installer MetaMask.
+Si `window.ethereum` n'_est pas_ présent, cela signifie que MetaMask n'est pas installé. Cela se traduit par le renvoi d'un objet JSON, où l'`address` renvoyée est une chaîne vide, et où l'objet `status` JSX relaie que l'utilisateur doit installer MetaMask.
 
-Maintenant, si `window.ethereum` _est présent_, alors c'est là que les choses deviennent intéressantes.
+Maintenant, si `window.ethereum` _est_ présent, c'est là que les choses deviennent intéressantes.
 
-À l'aide d'une boucle try/catch, nous essaierons de nous connecter à MetaMask en appelant[`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts). L'appel de cette fonction ouvrira MetaMask dans le navigateur, où l'utilisateur sera invité à connecter son portefeuille à votre dApp.
+À l'aide d'une boucle try/catch, nous allons essayer de nous connecter à MetaMask en appelant [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts). L'appel de cette fonction ouvrira MetaMask dans le navigateur, où l'utilisateur sera invité à connecter son portefeuille à votre dApp.
 
-- Si l'utilisateur choisit de se connecter, `method: "eth_requestAccounts"` retournera un tableau contenant toutes les adresses de compte de l'utilisateur qui sont connectées à la DApp. Au final, notre fonction `connectWallet` retourne un objet JSON qui contient la _première_ `address` dans cette table \(voir ligne 9\\) et un message `status` qui invite l'utilisateur à écrire un message sur le contrat intelligent.
-- Si l'utilisateur rejette la connexion, alors l'objet JSON contiendra une chaîne vide pour l'`address` retournée et un message `status` qui indique que l'utilisateur a rejeté la connexion.
+- Si l'utilisateur choisit de se connecter, `method: "eth_requestAccounts"` renverra un tableau contenant toutes les adresses de compte de l'utilisateur connectées à la dapp. Au total, notre fonction `connectWallet` renverra un objet JSON qui contient la _première_ `adresse` de ce tableau \(voir ligne 9\) et un message `d'état` qui invite l'utilisateur à écrire un message au contrat intelligent.
+- Si l'utilisateur rejette la connexion, l'objet JSON contiendra une chaîne vide pour l'`address` renvoyée et un message `d'état` indiquant que l'utilisateur a rejeté la connexion.
 
 Maintenant que nous avons écrit cette fonction `connectWallet`, la prochaine étape est de l'appeler dans notre composant `HelloWorld.js`.
 
-
-
-#### Ajoutez la fonction `connectWallet` à votre composant UI `HelloWorld.js` {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
+#### Ajouter la fonction `connectWallet` à votre composant d'interface `HelloWorld.js` {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
 
 Naviguez vers la fonction `connectWalletPressed` dans `HelloWorld.js`, et mettez-la à jour comme suit :
 
-
-
 ```javascript
 // HelloWorld.js
 
@@ -1479,31 +1219,26 @@ const connectWalletPressed = async () => {
 }
 ```
 
-
 Remarquez comment la plupart de nos fonctionnalités sont abstraites de notre composant `HelloWorld.js` à partir du fichier `interact.js` ? C'est ainsi que nous respectons le paradigme M-V-C !
 
-Dans `connectWalletPressed`, nous faisons simplement un appel await à notre fonction importée `connectWallet`, et en utilisant sa réponse, nous mettons à jour nos variables `status` et `walletAddress` via leurs hooks d'états.
+Dans `connectWalletPressed`, nous effectuons simplement un appel en attente vers notre fonction importée `connectWallet` et, à l'aide de sa réponse, nous mettons à jour nos variables `status` et `walletAddress` via leurs hooks d'état.
 
-Maintenant, sauvegardez les deux fichiers \(`HelloWorld.js` et `interact.js`\) et testez notre interface jusqu'à présent.
+Maintenant, enregistrons les deux fichiers \(`HelloWorld.js` et `interact.js`\) et testons notre interface utilisateur jusqu'à présent.
 
 Ouvrez votre navigateur sur la page [http://localhost:3000/](http://localhost:3000/), et appuyez sur le bouton « Connecter le portefeuille » en haut à droite de la page.
 
-Si MetaMask est installé, vous devriez être invité à connecter votre portefeuille à votre dApp. Accepter l'invitation à se connecter.
+Si MetaMask est installé, vous devriez être invité à connecter votre portefeuille à votre dApp. Acceptez l'invitation à se connecter.
 
-Vous devriez voir que le bouton du portefeuille reflète maintenant le fait que votre adresse est connectée ! Incroyable 🔥
+Vous devriez voir que le bouton du portefeuille indique maintenant que votre adresse est connectée ! Yessss 🔥
 
 Ensuite, essayez de rafraîchir la page... c'est étrange. Notre bouton de portefeuille nous invite à connecter MetaMask bien qu'il soit déjà connecté...
 
-Mais n'ayez crainte ! Nous pouvons facilement résoudre cela (compris ?) en implémentant la fonction `getCurrentWalletConnected`, qui vérifiera si une adresse est déjà connectée à notre dapp et mettra à jour notre interface en conséquence !
-
-
+Cependant, n'ayez crainte ! Nous pouvons facilement résoudre ce problème en implémentant `getCurrentWalletConnected`, qui vérifiera si une adresse est déjà connectée à notre dapp et mettra à jour notre interface utilisateur en conséquence !
 
 #### La fonction `getCurrentWalletConnected` {#the-getcurrentwalletconnected-function}
 
 Mettez à jour votre fonction `getCurrentWalletConnected` dans le fichier `interact.js` comme suit :
 
-
-
 ```javascript
 // interact.js
 
@@ -1516,12 +1251,12 @@ export const getCurrentWalletConnected = async () => {
       if (addressArray.length > 0) {
         return {
           address: addressArray[0],
-          status: "👆🏽 Write a message in the text-field above.",
+          status: "👆🏽 Écrivez un message dans le champ de texte ci-dessus.",
         }
       } else {
         return {
           address: "",
-          status: "🦊 Connect to MetaMask using the top right button.",
+          status: "🦊 Connectez-vous à MetaMask en utilisant le bouton en haut à droite.",
         }
       }
     } catch (err) {
@@ -1538,8 +1273,8 @@ export const getCurrentWalletConnected = async () => {
           <p>
             {" "}
             🦊 <a target="_blank" href={`https://metamask.io/download`}>
-              You must install MetaMask, a virtual Ethereum wallet, in your
-              browser.
+              Vous devez installer MetaMask, un portefeuille Ethereum virtuel, dans votre
+              navigateur.
             </a>
           </p>
         </span>
@@ -1549,15 +1284,12 @@ export const getCurrentWalletConnected = async () => {
 }
 ```
 
-
 Ce code est _très_ similaire à la fonction `connectWallet` que nous venons d'écrire à l'étape précédente.
 
-La différence principale est qu'au lieu d'appeler la méthode `eth_requestAccounts`, qui ouvre MetaMask pour que l'utilisateur puisse connecter son portefeuille, ici nous appelons la méthode `eth_accounts`, qui renvoie simplement un tableau contenant les adresses MetaMask actuellement connectées à notre dApp.
+La principale différence est qu'au lieu d'appeler la méthode `eth_requestAccounts`, qui ouvre MetaMask pour que l'utilisateur connecte son portefeuille, nous appelons ici la méthode `eth_accounts`, qui renvoie simplement un tableau contenant les adresses MetaMask actuellement connectées à notre dapp.
 
 Pour voir cette fonction en action, appelons-la dans notre fonction `useEffect` de notre composant `HelloWorld.js` :
 
-
-
 ```javascript
 // HelloWorld.js
 
@@ -1572,23 +1304,18 @@ useEffect(async () => {
 }, [])
 ```
 
-
-Remarquez que nous utilisons la réponse de notre appel à `getCurrentWalletConnected` pour mettre à jour nos variables d'état `walletAddress` et `status`.
+Notez que nous utilisons la réponse de notre appel à `getCurrentWalletConnected` pour mettre à jour nos variables d'état `walletAddress` et `status`.
 
 Maintenant que vous avez ajouté ce code, essayons de rafraîchir la fenêtre de notre navigateur.
 
-Magnifique ! Le bouton devrait indiquer que vous êtes connecté et afficher un aperçu de l'adresse de votre portefeuille connecté, même après avoir été actualisé !
-
+Géniaaaal ! Le bouton devrait indiquer que vous êtes connecté et afficher un aperçu de l'adresse de votre portefeuille connecté, même après avoir été actualisé !
 
-
-#### Mettre en œuvre `addWalletListener` {#implement-addwalletlistener}
+#### Implémenter `addWalletListener` {#implement-addwalletlistener}
 
 La dernière étape de la configuration de notre dApp de portefeuille consiste à mettre en place le listener de portefeuille afin que notre interface utilisateur soit mise à jour lorsque l'état de notre portefeuille change, par exemple lorsque l'utilisateur se déconnecte ou change de compte.
 
 Dans votre fichier `HelloWorld.js`, modifiez votre fonction `addWalletListener` comme suit :
 
-
-
 ```javascript
 // HelloWorld.js
 
@@ -1597,10 +1324,10 @@ function addWalletListener() {
     window.ethereum.on("accountsChanged", (accounts) => {
       if (accounts.length > 0) {
         setWallet(accounts[0])
-        setStatus("👆🏽 Write a message in the text-field above.")
+        setStatus("👆🏽 Écrivez un message dans le champ de texte ci-dessus.")
       } else {
         setWallet("")
-        setStatus("🦊 Connect to MetaMask using the top right button.")
+        setStatus("🦊 Connectez-vous à MetaMask en utilisant le bouton en haut à droite.")
       }
     })
   } else {
@@ -1608,7 +1335,7 @@ function addWalletListener() {
       <p>
         {" "}
         🦊 <a target="_blank" href={`https://metamask.io/download`}>
-          You must install MetaMask, a virtual Ethereum wallet, in your browser.
+          Vous devez installer MetaMask, un portefeuille Ethereum virtuel, dans votre navigateur.
         </a>
       </p>
     )
@@ -1616,17 +1343,14 @@ function addWalletListener() {
 }
 ```
 
+Je parie que vous n'avez même pas besoin de notre aide pour comprendre ce qui se passe ici à ce stade, mais pour des raisons d'exhaustivité, décomposons rapidement :
 
-Je parie que vous n'avez même pas besoin de notre aide pour comprendre ce qui se passe ici à ce stade, mais pour des raisons de rigueur, décomposons rapidement :
-
-- Premièrement, notre fonction vérifie si `window.ethereum` est activé \(ex. : MetaMask est installé\).
-    - Si ce n'est pas le cas, nous fixons simplement notre variable d'état `status` à une chaîne de caractères JSX qui invite l'utilisateur à installer MetaMask.
-  - S'il est activé, nous configurons le listener `window.ethereum.on("accountsChanged")` à la ligne 3 qui écoute les changements d'état dans le portefeuille MetaMask, qui les incluent lorsque l'utilisateur connecte un compte additionnel à la dApp, change de compte ou déconnecte un compte. S'il existe au moins un compte connecté, la variable d'état `walletAddress` est mise à jour comme premier compte dans le tableau des comptes `accounts` retourné par l'écouteur. Sinon, `walletAdresse` est défini comme une chaîne de caractères vide.
+- Tout d'abord, notre fonction vérifie si `window.ethereum` est activé \(c'est-à-dire si MetaMask est installé\).
+  - Si ce n'est pas le cas, nous définissons simplement notre variable d'état `status` sur une chaîne JSX qui invite l'utilisateur à installer MetaMask.
+  - S'il est activé, nous configurons l'écouteur `window.ethereum.on("accountsChanged")` à la ligne 3 qui écoute les changements d'état dans le portefeuille MetaMask, qui incluent le moment où l'utilisateur connecte un compte supplémentaire à la dapp, change de compte ou déconnecte un compte. S'il y a au moins un compte connecté, la variable d'état `walletAddress` est mise à jour en tant que premier compte dans le tableau `accounts` renvoyé par l'écouteur. Sinon, `walletAddress` est défini comme une chaîne vide.
 
 Enfin et surtout, nous devons l'appeler dans notre fonction `useEffect` :
 
-
-
 ```javascript
 // HelloWorld.js
 
@@ -1643,30 +1367,23 @@ useEffect(async () => {
 }, [])
 ```
 
+Et c'est tout ! Nous avons terminé avec succès la programmation de toutes les fonctionnalités de notre portefeuille ! Passons maintenant à notre dernière tâche : mettre à jour le message stocké dans notre contrat intelligent !
 
-Et voilà ! Nous avons réussi à programmer toute notre fonctionnalité de portefeuille ! Passons maintenant à notre dernière tâche : mettre à jour le message stocké dans notre contrat intelligent !
-
-
-
-### Étape 6 : Implémentez la fonction `updateMessage` {#step-6-implement-the-updateMessage-function}
-
-Alright, nous sommes dans la dernière ligne droite ! Dans la fonction `updateMessage` de votre fichier `interact.js`, nous allons faire ce qui suit :
-
-1. Vérifiez que le message que nous souhaitons publier dans notre contrat intelligent est valide
-2. Signez notre transaction à l'aide de MetaMask
-3. Appelez cette fonction depuis notre composant d'interface `HelloWorld.js`
+### Étape 6 : Implémenter la fonction `updateMessage` {#step-6-implement-the-updateMessage-function}
 
-Cela ne prendra pas très longtemps ; terminons cette dapp !
+C'est parti, nous sommes dans la dernière ligne droite ! Dans la fonction `updateMessage` de votre fichier `interact.js`, nous allons faire ce qui suit :
 
+1. S'assurer que le message que nous souhaitons publier dans notre contact intelligent est valide
+2. Signer notre transaction en utilisant MetaMask
+3. Appeler cette fonction depuis notre composant frontend `HelloWorld.js`
 
+Cela ne prendra pas très longtemps ; finissons cette dapp !
 
-#### Gestion des erreurs d'entrée {#input-error-handling}
-
-Naturellement, il est logique de disposer d'une sorte de gestion des erreurs d'entrée au début de la fonction.
-
-Nous souhaitons que notre fonction se termine rapidement s'il n'y a pas d'extension MetaMask installée, si aucun portefeuille n'est connecté \(c'est-à-dire si l'`adresse` transmise est une chaîne vide) ou si le `message` est une chaîne vide. Ajoutons la gestion des erreurs suivante à `updateMessage` :
+#### Gestion des erreurs de saisie {#input-error-handling}
 
+Naturellement, il est logique d'avoir une sorte de gestion des erreurs de saisie au début de la fonction.
 
+Nous voudrons que notre fonction se termine prématurément s'il n'y a pas d'extension MetaMask installée, si aucun portefeuille n'est connecté \(c'est-à-dire que l'`address` transmise est une chaîne vide\), ou si le `message` est une chaîne vide. Ajoutons la gestion des erreurs suivante à `updateMessage` :
 
 ```javascript
 // interact.js
@@ -1675,40 +1392,35 @@ export const updateMessage = async (address, message) => {
   if (!window.ethereum || address === null) {
     return {
       status:
-        "💡 Connecter votre portefeuille MetaMask pour mettre à jour le message sur la blockchain.",
+        "💡 Connectez votre portefeuille MetaMask pour mettre à jour le message sur la blockchain.",
     }
   }
 
   if (message.trim() === "") {
     return {
-      status: "❌ Votre message ne peut pas être vide.",
+      status: "❌ Votre message ne peut pas être une chaîne vide.",
     }
   }
 }
 ```
 
-
-Maintenant que nous avons une gestion d'erreur d'entrée appropriée, il est temps de signer la transaction via MetaMask !
-
-
+Maintenant que nous avons une bonne gestion des erreurs de saisie, il est temps de signer la transaction via MetaMask !
 
 #### Signer notre transaction {#signing-our-transaction}
 
-Si vous êtes déjà à l'aise avec les transactions Ethereum web3 traditionnelles, le code que nous écrirons ensuite vous sera très familier. Sous votre code de gestion d'erreur d'entrée, ajoutez ce qui suit à `updateMessage` :
-
-
+Si vous êtes déjà à l'aise avec les transactions Ethereum traditionnelles de web3, le code que nous écrirons ensuite vous sera très familier. Sous votre code de gestion des erreurs de saisie, ajoutez ce qui suit à `updateMessage` :
 
 ```javascript
 // interact.js
 
-//set up transaction parameters
+//configurer les paramètres de la transaction
 const transactionParameters = {
-  to: contractAddress, // Required except during contract publications.
-  from: address, // must match user's active address.
+  to: contractAddress, // Requis sauf lors de la publication de contrats.
+  from: address, // doit correspondre à l'adresse active de l'utilisateur.
   data: helloWorldContract.methods.update(message).encodeABI(),
 }
 
-//sign the transaction
+//signer la transaction
 try {
   const txHash = await window.ethereum.request({
     method: "eth_sendTransaction",
@@ -1719,11 +1431,11 @@ try {
       <span>
         ✅{" "}
         <a target="_blank" href={`https://goerli.etherscan.io/tx/${txHash}`}>
-          View the status of your transaction on Etherscan!
+          Consultez l'état de votre transaction sur Etherscan !
         </a>
         <br />
-        ℹ️ Once the transaction is verified by the network, the message will be
-        updated automatically.
+        ℹ️ Une fois la transaction vérifiée par le réseau, le message sera
+        mis à jour automatiquement.
       </span>
     ),
   }
@@ -1734,50 +1446,47 @@ try {
 }
 ```
 
+Analysons ce qui se passe. Tout d'abord, nous configurons les paramètres de nos transactions, où :
 
-Décortiquons ce qui se passe. Premièrement, nous configurons les paramètres de notre transaction, où :
+- `to` spécifie l'adresse du destinataire \(notre contrat intelligent\)
+- `from` spécifie le signataire de la transaction, la variable `address` que nous avons passée dans notre fonction
+- `data` contient l'appel à la méthode `update` de notre contrat intelligent Hello World, recevant notre variable de chaîne `message` en entrée
 
-- `to` spécifie l'adresse du destinataire \(notre contrat intelligent)
-- `from` spécifie le signataire de la transaction, la variable `adresse` que nous avons passée à notre fonction
-- `data` contient l'appel à la méthode `update` de notre contrat Hello World, recevant notre variable de chaîne `message` en entrée
-
-Ensuite, nous faisons un appel en attente, `window.ethereum.request`, où nous demandons à MetaMask de signer la transaction. Remarquez que, aux lignes 11 et 12, nous spécifions notre méthode eth, `eth_sendTransaction` et passons nos `transactionParameters`.
+Ensuite, nous effectuons un appel await, `window.ethereum.request`, où nous demandons à MetaMask de signer la transaction. Remarquez, aux lignes 11 et 12, nous spécifions notre méthode eth, `eth_sendTransaction`, et nous passons nos `transactionParameters`.
 
 À ce stade, MetaMask s'ouvrira dans le navigateur, et demandera à l'utilisateur de signer ou rejeter la transaction.
 
-- Si la transaction réussit, la fonction renverra un objet JSON où la chaîne `status` du JSX invite l'utilisateur à consulter Etherscan pour plus d'informations sur sa transaction.
+- Si la transaction réussit, la fonction renverra un objet JSON où la chaîne JSX `status` invite l'utilisateur à consulter Etherscan pour plus d'informations sur sa transaction.
 - Si la transaction échoue, la fonction renverra un objet JSON où la chaîne `status` relaie le message d'erreur.
 
-Dans l'ensemble, notre fonction `updateMessage` devrait ressembler à cela :
-
-
+Globalement, notre fonction `updateMessage` devrait ressembler à ceci :
 
 ```javascript
 // interact.js
 
 export const updateMessage = async (address, message) => {
-  //input error handling
+  //gestion des erreurs de saisie
   if (!window.ethereum || address === null) {
     return {
       status:
-        "💡 Connect your MetaMask wallet to update the message on the blockchain.",
+        "💡 Connectez votre portefeuille MetaMask pour mettre à jour le message sur la blockchain.",
     }
   }
 
   if (message.trim() === "") {
     return {
-      status: "❌ Your message cannot be an empty string.",
+      status: "❌ Votre message ne peut pas être une chaîne vide.",
     }
   }
 
-  //set up transaction parameters
+  //configurer les paramètres de la transaction
   const transactionParameters = {
-    to: contractAddress, // Required except during contract publications.
-    from: address, // must match user's active address.
+    to: contractAddress, // Requis sauf lors de la publication de contrats.
+    from: address, // doit correspondre à l'adresse active de l'utilisateur.
     data: helloWorldContract.methods.update(message).encodeABI(),
   }
 
-  //sign the transaction
+  //signer la transaction
   try {
     const txHash = await window.ethereum.request({
       method: "eth_sendTransaction",
@@ -1788,11 +1497,11 @@ export const updateMessage = async (address, message) => {
         <span>
           ✅{" "}
           <a target="_blank" href={`https://goerli.etherscan.io/tx/${txHash}`}>
-            View the status of your transaction on Etherscan!
+            Consultez l'état de votre transaction sur Etherscan !
           </a>
           <br />
-          ℹ️ Once the transaction is verified by the network, the message will
-          be updated automatically.
+          ℹ️ Une fois la transaction vérifiée par le réseau, le message sera
+          mis à jour automatiquement.
         </span>
       ),
     }
@@ -1804,16 +1513,11 @@ export const updateMessage = async (address, message) => {
 }
 ```
 
+Enfin et surtout, nous devons connecter notre fonction `updateMessage` à notre composant `HelloWorld.js`.
 
-Enfin, nous devons connecter notre fonction `updateMessage` à notre composant `HelloWorld.js`.
-
-
-
-#### Connectez `updateMessage` à l'interface de `HelloWorld.js` {#connect-updatemessage-to-the-helloworld-js-frontend}
-
-Notre fonction `onUpdatePressed` devrait émettre un appel en attente à la fonction importée `updateMessage` et modifier la variable d'état `status` pour refléter si notre transaction a réussi ou échoué :
-
+#### Connecter `updateMessage` au frontend `HelloWorld.js` {#connect-updatemessage-to-the-helloworld-js-frontend}
 
+Notre fonction `onUpdatePressed` devrait faire un appel `await` à la fonction `updateMessage` importée et modifier la variable d'état `status` pour refléter si notre transaction a réussi ou échoué :
 
 ```javascript
 // HelloWorld.js
@@ -1824,21 +1528,18 @@ const onUpdatePressed = async () => {
 }
 ```
 
-
 C'est super propre et simple. Et devinez quoi... VOTRE DAPP EST TERMINÉE !!!
 
-Allez-y et testez le bouton **Update** !
-
-
+Allez-y et testez le bouton **Mettre à jour** !
 
-### Créez votre propre DApp personnalisée {#make-your-own-custom-dapp}
+### Créez votre propre dapp personnalisée {#make-your-own-custom-dapp}
 
 Wooooo, vous êtes arrivé à la fin du tutoriel ! Pour récapituler, vous avez appris à :
 
 - Connecter un portefeuille MetaMask à votre projet de dapp
-- Lire les données de votre contrat intelligent en utilisant l'API [Web3 d'Alchemy](https://docs.alchemy.com/alchemy/documentation/alchemy-web3)
+- Lire des données de votre contrat intelligent en utilisant l'API [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3)
 - Signer des transactions Ethereum en utilisant MetaMask
 
-Maintenant, vous êtes pleinement équipé pour appliquer les compétences de ce tutoriel à la construction de votre propre projet de DApp personnalisé ! Comme toujours, si vous avez des questions, n'hésitez pas à nous demander de l'aide dans le [Discord d'Alchemy](https://discord.gg/gWuC7zB). 🧙‍♂️
+Maintenant, vous êtes pleinement équipé pour appliquer les compétences de ce tutoriel afin de créer votre propre projet de dapp personnalisé ! Comme toujours, si vous avez des questions, n'hésitez pas à nous contacter pour obtenir de l'aide sur le [Discord d'Alchemy](https://discord.gg/gWuC7zB). 🧙‍♂️
 
-Une fois ce tutoriel terminé, faites-nous savoir comment s'est passée votre expérience ou si vous avez des commentaires en nous identifiant sur Twitter [@alchemyplatform](https://twitter.com/AlchemyPlatform) !
+Une fois que vous avez terminé ce tutoriel, faites-nous savoir comment s'est passée votre expérience ou si vous avez des commentaires en nous identifiant sur Twitter [@alchemyplatform](https://twitter.com/AlchemyPlatform) !
diff --git a/public/content/translations/fr/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/fr/developers/tutorials/hello-world-smart-contract/index.md
index 874564ac305..031561f852d 100644
--- a/public/content/translations/fr/developers/tutorials/hello-world-smart-contract/index.md
+++ b/public/content/translations/fr/developers/tutorials/hello-world-smart-contract/index.md
@@ -1,75 +1,71 @@
 ---
-title: Un Contrat intelligent « Hello World » pour les débutants
-description: Tutoriel d'introduction à l'écriture et au déploiement d'un contrat intelligent simple sur Ethereum.
+title: "Un contrat intelligent « Hello World » pour les débutants"
+description: "Tutoriel d'introduction à l'écriture et au déploiement d'un contrat intelligent simple sur Ethereum."
 author: "elanh"
 tags:
-  - "solidité"
-  - "hardhat"
-  - "alchemy"
-  - "contrats intelligents"
-  - "déployer"
+  [
+    "Solidity",
+    "Hardhat",
+    "Alchemy",
+    "contrats intelligents",
+    "déploiement"
+  ]
 skill: beginner
 lang: fr
 published: 2021-03-31
 ---
 
-Si vous débutez dans le développement de blockchain et ne savez pas par où commencer, ou si vous souhaitez uniquement comprendre comment déployer et interagir avec les contrats intelligents, ce guide est fait pour vous. Nous allons parcourir la création et le déploiement d'un contrat intelligent simple sur le réseau de test de Goerli à l'aide d'un portefeuille virtuel [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), et [Alchemy](https://alchemyapi.io/eth) (ne vous inquiétez pas si vous ne comprenez pas à ce stade ce que cela signifie, nous allons l'expliquer).
+Si vous débutez dans le développement de la blockchain et que vous ne savez pas par où commencer, ou si vous voulez simplement comprendre comment déployer des contrats intelligents et interagir avec, ce guide est fait pour vous. Nous allons vous guider dans la création et le déploiement d'un contrat intelligent simple sur le réseau de test Sepolia en utilisant un portefeuille virtuel [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) et [Alchemy](https://www.alchemy.com/eth) (ne vous inquiétez pas si vous ne comprenez pas encore ce que tout cela signifie, nous vous l'expliquerons).
 
-> **Avertissement **
->
-> 🚧 Avis de fin de support
->
-> Tout au long de ce guide, le réseau de test Goerli est utilisé pour créer et déployer un contrat intelligent. Cependant, veuillez noter que l'Ethereum Foundation a annoncé que [Goerli sera bientôt obsolète](https://www.alchemy.com/blog/goerli-faucet-deprecation).
->
-> Nous vous recommandons d'utiliser le [Sepolia](https://www.alchemy.com/overviews/sepolia-testnet) et le [distributeur sur Sepolia](https://sepoliafaucet.com/) pour ce tutoriel.
+Dans la [partie 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) de ce tutoriel, nous verrons comment interagir avec notre contrat intelligent une fois qu'il sera déployé, et dans la [partie 3](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan), nous aborderons la façon de le publier sur Etherscan.
 
-Dans la [partie 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) de ce tutoriel, nous allons voir comment nous pouvons interagir avec notre contrat intelligent une fois qu'il sera déployé ici, et dans la [partie 3](https://docs.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) nous couvrirons comment le publier sur Etherscan.
-
-Si vous avez des questions à un moment ou à un autre, n'hésitez pas à en discuter sur le [Discord Alchemy](https://discord.gg/gWuC7zB)!
+Si vous avez des questions à un moment ou à un autre, n'hésitez pas à nous contacter sur le [Discord d'Alchemy](https://discord.gg/gWuC7zB) !
 
 ## Étape 1 : Se connecter au réseau Ethereum {#step-1}
 
-Il existe de nombreuses façons de faire des requêtes dans la chaîne d'Ethereum. Pour plus de simplicité, nous allons utiliser un compte gratuit sur Alchemy, une plateforme de blockchain et d'API pour développeur, nous permettant de communiquer avec la chaîne Ethereum sans avoir à exécuter nos propres nœuds. La plateforme possède également des outils de développement pour la surveillance et l'analyse, dont nous allons tirer parti dans ce tutoriel, pour comprendre ce qui se passe sous le capot de notre déploiement de contrat intelligent. Si vous n'avez pas encore de compte Alchemy, [vous pouvez vous inscrire gratuitement ici](https://dashboard.alchemyapi.io/signup).
+Il existe de nombreuses façons de faire des requêtes sur la chaîne Ethereum. Pour des raisons de simplicité, nous utiliserons un compte gratuit sur Alchemy, une plateforme de développement blockchain et une API qui nous permet de communiquer avec la chaîne Ethereum sans avoir à exécuter nos propres nœuds. La plateforme dispose également d'outils de développement pour la surveillance et l'analyse, dont nous tirerons parti dans ce tutoriel pour comprendre ce qui se passe en coulisses lors du déploiement de notre contrat intelligent. Si vous n'avez pas encore de compte Alchemy, [vous pouvez vous inscrire gratuitement ici](https://dashboard.alchemy.com/signup).
 
 ## Étape 2 : Créer votre application (et votre clé API) {#step-2}
 
-Une fois que vous avez créé un compte Alchemy, vous pouvez générer une clé API en créant une application. Cela va nous permettre d'émettre des requêtes sur le réseau de test Goerli. Si vous n'êtes pas familier avec Testnets (réseau de test), consultez [cette page](/developers/docs/networks/).
+Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela va nous permettre d'émettre des requêtes sur le réseau de test Sepolia. Si vous n'êtes pas familier avec les réseaux de test, consultez [cette page](/developers/docs/networks/).
+
+1. Accédez à la page "Create new app" dans votre tableau de bord Alchemy en sélectionnant "Select an app" dans la barre de navigation et en cliquant sur "Create new app".
 
-1.  Accédez à la page « Créer une application » dans votre tableau de bord Alchemy en survolant « Apps » dans la barre de navigation et en cliquant sur « Créer une application »
+![Création de l'application Hello world](./hello-world-create-app.png)
 
-![créer une application Hello world](./hello-world-create-app.png)
+2. Nommez votre application « Hello World », fournissez une courte description et choisissez un cas d'utilisation, par exemple, "Infra & Tooling." Ensuite, recherchez "Ethereum" et sélectionnez le réseau.
 
-2. Nommez votre application « Hello World », faites-en une description rapide, pour l'environnement sélectionnez « Staging » (utilisé pour la comptabilité de votre application), et pour votre réseau choisissez « Goerli ».
+![Vue de création de l'application Hello world](./create-app-view-hello-world.png)
 
-![créer une vue de l'application Hello world](./create-app-view-hello-world.png)
+3. Cliquez sur "Next" pour continuer, puis sur “Create app” et c'est tout ! Votre application devrait apparaître dans le menu déroulant de la barre de navigation, avec une clé API que vous pouvez copier.
 
-3. Cliquez sur « Créer l'application » et voilà ! Votre application devrait apparaître dans le tableau.
+## Étape 3 : Créer un compte Ethereum (adresse) {#step-3}
 
-## Étape 3 : Créez un compte Ethereum (adresse) {#step-3}
+Nous avons besoin d'un compte Ethereum pour effectuer des transactions (envoyer et recevoir). Pour ce tutoriel, nous allons utiliser MetaMask, un portefeuille virtuel intégré au navigateur, servant à gérer les adresses de votre compte Ethereum. En savoir plus sur les [transactions](/developers/docs/transactions/).
 
-Nous avons besoin d'un compte Ethereum pour effectuer des transactions (envoyer et recevoir). Pour ce tutoriel, nous allons utiliser MetaMask, un portefeuille virtuel intégré au navigateur, servant à gérer les adresses de votre compte Ethereum. Plus d'infos sur les [transactions](/developers/docs/transactions/).
+Vous pouvez télécharger MetaMask et créer gratuitement un compte Ethereum [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, veillez à basculer sur le réseau de test "Sepolia" à l'aide du menu déroulant du réseau (afin de ne pas utiliser d'argent réel).
 
-Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer sur « Réseau de test Goerli » en haut à droite (afin de ne pas utiliser d'argent réel).
+Si Sepolia n'est pas listé, allez dans le menu, puis dans « Advanced » et faites défiler vers le bas pour activer l'option "Show test networks". Dans le menu de sélection du réseau, choisissez l'onglet "Custom" pour trouver une liste de réseaux de test et sélectionnez "Sepolia."
 
-![exemple metamask ropsten](./metamask-ropsten-example.png)
+![Exemple de MetaMask Sepolia](./metamask-sepolia-example.png)
 
-## Étape 4 : Ajoutez de l'ether à partir d'un faucet {#step-4}
+## Étape 4 : Ajouter de l'ether depuis un faucet {#step-4}
 
-Afin de déployer notre contrat intelligent sur le réseau de test, nous aurons besoin de faux Eth. Pour obtenir des Eth, vous pouvez vous rendre sur le [faucet Goerli](https://goerlifaucet.com/) et vous connecter à votre compte Alchemy et entrer l'adresse de votre portefeuille, puis cliquez sur « Envoyez-moi des Eth ». Cela peut prendre un certain temps pour recevoir votre faux Eth en fonction du trafic sur le réseau. (Au moment de rédiger l'article, cela a pris environ 30 minutes.) Vous devriez voir les Eth dans votre compte Metamask peu de temps après !
+Afin de déployer notre contrat intelligent sur le réseau de test, nous aurons besoin de faux ETH. Pour obtenir des ETH Sepolia, vous pouvez accéder à la page des [détails du réseau Sepolia](/developers/docs/networks/#sepolia) pour consulter une liste de différents faucets. Si l'un d'eux ne fonctionne pas, essayez-en un autre, car ils peuvent parfois être à sec. La réception de vos faux ETH peut prendre un certain temps en raison du trafic réseau. Vous devriez voir les ETH apparaître dans votre compte Metamask peu de temps après !
 
-## Étape 5 : Vérifiez votre solde {#step-5}
+## Étape 5 : Vérifier votre solde {#step-5}
 
-Pour vérifier notre solde, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant [l'outil composeur d'Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va retourner la quantité d'ETH présente dans notre portefeuille. Après avoir entré l'adresse de votre compte Metamask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
+Pour vérifier notre solde, effectuons une requête [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) en utilisant l'[outil de composition d'Alchemy](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest). Cela va renvoyer la quantité d'ETH dans notre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
 
 ```json
 { "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
 ```
 
-> **REMARQUE :** Ce résultat est en wei et non pas en ETH. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion de wei en ETH est : 1 eth = 10<sup>18</sup> wei. Donc si nous convertissons 0x2B5E3AF16B1880000 en décimales, nous obtenons 5\*10¹⁸, ce qui équivaut à 5 ETH.
+> **REMARQUE :** Ce résultat est en wei, et non en ETH. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion de wei en ETH est la suivante : 1 ETH = 10<sup>18</sup> wei. Donc, si nous convertissons 0x2B5E3AF16B1880000 en décimal, nous obtenons 5\*10¹⁸, ce qui équivaut à 5 ETH.
 >
 > Ouf ! Notre fausse monnaie est bien là <Emoji text=":money_mouth_face:" size={1} />.
 
-## Étape 6 : Initialisez notre projet {#step-6}
+## Étape 6 : Initialiser notre projet {#step-6}
 
 Pour commencer, nous allons devoir créer un dossier pour notre projet. Ouvrez votre ligne de commande et tapez :
 
@@ -78,13 +74,13 @@ mkdir hello-world
 cd hello-world
 ```
 
-Maintenant que nous sommes dans le dossier de notre projet, nous allons utiliser `npm init` pour initialiser le projet. Si vous n'avez pas encore installé npm, suivez [ces instructions](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (téléchargez également Node.js, car nous en aurons besoin aussi).
+Maintenant que nous sommes dans notre dossier de projet, nous allons utiliser `npm init` pour initialiser le projet. Si vous n'avez pas encore installé npm, suivez [ces instructions](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (nous aurons également besoin de Node.js, alors téléchargez-le aussi !).
 
 ```
 npm init
 ```
 
-La manière dont vous répondez à ces questions d'installation a peu d'importance. Pour référence, voici comment nous avons répondu :
+La façon dont vous répondez aux questions d'installation n'a pas vraiment d'importance, voici comment nous avons procédé, à titre de référence :
 
 ```
 package name: (hello-world)
@@ -104,28 +100,28 @@ About to write to /Users/.../.../.../hello-world/package.json:
   "description": "hello world smart contract",
   "main": "index.js",
   "scripts": {
-     "test": "echo \\"Error: no test specified\\" && exit 1"
+     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "",
   "license": "ISC"
 }
 ```
 
-Approuvez le package.json et nous sommes prêts à démarrer !
+Approuvez le fichier package.json et nous sommes prêts !
 
-## Étape 7 : Téléchargez [Hardhat](https://hardhat.org/getting-started/#overview) {#step-7}
+## Étape 7 : Télécharger [Hardhat](https://hardhat.org/getting-started/#overview) {#step-7}
 
 Hardhat est un environnement de développement qui permet de compiler, déployer, tester et déboguer votre logiciel Ethereum. Il aide les développeurs à construire des contrats intelligents et des dApps localement avant de les déployer sur la chaîne en production.
 
-À l'intérieur de notre projet `hello-world`, exécutez :
+Dans notre projet `hello-world`, exécutez :
 
 ```
 npm install --save-dev hardhat
 ```
 
-Consultez cette page pour plus de détails sur [les instructions d'installation](https://hardhat.org/getting-started/#overview).
+Consultez cette page pour plus de détails sur les [instructions d'installation](https://hardhat.org/getting-started/#overview).
 
-## Étape 8 : Créez un projet Hardhat {#step-8}
+## Étape 8 : Créer le projet Hardhat {#step-8}
 
 Dans notre dossier de projet, exécutez :
 
@@ -133,7 +129,7 @@ Dans notre dossier de projet, exécutez :
 npx hardhat
 ```
 
-Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour séléctionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :
+Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour sélectionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :
 
 ```
 888    888                      888 888               888
@@ -147,72 +143,72 @@ Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour s
 
 👷 Welcome to Hardhat v2.0.11 👷‍?
 
-Que voulez vous faire ? …
+What do you want to do? …
 Create a sample project
 ❯ Create an empty hardhat.config.js
 Quit
 ```
 
-Cela va générer un fichier `hardhat.config.js` dans lequel nous allons spécifier tous les paramètres de notre projet (à l'étape 13).
+Cela générera pour nous un fichier `hardhat.config.js`, dans lequel nous spécifierons toute la configuration de notre projet (à l'étape 13).
 
-## Étape 9 : Ajoutez des dossiers au projet {#step-9}
+## Étape 9 : Ajouter des dossiers de projet {#step-9}
 
-Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. Naviguez vers le répertoire racine de votre projet dans votre ligne de commande et tapez :
+Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. Naviguez vers le répertoire racine de votre projet dans votre invite de commande en ligne et tapez :
 
 ```
 mkdir contracts
 mkdir scripts
 ```
 
-- `contrats/` est l'endroit où nous garderons notre fichier de code de contrat intelligent 'hello world'
-- `scripts/` est l'endroit où nous garderons les scripts à déployer et pour interagir avec notre contrat
+- `contracts/` est l'endroit où nous conserverons le fichier de code de notre contrat intelligent hello world.
+- `scripts/` est l'endroit où nous conserverons les scripts pour déployer notre contrat et interagir avec lui.
 
-## Étape 10 : Écrivez votre contrat {#step-10}
+## Étape 10 : Rédiger notre contrat {#step-10}
 
-Vous vous demandez peut-être quand allons nous enfin écrire du code ??? Eh bien, nous y voilà en cette étape 10.
+Vous vous demandez peut-être quand allons-nous enfin écrire du code ?? Eh bien, nous y voilà, à l'étape 10.
 
-Ouvrez le projet hello-world dans votre éditeur de code favori (nous apprécions [VSCode](https://code.visualstudio.com/)). Les contrats intelligents sont écrits dans un langage appelé Solidity, qui est celui que nous utiliserons pour écrire notre contrat intelligent HelloWorld.sol.
+Ouvrez le projet hello-world dans votre éditeur de code favori (nous aimons [VSCode](https://code.visualstudio.com/)). Les contrats intelligents sont écrits dans un langage appelé Solidity que nous utiliserons pour écrire notre contrat intelligent HelloWorld.sol.
 
-1.  Naviguez vers le dossier « contracts » et créez un nouveau fichier appelé HelloWord.sol
-2.  Ci-dessous un exemple de contrat intelligent Hello World de la fondation Ethereum que nous utiliserons pour ce tutoriel. Copiez et collez le contenu ci-dessous dans votre fichier HelloWorld.sol et assurez-vous de lire les commentaires pour comprendre ce que fait ce contrat :
+1. Accédez au dossier « contracts » et créez un nouveau fichier nommé HelloWorld.sol.
+2. Vous trouverez ci-dessous un exemple de contrat intelligent Hello World de la Fondation Ethereum que nous utiliserons pour ce tutoriel. Copiez et collez le contenu ci-dessous dans votre fichier HelloWorld.sol, et assurez-vous de lire les commentaires pour comprendre ce que fait ce contrat :
 
 ```solidity
-// Specifies the version of Solidity, using semantic versioning.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// Spécifie la version de Solidity, en utilisant le versionnage sémantique.
+// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
 pragma solidity ^0.7.0;
 
-// Defines a contract named `HelloWorld`.
-// A contract is a collection of functions and data (its state). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// Définit un contrat nommé `HelloWorld`.
+// Un contrat est un ensemble de fonctions et de données (son état). Une fois déployé, un contrat réside à une adresse spécifique sur la blockchain Ethereum. En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
 contract HelloWorld {
 
-   // Declares a state variable `message` of type `string`.
-   // State variables are variables whose values are permanently stored in contract storage. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+   // Déclare une variable d'état `message` de type `string`.
+   // Les variables d'état sont des variables dont les valeurs sont stockées en permanence dans le stockage du contrat. Le mot-clé `public` rend les variables accessibles depuis l'extérieur d'un contrat et crée une fonction que d'autres contrats ou clients peuvent appeler pour accéder à la valeur.
    string public message;
 
-   // Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
-   // Constructors are used to initialize the contract's data. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+   // Semblable à de nombreux langages orientés objet basés sur des classes, un constructeur est une fonction spéciale qui n'est exécutée qu'à la création du contrat.
+   // Les constructeurs sont utilisés pour initialiser les données du contrat. En savoir plus :https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
    constructor(string memory initMessage) {
 
-      // Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
+      // Accepte un argument de chaîne de caractères `initMessage` et définit la valeur dans la variable de stockage `message` du contrat).
       message = initMessage;
    }
 
-   // A public function that accepts a string argument and updates the `message` storage variable.
+   // Une fonction publique qui accepte un argument de chaîne de caractères et met à jour la variable de stockage `message`.
    function update(string memory newMessage) public {
       message = newMessage;
    }
 }
 ```
 
-Il s'agit d'un contrat intelligent très simple qui stocke un message lors de la création et peut être mis à jour en appelant la fonction `update`.
+Il s'agit d'un contrat intelligent très simple qui stocke un message lors de sa création et qui peut être mis à jour en appelant la fonction `update`.
 
-## Étape 11 : Connectez MetaMask & Alchemy à votre projet {#step-11}
+## Étape 11 : Connecter MetaMask et Alchemy à votre projet {#step-11}
 
-Maintenant que nous avons créé un portefeuille Metamask, un compte Alchemy et écrit notre contrat intelligent, il est temps de connecter les trois.
+Nous avons créé un portefeuille MetaMask, un compte Alchemy et rédigé notre contrat intelligent. Il est maintenant temps de connecter les trois.
 
 Chaque transaction envoyée depuis votre portefeuille virtuel nécessite une signature en utilisant votre clé privée unique. Pour donner cette permission à notre programme, nous pouvons stocker en toute sécurité notre clé privée (et la clé API Alchemy) dans un fichier d'environnement.
 
-> Pour en savoir plus sur l'envoi de transactions, consultez [ce tutoriel](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sur l'envoi de transactions avec web3.
+> Pour en savoir plus sur l'envoi de transactions, consultez [ce tutoriel](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sur l'envoi de transactions à l'aide de web3.
 
 Premièrement, installez le paquet dotenv dans votre dossier de projet :
 
@@ -220,19 +216,19 @@ Premièrement, installez le paquet dotenv dans votre dossier de projet :
 npm install dotenv --save
 ```
 
-Ensuite, créez un fichier `.env` dans le répertoire racine de notre projet et ajoutez-y votre clé privée MetaMask et l'URL de l'API HTTP Alchemy.
+Ensuite, créez un fichier `.env` à la racine de notre projet, et ajoutez-y votre clé privée MetaMask et votre URL d'API HTTP Alchemy.
 
-- Suivez [ces instructions](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) pour exporter votre clé privée
+- Suivez [ces instructions](https://support.metamask.io/configure/accounts/how-to-export-an-accounts-private-key/) pour exporter votre clé privée
 - Voir ci-dessous pour obtenir l'URL de l'API HTTP Alchemy
 
-![obtenir la clé api alchemy](./get-alchemy-api-key.gif)
+![obtenir la clé api alchemy](./get-alchemy-api-key.png)
 
 Copiez l'URL de l'API Alchemy
 
-Votre `.env` devrait ressembler à ceci :
+Votre `.env` devrait ressembler à ceci :
 
 ```
-API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
+API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
 PRIVATE_KEY = "your-metamask-private-key"
 ```
 
@@ -241,16 +237,16 @@ Pour les relier à notre code, nous ferons référence à ces variables dans not
 <Alert variant="warning">
 <AlertContent>
 <AlertDescription>
-Ne propagez pas le fichier <code>.env</code> ! Veillez à ne jamais partager ou exposer votre fichier <code>.env</code> avec quiconque car vous compromettez vos secrets en le faisant. Si vous utilisez le contrôle de version, ajoutez votre <code>.env</code> à un fichier <a href="https://git-scm.com/docs/gitignore">gitignore</a>.
+Ne commitez pas le fichier <code>.env</code> ! Veillez à ne jamais partager ou exposer votre fichier <code>.env</code> avec quiconque, car vous compromettez vos secrets en le faisant. Si vous utilisez un système de contrôle de version, ajoutez votre fichier <code>.env</code> à un fichier <a href="https://git-scm.com/docs/gitignore">gitignore</a>.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
-## Étape 12 : Installez Ethers.js {#step-12-install-ethersjs}
+## Étape 12 : Installer Ethers.js {#step-12-install-ethersjs}
 
-Ethers.js est une bibliothèque qui permet facilement d'interagir et de faire des requêtes pour Ethereum en enveloppant les méthodes [standard JSON-RPC](/developers/docs/apis/json-rpc/) avec des méthodes plus conviviales d'utilisation.
+Ethers.js est une bibliothèque qui facilite l'interaction et l'envoi de requêtes à Ethereum en encapsulant les [méthodes JSON-RPC standard](/developers/docs/apis/json-rpc/) dans des méthodes plus conviviales.
 
-Hardhat facilite grandement l'intégration de [Plugins](https://hardhat.org/plugins/) pour des outils supplémentaires et des fonctionnalités étendues. Nous profiterons du [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) pour le déploiement de contrats ([Ethers.js](https://github.com/ethers-io/ethers.js/) dispose de quelques méthodes très nettes de déploiement de contrat).
+Hardhat facilite grandement l'intégration de [plugins](https://hardhat.org/plugins/) pour des outils supplémentaires et des fonctionnalités étendues. Nous allons profiter du [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) pour le déploiement du contrat ([Ethers.js](https://github.com/ethers-io/ethers.js/) a des méthodes de déploiement de contrat très propres).
 
 Dans votre dossier de projet, tapez :
 
@@ -260,11 +256,11 @@ npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
 
 Nous aurons également besoin d'ethers dans notre `hardhat.config.js` à l'étape suivante.
 
-## Étape 13 : Mettez à jour hardhat.config.js {#step-13-update-hardhatconfigjs}
+## Étape 13 : Mettre à jour hardhat.config.js {#step-13-update-hardhatconfigjs}
 
-A ce stade, nous avons ajouté plusieurs dépendances et plugins. Nous devons maintenant mettre à jour `hardhat.config.js` pour que notre projet les reconnaisse.
+À ce stade, nous avons ajouté plusieurs dépendances et plugins. Nous devons maintenant mettre à jour `hardhat.config.js` pour que notre projet les reconnaisse.
 
-Mettez à jour votre `hardhat.config.js` pour qu'il ressemble à ceci :
+Mettez à jour votre `hardhat.config.js` pour qu'il ressemble à ceci :
 
 ```
 require('dotenv').config();
@@ -277,10 +273,10 @@ const { API_URL, PRIVATE_KEY } = process.env;
 */
 module.exports = {
    solidity: "0.7.3",
-   defaultNetwork: "goerli",
+   defaultNetwork: "sepolia",
    networks: {
       hardhat: {},
-      goerli: {
+      sepolia: {
          url: API_URL,
          accounts: [`0x${PRIVATE_KEY}`]
       }
@@ -288,9 +284,9 @@ module.exports = {
 }
 ```
 
-## Étape 14 : Compilons notre contrat {#step-14-compile-our-contracts}
+## Étape 14 : Compiler notre contrat {#step-14-compile-our-contracts}
 
-Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La tâche `compile` est une des tâches intégrées à hardhat.
+Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La tâche `compile` est l'une des tâches intégrées de hardhat.
 
 À partir de la ligne de commande, exécutez :
 
@@ -298,9 +294,9 @@ Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La t
 npx hardhat compile
 ```
 
-Vous pourriez voir un avertissement du type `SPDX license identifier not provided in source file`, mais nul besoin de vous inquiéter — espérons que tout le reste fonctionne ! Si ce n'est pas le cas, vous pouvez toujours envoyer un message dans le Discord [Alchemy](https://discord.gg/u72VCg3).
+Vous pourriez voir un avertissement du type `SPDX license identifier not provided in source file` (identifiant de licence SDPX non fourni dans le fichier source), mais nul besoin de vous inquiéter — espérons que tout le reste fonctionne ! Sinon, vous pouvez toujours envoyer un message sur le [Discord d'Alchemy](https://discord.gg/u72VCg3).
 
-## Étape 15 : Rédigeons notre script de déploiement {#step-15-write-our-deploy-scripts}
+## Étape 15 : Rédiger notre script de déploiement {#step-15-write-our-deploy-scripts}
 
 Maintenant que notre contrat est codé et que notre fichier de configuration est bon, il est temps d’écrire notre script de déploiement pour notre contrat.
 
@@ -310,9 +306,9 @@ Naviguez vers le dossier `scripts/` et créez un nouveau fichier appelé `deploy
 async function main() {
    const HelloWorld = await ethers.getContractFactory("HelloWorld");
 
-   // Start deployment, returning a promise that resolves to a contract object
+   // Lancer le déploiement, renvoyant une promesse qui se résout en un objet de contrat
    const hello_world = await HelloWorld.deploy("Hello World!");
-   console.log("Contract deployed to address:", hello_world.address);}
+   console.log("Contrat déployé à l'adresse :", hello_world.address);}
 
 main()
   .then(() => process.exit(0))
@@ -322,48 +318,50 @@ main()
   });
 ```
 
-Hardhat est incroyable en ce sens qu'il explique clairement ce que fait chacune des lignes de code au travers de son [tutoriel sur les contrats](https://hardhat.org/tutorial/testing-contracts.html#writing-tests). Nous avons repris ces explications ici.
+Hardhat explique très bien ce que fait chacune de ces lignes de code dans son [tutoriel sur les contrats](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), nous avons repris leurs explications ici.
 
 ```
 const HelloWorld = await ethers.getContractFactory("HelloWorld");
 ```
 
-Une `ContractFactory` dans ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents. Ainsi, `HelloWorld` est ici une usine pour des exemples de notre contrat Hello world. Lors de l'utilisation du plugin `hardhat-ethers`, les instances `ContractFactory` et `Contract` sont connectées par défaut au premier signataire.
+Une `ContractFactory` dans ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents. Ainsi, `HelloWorld` est ici une usine pour des exemples de notre contrat Hello world. Lors de l'utilisation du plugin `hardhat-ethers`, les instances de `ContractFactory` et de `Contract` sont connectées au premier signataire par défaut.
 
 ```
 const hello_world = await HelloWorld.deploy();
 ```
 
-Appeler `deploy()` sur un `ContractFactory` va démarrer le déploiement et retourner une `Promise` qui corrige un `Contract`. C'est l'objet qui a une méthode pour chacune de nos fonctions de contrat intelligent.
+L'appel de `deploy()` sur un `ContractFactory` lancera le déploiement et renverra une `Promise` qui se résout en un `Contract`. C'est l'objet qui possède une méthode pour chacune des fonctions de notre contrat intelligent.
 
-## Étape 16 : Déployons notre contrat {#step-16-deploy-our-contract}
+## Étape 16 : Déployer notre contrat {#step-16-deploy-our-contract}
 
 Nous sommes enfin prêts à déployer notre contrat intelligent ! Naviguez vers la ligne de commande et exécutez :
 
 ```
-npx hardhat run scripts/deploy.js --network goerli
+npx hardhat run scripts/deploy.js --network sepolia
 ```
 
-Vous devriez dès lors voir quelque chose comme :
+Vous devriez maintenant voir quelque chose comme :
 
 ```
-Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+Contrat déployé à l'adresse : 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
 ```
 
-Si nous allons sur l'[etherscan Goerli](https://goerli.etherscan.io/) et que nous recherchons l'adresse de notre contrat, nous devrions constater qu'il a été déployé avec succès. La transaction ressemblera à ceci :
+Si nous allons sur l'[Etherscan Sepolia](https://sepolia.etherscan.io/) et que nous recherchons l'adresse de notre contrat, nous devrions être en mesure de voir qu'il a été déployé avec succès. La transaction ressemblera à quelque chose comme :
 
-![contrat etherscan](./etherscan-contract.png)
+![Contrat Etherscan](./etherscan-contract.png)
 
-L'adresse `From` devrait correspondre à votre adresse de compte Metamask et l'adresse To retournera « Contract Creation », mais si nous cliquons dans la transaction, nous verrons notre adresse de contrat dans le champ `To` :
+L'adresse `From` devrait correspondre à l'adresse de votre compte MetaMask et l'adresse `To` indiquera « Contract Creation » mais si nous cliquons sur la transaction, nous verrons l'adresse de notre contrat dans le champ `To` :
 
-![transaction etherscan](./etherscan-transaction.png)
+![Transaction Etherscan](./etherscan-transaction.png)
 
 Félicitations ! Vous venez de déployer un contrat intelligent sur la chaîne Ethereum 🎉
 
-Pour comprendre ce qui se passe sous le capot, naviguons dans l'onglet Explorer de notre [tableau de bord Alchemy](https://dashboard.alchemyapi.io/explorer). Si vous disposez de plusieurs applications Alchemy, assurez-vous de filtrer par application et sélectionnez « Hello World ». ![explorateur Hello world](./hello-world-explorer.png)
+Pour comprendre ce qui se passe en coulisses, allons dans l'onglet Explorer de notre [tableau de bord Alchemy](https://dashboard.alchemyapi.io/explorer). Si vous disposez de plusieurs applications Alchemy, assurez-vous de filtrer par application et sélectionnez « Hello World ».
+![Explorateur Hello World](./hello-world-explorer.png)
 
-Ici, vous verrez un certain nombre d'appels JSON-RPC que Hardhat/Ethers a réalisés pour nous lorsque nous avons appelé la fonction `.deploy()`. Ici, deux appels importants réalisés sont [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), qui est la demande d'écriture de notre contrat sur la chaîne Goerli, et [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash) qui est une requête pour lire des informations sur notre transaction compte tenu du hachage (un modèle type lors de transactions). Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur [l'envoi de transactions en utilisant Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
+Vous verrez ici un certain nombre d'appels JSON-RPC que Hardhat/Ethers ont effectués en coulisses pour nous lorsque nous avons appelé la fonction `.deploy()`. Deux appels importants à mentionner ici sont [`eth_sendRawTransaction`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-send-raw-transaction), qui est la requête pour réellement écrire notre contrat sur la chaîne Sepolia, et [`eth_getTransactionByHash`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-get-transaction-by-hash) qui est une requête pour lire des informations sur notre transaction en fonction du hachage (un modèle typique lors
+des transactions). Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur l'[envoi de transactions à l'aide de Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
 
-C'est tout pour la première partie de ce tutoriel. Dans la deuxième partie, nous allons [interagir avec notre contrat intelligent](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#part-2-interact-with-your-smart-contract) en mettant à jour notre message initial et, dans la troisième partie, nous [publierons notre contrat intelligent sur Etherscan](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#optional-part-3-publish-your-smart-contract-to-etherscan) afin que tout le monde sache comment interagir avec lui.
+C'est tout pour la première partie de ce tutoriel. Dans la deuxième partie, nous allons [interagir avec notre contrat intelligent](https://www.alchemy.com/docs/interacting-with-a-smart-contract) en mettant à jour notre message initial et, dans la troisième partie, nous [publierons notre contrat intelligent sur Etherscan](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) afin que tout le monde sache comment interagir avec lui.
 
-**Vous voulez en savoir plus sur Alchemy ? Consultez notre [site web](https://alchemyapi.io/eth). Vous ne voulez manquer aucune mise à jour ? Abonnez-vous à notre newsletter [ici](https://www.alchemyapi.io/newsletter) ! N'oubliez pas également de nous suivre sur [Twitter](https://twitter.com/alchemyplatform) et de rejoindre notre [Discord](https://discord.com/invite/u72VCg3)**.
+**Vous voulez en savoir plus sur Alchemy ? Consultez notre [site web](https://www.alchemy.com/eth). Ne ratez plus jamais une mise à jour ? Inscrivez-vous à notre newsletter [ici](https://www.alchemy.com/newsletter) ! Assurez-vous également de rejoindre notre [Discord](https://discord.gg/u72VCg3).**.
diff --git a/public/content/translations/fr/developers/tutorials/how-to-implement-an-erc721-market/index.md b/public/content/translations/fr/developers/tutorials/how-to-implement-an-erc721-market/index.md
index 4ae29d0236c..037bfa1d65c 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-implement-an-erc721-market/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-implement-an-erc721-market/index.md
@@ -1,12 +1,14 @@
 ---
-title: Comment mettre en œuvre un marché ERC-721
-description: Comment mettre en vente des objets tokénisés dans un forum de petites annonces décentralisé
+title: "Comment mettre en œuvre un marché ERC-721"
+description: "Comment mettre en vente des objets tokénisés dans un forum de petites annonces décentralisé"
 author: "Alberto Cuesta Cañada"
 tags:
-  - "contrats intelligents"
-  - "erc-721"
-  - "solidity"
-  - "jetons"
+  [
+    "contrats intelligents",
+    "erc-721",
+    "Solidity",
+    "jetons"
+  ]
 skill: intermediate
 lang: fr
 published: 2020-03-19
@@ -26,13 +28,13 @@ Avec la blockchain, ces marchés sont appelés à changer une fois de plus. Lais
 
 Le business model d'un forum public de petites annonces sur la blockchain devra être différent de celui d'Ebay et d'une entreprise.
 
-Tout d'abord, il y a [la qestion de la décentralisation](/developers/docs/web2-vs-web3/). Les plateformes existantes doivent assurer le bon fonctionnement de leurs propres serveurs. Le bon fonctionnement d'une plateforme décentralisée est assuré par ses utilisateurs, de sorte que le coût de fonctionnement de la plateforme centrale tombe à zéro pour le propriétaire de la plateforme.
+Tout d'abord, il y a [l'angle de la décentralisation](/developers/docs/web2-vs-web3/). Les plateformes existantes doivent assurer le bon fonctionnement de leurs propres serveurs. Le bon fonctionnement d'une plateforme décentralisée est assuré par ses utilisateurs, de sorte que le coût de fonctionnement de la plateforme centrale tombe à zéro pour le propriétaire de la plateforme.
 
-Il y a ensuite le front-end, le site Web ou l'interface qui donne accès à la plateforme. Les options sont nombreuses. Les propriétaires d'une plateforme peuvent en restreindre l'accès et obliger tout le monde à utiliser leur interface, en facturant des frais. Ils peuvent également décider d'en ouvrir l'accès (Power to the People !) et laisser n'importe qui créer des interfaces avec la plateforme. Ou encore décider d'une approche située entre ces deux extrêmes.
+Il y a ensuite le front-end, le site Web ou l'interface qui donne accès à la plateforme. Les options sont nombreuses. Les propriétaires d'une plateforme peuvent en restreindre l'accès et obliger tout le monde à utiliser leur interface, en facturant des frais. Les propriétaires de la plateforme peuvent également décider d'ouvrir l'accès (Le pouvoir au peuple !) et laisser n'importe qui construire des interfaces pour la plateforme. Ou encore décider d'une approche située entre ces deux extrêmes.
 
 _Les chefs d'entreprise qui ont plus de vision que moi sauront comment monétiser cela. Tout ce que je vois, c'est que c'est différent du statu quo et probablement rentable._
 
-Il y a aussi la question de l'automatisation et des paiements. Certaines choses peuvent être [tokénisées très efficacement](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) et échangées dans un forumde petites annonces. Les actifs tokénisés sont faciles à céder dans une blockchain. Des méthodes de paiement très complexes peuvent être facilement mises en œuvre dans une blockchain.
+Il y a aussi la question de l'automatisation et des paiements. Certaines choses peuvent être très efficacement [tokenisées](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) et échangées sur un tableau de petites annonces. Les actifs tokénisés sont faciles à céder dans une blockchain. Des méthodes de paiement très complexes peuvent être facilement mises en œuvre dans une blockchain.
 
 Je sens juste ici une occasion de faire des affaires. Il est facile de mettre en place un tableau de petites annonces sans frais de fonctionnement, avec des modalités de paiement complexes incluses pour chaque transaction. Je suis sûr que quelqu'un trouvera une idée pour concrétiser le tout.
 
@@ -40,9 +42,9 @@ Je suis ravi de m'atteler à la tâche. Jetons un coup d'oeil au code.
 
 ## Implémentation {#implementation}
 
-Il y a quelque temps, nous avons lancé un [référentiel de sources ouvertes](https://github.com/HQ20/contracts?ref=hackernoon.com) avec des exemples de concrétiser d'opportunités commerciales et d'autres goodies, veuillez y jeter un coup d'œil.
+Il y a quelque temps, nous avons lancé un [dépôt open source](https://github.com/HQ20/contracts?ref=hackernoon.com) contenant des exemples d'implémentation de cas d'entreprise et d'autres surprises, n'hésitez pas à le consulter.
 
-Le code pour ce [forum de petites annonces Ethereum](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com) est là, n'hésitez pas à l'utiliser et à en abuser. Sachez simplement que le code n'a pas été vérifié et que vous devez faire votre propre recherche avant de laisser de l'argent y entrer.
+Le code pour ce [tableau de petites annonces Ethereum](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com) s'y trouve, veuillez l'utiliser et en abuser. Sachez simplement que le code n'a pas été vérifié et que vous devez faire votre propre recherche avant de laisser de l'argent y entrer.
 
 Les principes de base du conseil ne sont pas complexes. Toutes les annonces dans le forum se résumeront juste à une structure avec quelques champs :
 
@@ -67,9 +69,9 @@ Utiliser un mapping implique simplement de trouver un identifiant pour chaque an
 
 Vient ensuite la question de savoir quels sont ces articles que nous traitons, et quelle est cette monnaie qui est utilisée pour payer la transaction.
 
-Pour les articles, nous allons simplement demander la mise en œuvre de l'interface [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com), qui n'est en fait qu'un moyen de représenter des articles du monde réel dans une blockchain, bien qu'elle [fonctionne mieux avec les actifs numériques](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com). Nous allons spécifier notre propre contrat ERC721 dans le constructeur, ce qui signifie que tous les actifs publiées dans notre forum de petites annonces doivent avoir été tokénisés au préalable.
+Pour les articles, nous allons simplement demander qu'ils implémentent l'interface [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com), qui est en fait simplement une manière de représenter des objets du monde réel sur une blockchain, bien que cela [fonctionne mieux avec des actifs numériques](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com). Nous allons spécifier notre propre contrat ERC721 dans le constructeur, ce qui signifie que tous les actifs publiées dans notre forum de petites annonces doivent avoir été tokénisés au préalable.
 
-Pour les paiements, nous allons faire quelque chose de similaire. La plupart des projets de blockchain définissent leur propre cryptomonnaie [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com). D'autres préfèrent utiliser un produit grand public comme DAI. Dans ce forum de petites annonces, il vous suffit de décider, au moment de la construction, quelle sera votre monnaie. Facile.
+Pour les paiements, nous allons faire quelque chose de similaire. La plupart des projets blockchain définissent leur propre cryptomonnaie [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com). D'autres préfèrent utiliser un produit grand public comme DAI. Dans ce forum de petites annonces, il vous suffit de décider, au moment de la construction, quelle sera votre monnaie. Facile.
 
 ```solidity
 constructor (
@@ -127,16 +129,16 @@ function cancelTrade(uint256 _trade)
   Trade memory trade = trades[_trade];
   require(
     msg.sender == trade.poster,
-    "Trade can be cancelled only by poster."
+    "L'échange ne peut être annulé que par son auteur."
   );
-  require(trade.status == "Open", "Trade is not Open.");
+  require(trade.status == "Open", "L'échange n'est pas ouvert.");
   itemToken.transferFrom(address(this), trade.poster, trade.item);
   trades[_trade].status = "Cancelled";
   emit TradeStatusChange(_trade, "Cancelled");
 }
 ```
 
-C’est tout. Vous êtes arrivé à la fin de l'implémentation. Il est assez surprenant de constater à quel point certains concepts commerciaux sont compacts lorsqu'ils sont exprimés en code, et c'est l'un de ces cas. Consultez le contrat complet [dans notre référentiel](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol).
+C’est tout. Vous êtes arrivé à la fin de l'implémentation. Il est assez surprenant de constater à quel point certains concepts commerciaux sont compacts lorsqu'ils sont exprimés en code, et c'est l'un de ces cas. Consultez le contrat complet [dans notre dépôt](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol).
 
 ## Conclusion {#conclusion}
 
@@ -146,4 +148,4 @@ Les forums de petites annonces se révèlent également être un outil facile à
 
 Dans cet article, j'ai tenté de faire le lien entre la réalité commerciale d'une entreprise de publication de petites annonces et son implémentation technologique. Ces connaissances devraient vous aider à créer une vision et une feuille de route pour l'implémentation si vous avez les bonnes compétences.
 
-Comme toujours, si vous êtes en train de construire quelque chose d'amusant et que vous souhaitez recevoir des conseils, n'hésitez pas à [m'envoyer un mot](https://albertocuesta.es/) ! Je suis toujours ravi d'aider.
+Comme toujours, si vous êtes en train de construire quelque chose d'amusant et que vous souhaitez recevoir des conseils, n'hésitez pas à m'envoyer un mot ! Je suis toujours ravi d'aider.
diff --git a/public/content/translations/fr/developers/tutorials/how-to-mint-an-nft/index.md b/public/content/translations/fr/developers/tutorials/how-to-mint-an-nft/index.md
index f51ede85368..cc3792d9c8d 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-mint-an-nft/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-mint-an-nft/index.md
@@ -1,38 +1,42 @@
 ---
-title: Comment frapper un NFT (Partie 2/3 du tutoriel NFT)
-description: Ce tutoriel explique comment frapper un NFT sur la blockchain Ethereum grâce à notre contrat intelligent et à Web3.
+title: "Comment frapper un NFT (partie 2/3 de la série de tutoriels sur les NFT)"
+description: "Ce tutoriel explique comment frapper un NFT sur la blockchain Ethereum grâce à notre contrat intelligent et à Web3."
 author: "Sumi Mudgil"
 tags:
-  - "ERC-721"
-  - "alchemy"
-  - "solidity"
-  - "contrats intelligents"
+  [
+    "ERC-721",
+    "Alchemy",
+    "Solidity",
+    "contrats intelligents"
+  ]
 skill: beginner
 lang: fr
 published: 2021-04-22
 ---
 
-[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html) : 69 millions de dollars [3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b) : 11 millions de dollars [Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens) : 6 millions de dollars
+[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html) : 69 millions de dollars
+[3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b) : 11 millions de dollars
+[Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens) : 6 millions de dollars
 
-Tous ont frappé leur NFT en utilisant la puissante API d'Alchemy. Dans ce tutoriel, nous vous apprendrons comment faire la même chose en < 10 minutes.
+Tous ont frappé leurs NFT en utilisant la puissante API d'Alchemy. Dans ce tutoriel, nous vous apprendrons comment faire la même chose en \&lt;10 minutes.
 
-« Frapper un NFT » (Minting an NFT) est l'acte de publier une instance unique de votre jeton ERC-721 sur la blockchain. En utilisant notre contrat intelligent de la [Partie 1 de cette série de tutoriels sur les NFT](/developers/tutorials/how-to-write-and-deploy-an-nft/), nous allons développer nos compétences en Web3 et frapper un NFT. À la fin de ce tutoriel, vous serez en mesure de frapper autant de NFT que vous, (ou votre portefeuille) le désirez !
+« Frapper un NFT » est l'acte de publier une instance unique de votre jeton ERC-721 sur la blockchain. En utilisant notre contrat intelligent de la [partie 1 de cette série de tutoriels sur les NFT](/developers/tutorials/how-to-write-and-deploy-an-nft/), mettons en pratique nos compétences Web3 et frappons un NFT. À la fin de ce tutoriel, vous serez en mesure de frapper autant de NFT que votre cœur (et votre portefeuille) le désire !
 
 Commençons !
 
-## Étape 1 : Installer Web3 {#install-web3}
+## Étape 1 : Installer Web3 {#install-web3}
 
-Si vous avez suivi le premier tutoriel sur la création de votre contrat intelligent NFT, vous avez déjà expérimenté Ethers.js. Web3 est similaire à Ethers, étant une bibliothèque utilisée pour faciliter la création de requêtes vers la blockchain Ethereum. Dans ce tutoriel, nous utiliserons [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3) qui est une bibliothèque Web3 améliorée proposant des essais automatiques et une prise en charge solide de WebSocket.
+Si vous avez suivi le premier tutoriel sur la création de votre contrat intelligent de NFT, vous avez déjà de l'expérience avec Ethers.js. Web3 est similaire à Ethers, car c'est une bibliothèque utilisée pour faciliter la création de requêtes sur la blockchain Ethereum. Dans ce tutoriel, nous utiliserons [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3), qui est une bibliothèque Web3 améliorée offrant des relances automatiques et une prise en charge robuste de WebSocket.
 
-Dans le répertoire d'accueil de votre projet, exécutez :
+Dans le répertoire principal de votre projet, exécutez :
 
 ```
 npm install @alch/alchemy-web3
 ```
 
-## Étape 2 : Créer un fichier `mint-nft.js` {#create-mintnftjs}
+## Étape 2 : Créer un fichier `mint-nft.js` {#create-mintnftjs}
 
-À l'intérieur de votre répertoire de scripts, créez un fichier `mint-nft.js` et ajoutez les lignes de code suivantes :
+Dans votre répertoire `scripts`, créez un fichier `mint-nft.js` et ajoutez les lignes de code suivantes :
 
 ```js
 require("dotenv").config()
@@ -41,83 +45,83 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
 const web3 = createAlchemyWeb3(API_URL)
 ```
 
-## Étape 3 : Récupérer l'ABI de votre contrat {#contract-abi}
+## Étape 3 : Récupérer l'ABI de votre contrat {#contract-abi}
 
-L'ABI (Application Binary Interface) de notre contrat est l’interface permettant d'interagir avec notre contrat intelligent. Vous en apprendrez plus sur les ABI de contrats [ici](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is). Hardhat génère automatiquement pour nous une ABI et l'enregistre dans le fichier `MyNFT.json`. Pour l'utiliser, nous devrons analyser les contenus en ajoutant les lignes de code suivantes à notre fichier `mint-nft.js` :
+L'ABI (Application Binary Interface) de notre contrat est l’interface qui permet d'interagir avec notre contrat intelligent. Vous pouvez en apprendre davantage sur les ABI de contrat [ici](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is). Hardhat génère automatiquement un ABI pour nous et l'enregistre dans le fichier `MyNFT.json`. Pour l'utiliser, nous devrons analyser le contenu en ajoutant les lignes de code suivantes à notre fichier `mint-nft.js` :
 
 ```js
 const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
 ```
 
-Si vous voulez lire l'ABI, vous pouvez l'afficher dans votre console :
+Si vous voulez voir l'ABI, vous pouvez l'afficher dans votre console :
 
 ```js
 console.log(JSON.stringify(contract.abi))
 ```
 
-Pour exécuter `mint-nft.js` et voir votre ABI affichée dans la console, naviguez vers votre terminal et exécutez :
+Pour exécuter `mint-nft.js` et voir votre ABI s'afficher dans la console, allez dans votre terminal et exécutez :
 
 ```js
 node scripts/mint-nft.js
 ```
 
-## Étape 4 : Configurer les métadonnées de votre NFT en utilisant IPFS {#config-meta}
+## Étape 4 : Configurer les métadonnées pour votre NFT à l'aide d'IPFS {#config-meta}
 
-Si vous vous rappelez de la première partie de notre tutoriel, notre fonction de contrat intelligent `mintNFT` accepte un paramètre tokenURI qui doit se résoudre en un document JSON décrivant les métadonnées du NFT - ce qui donne vraiment vie au NFT, en lui permettant d'avoir des propriétés configurables, comme un nom, une description ou encore une image, entre autres.
+Si vous vous souvenez de notre tutoriel de la partie 1, notre fonction de contrat intelligent `mintNFT` prend en entrée un paramètre tokenURI qui doit correspondre à un document JSON décrivant les métadonnées du NFT — c'est vraiment ce qui donne vie au NFT, lui permettant d'avoir des propriétés configurables, telles qu'un nom, une description, une image et d'autres attributs.
 
-> _IPFS (système de fichiers interplanétaire) est un protocole décentralisé et un réseau pair-à-pair permettant de stocker et de partager des données au sein d'un système de fichiers distribué._
+> _Interplanetary File System (IPFS) est un protocole décentralisé et un réseau pair-à-pair pour le stockage et le partage de données dans un système de fichiers distribué._
 
-Nous utiliserons Pinata, une API IPFS pratique et une boîte à outils, pour stocker nos ressources et métadonnées NFT afin de nous assurer que notre NFT est véritablement décentralisée. Si vous ne possédez pas de compte Pinata, vous pouvez en créer un gratuitement [ici](https://app.pinata.cloud) puis suivre les étapes pour confirmer votre adresse e-mail.
+Nous utiliserons Pinata, une API IPFS et une boîte à outils pratiques, pour stocker notre actif NFT et ses métadonnées afin de garantir que notre NFT est véritablement décentralisé. Si vous n'avez pas de compte Pinata, créez-en un gratuitement [ici](https://app.pinata.cloud) et suivez les étapes pour vérifier votre e-mail.
 
-Une fois que vous avez créé un compte :
+Une fois votre compte créé :
 
-- Allez sur la page « Fichiers » et cliquez sur le bouton bleu « Upload » en haut à gauche de la page.
+- Rendez-vous sur la page « Files » et cliquez sur le bouton bleu « Upload » en haut à gauche de la page.
 
-- Téléchargez une image sur Pinata — ce sera l'image de votre NFT. N’hésitez pas à nommer la ressource comme vous le souhaitez
+- Téléversez une image sur Pinata — ce sera l'image de votre NFT. N’hésitez pas à nommer l'actif comme vous le souhaitez
 
-- Après le téléchargement, vous verrez les informations sur le fichier dans le tableau de la page « Fichiers ». Vous verrez également une colonne CID. Vous pouvez copier le CID en cliquant sur le bouton copier à côté de celui-ci. Vous pouvez voir votre téléchargement sur `https://gateway.pinata.cloud/ipfs/<CID>`. Vous pouvez trouver l'image que nous avons utilisée sur IPFS [ici](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5), par exemple.
+- Après le téléversement, vous verrez les informations du fichier dans le tableau de la page « Files ». Vous verrez également une colonne CID. Vous pouvez copier le CID en cliquant sur le bouton de copie situé à côté. Vous pouvez voir votre téléversement à l'adresse suivante : `https://gateway.pinata.cloud/ipfs/<CID>`. Vous pouvez par exemple trouver l'image que nous avons utilisée sur IPFS [ici](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5).
 
-Pour les apprenants plus visuels, les étapes ci-dessus sont résumées ici :
+Pour les personnes qui préfèrent un support visuel, les étapes ci-dessus sont résumées ici :
 
-![Comment télécharger votre image sur Pinata](./instructionsPinata.gif)
+![Comment téléverser votre image sur Pinata](./instructionsPinata.gif)
 
-Maintenant, nous allons vouloir télécharger un document de plus sur Pinata. Mais avant de le faire, nous devons le créer !
+Maintenant, nous allons téléverser un document de plus sur Pinata. Mais avant cela, nous devons le créer !
 
-Dans votre répertoire racine, créez un nouveau fichier appelé `nft-metadata.json` et ajoutez le code json suivant :
+Dans votre répertoire racine, créez un nouveau fichier nommé `nft-metadata.json` et ajoutez-y le code JSON suivant :
 
 ```json
 {
   "attributes": [
     {
-      "trait_type": "Breed",
+      "trait_type": "Race",
       "value": "Maltipoo"
     },
     {
-      "trait_type": "Eye color",
-      "value": "Mocha"
+      "trait_type": "Couleur des yeux",
+      "value": "Moka"
     }
   ],
-  "description": "The world's most adorable and sensitive pup.",
+  "description": "Le chiot le plus adorable et le plus sensible du monde.",
   "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
   "name": "Ramses"
 }
 ```
 
-N'hésitez pas à modifier les données dans le json. Vous pouvez supprimer ou étoffer la section des attributs. Avant tout, assurez-vous que le champ image pointe vers l'emplacement de votre image IPFS — sinon, votre NFT inclura la photo d'un (adorable !) chien.
+N'hésitez pas à modifier les données dans le fichier JSON. Vous pouvez supprimer ou ajouter des éléments dans la section des attributs. Plus important encore, assurez-vous que le champ de l'image pointe vers l'emplacement de votre image IPFS — sinon, votre NFT inclura une photo d'un (très mignon !) chien.
 
-Une fois que vous avez fini de modifier le fichier JSON, enregistrez les modifications et téléversez-le sur Pinata, en suivant les mêmes étapes que précédemment, pour l'image.
+Une fois que vous avez fini de modifier le fichier JSON, enregistrez-le et téléversez-le sur Pinata, en suivant les mêmes étapes que pour l'image.
 
-![Comment télécharger votre nft-metadata.json sur Pinata](./uploadPinata.gif)
+![Comment téléverser votre nft-metadata.json sur Pinata](./uploadPinata.gif)
 
 ## Étape 5 : Créer une instance de votre contrat {#instance-contract}
 
-À présent, pour interagir avec notre contrat, nous avons besoin de l'instancier dans notre code. Pour ce faire, nous aurons besoin de l'adresse du contrat que nous pouvons obtenir à partir du déploiement ou d'[Etherscan](https://sepolia.etherscan.io/) en recherchant l'adresse que vous avez utilisée pour déployer le contrat.
+Maintenant, pour interagir avec notre contrat, nous devons en créer une instance dans notre code. Pour ce faire, nous aurons besoin de l'adresse de notre contrat, que nous pouvons obtenir à partir du déploiement ou de [Blockscout](https://eth-sepolia.blockscout.com/) en consultant l'adresse que vous avez utilisée pour déployer le contrat.
 
-![Consultez l'adresse de votre contrat sur Etherscan](./view-contract-etherscan.png)
+![Afficher l'adresse de votre contrat sur Etherscan](./view-contract-etherscan.png)
 
-Dans l'exemple ci-dessus, notre adresse de contrat est 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.
+Dans l'exemple ci-dessus, l'adresse de notre contrat est 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.
 
-Ensuite, nous utiliserons la [méthode pour contrat](https://docs.web3js.org/api/web3-eth-contract/class/Contract) Web3 pour créer notre contrat en utilisant l'ABI et l'adresse. Ajoutez ce qui suit dans votre fichier `mint-nft.js` :
+Ensuite, nous utiliserons la méthode de [contrat](https://docs.web3js.org/api/web3-eth-contract/class/Contract) Web3 pour créer notre contrat à l'aide de l'ABI et de l'adresse. Dans votre fichier `mint-nft.js`, ajoutez ce qui suit :
 
 ```js
 const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
@@ -127,9 +131,9 @@ const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
 
 ## Étape 6 : Mettre à jour le fichier `.env` {#update-env}
 
-Maintenant, pour créer et envoyer des transactions sur la chaîne Ethereum, nous utiliserons votre adresse publique de compte Ethereum pour obtenir le nonce du compte (explication à suivre ci-dessous).
+Maintenant, pour créer et envoyer des transactions vers la chaîne Ethereum, nous utiliserons l'adresse de votre compte public Ethereum pour obtenir le nonce du compte (nous l'expliquerons ci-dessous).
 
-Ajoutez votre clé publique à votre fichier `.env` — si vous avez terminé la première partie du tutoriel, notre fichier `.env` devrait maintenant ressembler à ceci :
+Ajoutez votre clé publique à votre fichier `.env` — si vous avez terminé la partie 1 du tutoriel, votre fichier `.env` devrait maintenant ressembler à ceci :
 
 ```js
 API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
@@ -139,25 +143,25 @@ PUBLIC_KEY = "your-public-account-address"
 
 ## Étape 7 : Créer votre transaction {#create-txn}
 
-En premier lieu, définissons une fonction nommée `mintNFT(tokenData)` et créons notre transaction en faisant ce qui suit :
+Tout d'abord, nous allons définir une fonction nommée `mintNFT(tokenData)` et créer notre transaction en procédant comme suit :
 
-1. Récupérez la clé privée _PRIVATE_KEY_ et la clé publique _PUBLIC_KEY_ depuis le fichier `.env`.
+1. Récupérez vos `PRIVATE_KEY` et `PUBLIC_KEY` depuis le fichier `.env`.
 
-1. Ensuite, nous devrons trouver le nonce du compte. La spécification nonce est utilisée pour garder une trace du nombre de transactions envoyées à partir de votre adresse — ce dont nous avons besoin pour des raisons de sécurité et pour empêcher [les attaques par répétition](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce). Pour obtenir le nombre de transactions envoyées à partir de votre adresse, nous utilisons [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
+2. Ensuite, nous devrons déterminer le nonce du compte. La spécification de nonce est utilisée pour suivre le nombre de transactions envoyées depuis votre adresse. Nous en avons besoin pour des raisons de sécurité et pour empêcher les [attaques par rejeu](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce). Pour obtenir le nombre de transactions envoyées depuis votre adresse, nous utilisons [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
 
-1. Enfin, nous allons configurer notre transaction avec les informations suivantes :
+3. Enfin, nous allons configurer notre transaction avec les informations suivantes :
 
-- `'from': PUBLIC_KEY` — L'origine de notre transaction est notre adresse publique
+- `'from': PUBLIC_KEY` — L'origine de notre transaction est notre adresse publique.
 
-- `'to': contractAddress` — Le contrat avec lequel nous souhaitons interagir et envoyer la transaction
+- `'to': contractAddress` — Le contrat avec lequel nous souhaitons interagir et auquel nous souhaitons envoyer la transaction.
 
-- `'nonce': nonce` — Le nonce du compte avec le nombre de transactions envoyées à partir de notre adresse
+- `'nonce': nonce` — Le nonce du compte, avec le nombre de transactions envoyées depuis notre adresse.
 
-- `'gas': estimatedGas` — Le gaz nécessaire estimé pour réaliser la transaction
+- `'gas': estimatedGas` — La quantité de gaz estimée nécessaire pour effectuer la transaction.
 
-- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` — Le calcul que nous souhaitons effectuer dans cette transaction — qui, dans le cas présent, est le fait de frapper un NFT
+- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` — Le calcul que nous souhaitons effectuer dans cette transaction, qui est dans ce cas le frappage d'un NFT.
 
-Votre fichier `mint-nft.js` devrait ressembler à ceci maintenant :
+Votre fichier `mint-nft.js` devrait maintenant ressembler à ceci :
 
 ```js
    require('dotenv').config();
@@ -173,9 +177,9 @@ Votre fichier `mint-nft.js` devrait ressembler à ceci maintenant :
    const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
 
    async function mintNFT(tokenURI) {
-     const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce
+     const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //obtenir le dernier nonce
 
-   //the transaction
+   //la transaction
      const tx = {
        'from': PUBLIC_KEY,
        'to': contractAddress,
@@ -188,9 +192,9 @@ Votre fichier `mint-nft.js` devrait ressembler à ceci maintenant :
 
 ## Étape 8 : Signer la transaction {#sign-txn}
 
-Maintenant que nous avons créé notre transaction, nous devons la signer afin de l’envoyer. Nous utiliserons ici notre clé privée.
+Maintenant que nous avons créé notre transaction, nous devons la signer pour pouvoir l'envoyer. C'est ici que nous allons utiliser notre clé privée.
 
-`web3.eth.sendSignedTransaction` nous donnera le hachage de la transaction que nous pouvons utiliser pour nous assurer que notre transaction a été minée et n'a pas été rejetée par le réseau. Vous remarquerez dans la section de signature de la transaction que nous avons ajouté quelques vérifications d'erreurs afin de savoir si notre transaction a bien été exécutée.
+`web3.eth.sendSignedTransaction` nous donnera le hachage de la transaction, que nous pourrons utiliser pour nous assurer que notre transaction a été minée et n'a pas été abandonnée par le réseau. Vous remarquerez que dans la section de signature de la transaction, nous avons ajouté une vérification des erreurs afin de savoir si notre transaction a été effectuée avec succès.
 
 ```js
 require("dotenv").config()
@@ -206,9 +210,9 @@ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
 const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
 
 async function mintNFT(tokenURI) {
-  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
+  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //obtenir le dernier nonce
 
-  //the transaction
+  //la transaction
   const tx = {
     from: PUBLIC_KEY,
     to: contractAddress,
@@ -225,13 +229,13 @@ async function mintNFT(tokenURI) {
         function (err, hash) {
           if (!err) {
             console.log(
-              "The hash of your transaction is: ",
+              "Le hachage de votre transaction est : ",
               hash,
-              "\nCheck Alchemy's Mempool to view the status of your transaction!"
+              "\nConsultez le Mempool d'Alchemy pour voir l'état de votre transaction !"
             )
           } else {
             console.log(
-              "Something went wrong when submitting your transaction:",
+              "Un problème est survenu lors de l'envoi de votre transaction :",
               err
             )
           }
@@ -239,22 +243,22 @@ async function mintNFT(tokenURI) {
       )
     })
     .catch((err) => {
-      console.log(" Promise failed:", err)
+      console.log(" La promesse a échoué :", err)
     })
 }
 ```
 
-## Étape 9 : Appelez `mintNFT` et exécutez le nœud `mint-nft.js` {#call-mintnft-fn}
+## Étape 9 : Appeler `mintNFT` et exécuter `node mint-nft.js` {#call-mintnft-fn}
 
-Vous vous souvenez du `metadata.json` que vous avez téléchargé sur Pinata ? Récupérez son code de hachage et passez-le comme paramètre à la fonction `mintNFT` `https://gateway.pinata.cloud/ipfs/<metadata-hash-code>`
+Vous vous souvenez du fichier `metadata.json` que vous avez téléversé sur Pinata ? Obtenez son code de hachage sur Pinata et transmettez ce qui suit comme paramètre à la fonction `mintNFT` : `https://gateway.pinata.cloud/ipfs/<metadata-hash-code>`
 
 Voici comment obtenir le code de hachage :
 
-![Comment obtenir votre hashcode de métadonnées nft sur Pinata](./metadataPinata.gif)_Comment obtenir votre code de hachage de métadonnées nft sur Pinata_
+![Comment obtenir le code de hachage des métadonnées de votre NFT sur Pinata](./metadataPinata.gif)_Comment obtenir le code de hachage des métadonnées de votre NFT sur Pinata_
 
-> Vérifiez que le code de hachage que vous avez copié est un lien vers votre `metadata.json` en chargeant `https://gateway.pinata.cloud/ipfs/<metadata-hash-code>` dans une fenêtre séparée. La page devrait ressembler à la capture d'écran ci-dessous :
+> Vérifiez que le code de hachage que vous avez copié renvoie bien à votre **metadata.json** en chargeant `https://gateway.pinata.cloud/ipfs/<metadata-hash-code>` dans une fenêtre distincte. La page devrait ressembler à la capture d'écran ci-dessous :
 
-![Votre page devrait afficher les métadonnées json](./metadataJSON.png)_Votre page devrait afficher les métadonnées json_
+![Votre page devrait afficher les métadonnées JSON](./metadataJSON.png)_Votre page devrait afficher les métadonnées JSON_
 
 Au final, votre code devrait ressembler à ceci :
 
@@ -272,9 +276,9 @@ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
 const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
 
 async function mintNFT(tokenURI) {
-  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
+  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //obtenir le dernier nonce
 
-  //the transaction
+  //la transaction
   const tx = {
     from: PUBLIC_KEY,
     to: contractAddress,
@@ -291,13 +295,13 @@ async function mintNFT(tokenURI) {
         function (err, hash) {
           if (!err) {
             console.log(
-              "The hash of your transaction is: ",
+              "Le hachage de votre transaction est : ",
               hash,
-              "\nCheck Alchemy's Mempool to view the status of your transaction!"
+              "\nConsultez le Mempool d'Alchemy pour voir l'état de votre transaction !"
             )
           } else {
             console.log(
-              "Something went wrong when submitting your transaction:",
+              "Un problème est survenu lors de l'envoi de votre transaction :",
               err
             )
           }
@@ -305,7 +309,7 @@ async function mintNFT(tokenURI) {
       )
     })
     .catch((err) => {
-      console.log("Promise failed:", err)
+      console.log("La promesse a échoué :", err)
     })
 }
 
@@ -314,16 +318,18 @@ mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
 
 Maintenant, exécutez `node scripts/mint-nft.js` pour déployer votre NFT. Après quelques secondes, vous devriez voir une réponse comme celle-ci dans votre terminal :
 
-    Le hachage de votre transaction est : 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8e8
+    ```
+    Le hachage de votre transaction est : 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
     
-    Vérifiez le Mempool d'Alchemy pour voir l'état de votre transaction !
+    Consultez le Mempool d'Alchemy pour voir l'état de votre transaction !
+    ```
 
-Ensuite, consultez votre [Alchemy mempool](https://dashboard.alchemyapi.io/mempool) pour voir l'état de votre transaction (en attente, minée ou rejetée par le réseau). Si votre transaction a été rejetée, il est également utile de vérifier [Sepolia Etherscan](https://sepolia.etherscan.io/) et rechercher votre hachage de transaction.
+Ensuite, visitez le [mempool d'Alchemy](https://dashboard.alchemyapi.io/mempool) pour voir l'état de votre transaction (si elle est en attente, minée ou abandonnée par le réseau). Si votre transaction a été abandonnée, il est également utile de consulter [Blockscout](https://eth-sepolia.blockscout.com/) et de rechercher le hachage de votre transaction.
 
-![Voir le hachage de votre transaction NFT sur Etherscan](./view-nft-etherscan.png)_Voir le hachage de votre transaction NFT sur Etherscan_
+![Afficher le hachage de votre transaction NFT sur Etherscan](./view-nft-etherscan.png)_Afficher le hachage de votre transaction NFT sur Etherscan_
 
-Et voilà ! Vous avez maintenant déployé ET frappé un NFT sur la blockchain Ethereum. <Emoji text=":money_mouth_face:" size={1} />
+Et c'est tout ! Vous avez maintenant déployé ET frappé un NFT sur la blockchain Ethereum <Emoji text=":money_mouth_face:" size={1} />
 
-En utilisant `mint-nft.js` vous pouvez frapper autant de NFT que vous (ou votre wallet crypto) désirez ! Assurez-vous juste de passer une nouvelle URI de jeton décrivant les métadonnées du NFT (sinon, vous ne réaliserez qu'une multitude de métadonnées identiques avec différents identifiants).
+Avec `mint-nft.js`, vous pouvez frapper autant de NFT que votre cœur (et votre portefeuille) le désire ! Veillez simplement à transmettre une nouvelle URI de jeton décrivant les métadonnées du NFT (sinon, vous finirez par en créer un tas d'identiques avec des ID différents).
 
-Sans doute, vous souhaiteriez pouvoir afficher votre NFT dans votre portefeuille — alors n’oubliez pas de consulter la [Partie 3 : Comment voir votre NFT dans votre portefeuille](/developers/tutorials/how-to-view-nft-in-metamask/) !
+Vous aimeriez probablement pouvoir montrer votre NFT dans votre portefeuille — alors ne manquez pas de consulter la [Partie 3 : Comment afficher votre NFT dans votre portefeuille](/developers/tutorials/how-to-view-nft-in-metamask/) !
diff --git a/public/content/translations/fr/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md b/public/content/translations/fr/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
index a18795c45ad..3fcaec57f1d 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
@@ -4,64 +4,32 @@ description: Pourquoi vous devriez vous amuser avec vos contrats lors de vos tes
 author: Markus Waas
 lang: fr
 tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "test"
-  - "bouchonnage"
+  [
+    "Solidity",
+    "contrats intelligents",
+    "test",
+    "simulation"
+  ]
 skill: intermediate
 published: 2020-05-02
 source: soliditydeveloper.com
 sourceUrl: https://soliditydeveloper.com/mocking-contracts
 ---
 
-[Les objets simulés](https://wikipedia.org/wiki/Mock_object) sont un modèle de conception commun en programmation orientée objet. Provenant du vieux mot français "mocquer", qui signifiait "se moquer de", sa signification a évolué en "imiter quelque chose de réel", ce qui est en fait ce que nous faisons en programmation. Vous pouvez vous moquer de vos contrats intelligents si vous le souhaitez, mais simulez-les dès que vous le pouvez. Cela vous facilite la vie.
+[Les objets simulés](https://wikipedia.org/wiki/Mock_object) sont un modèle de conception courant dans la programmation orientée objet. Provenant du vieux mot français "mocquer", qui signifiait "se moquer de", sa signification a évolué en "imiter quelque chose de réel", ce qui est en fait ce que nous faisons en programmation. Vous pouvez vous moquer de vos contrats intelligents si vous le souhaitez, mais simulez-les dès que vous le pouvez. Cela vous facilite la vie.
 
-## Contrats de test unitaire avec simulation {#unit-testing-contracts-with-mocks}
+## Test unitaire de contrats avec des objets simulés {#unit-testing-contracts-with-mocks}
 
-Simuler un contrat signifie essentiellement créer une seconde version de ce contrat qui se comporte d'une manière très similaire à la version originale, mais qui peut être facilement contrôlé par le développeur. Vous vous retrouvez souvent avec des contrats complexes où vous ne voulez que [tester de petites parties du contrat](/developers/docs/smart-contracts/testing/). Le problème est le suivant : que se passe-t-il si le test de cette petite partie exige un état de contrat très spécifique dans lequel il est difficile de s'y retrouver ?
+Simuler un contrat signifie essentiellement créer une seconde version de ce contrat qui se comporte d'une manière très similaire à la version originale, mais qui peut être facilement contrôlé par le développeur. Vous vous retrouvez souvent avec des contrats complexes où vous voulez seulement [tester unitairement de petites parties du contrat](/developers/docs/smart-contracts/testing/). Le problème est le suivant : que se passe-t-il si le test de cette petite partie exige un état de contrat très spécifique dans lequel il est difficile de s'y retrouver ?
 
 Vous pouvez écrire une logique de configuration de test complexe à chaque fois que le contrat est dans l'état requis ou vous pouvez écrire une simulation. Il est facile de simuler un contrat en utilisant l'héritage. Il suffit de créer un second contrat fictif qui hérite du contrat original. Vous pouvez maintenant remplacer les fonctions sur votre contrat fictif. Voyons cela avec un exemple.
 
 ## Exemple : ERC20 privé {#example-private-erc20}
 
-Notre exemple est celui d'un contrat ERC-20 ayant une durée de vie privée initiale. Le propriétaire peut gérer les utilisateurs privés et seuls ces derniers seront autorisés à recevoir des jetons au début. Une fois un certain temps écoulé, tout le monde sera autorisé à utiliser les jetons. Si vous êtes curieux, sachez que nous utilisons le crochet [`_beforeTokenTransfer`](https://docs.openzeppelin.com/contracts/5.x/extending-contracts#using-hooks) des nouveaux contrats OpenZeppelin v3.
+Notre exemple est celui d'un contrat ERC-20 ayant une durée de vie privée initiale. Le propriétaire peut gérer les utilisateurs privés et seuls ces derniers seront autorisés à recevoir des jetons au début. Une fois un certain temps écoulé, tout le monde sera autorisé à utiliser les jetons. Si vous êtes curieux, nous utilisons le hook [`_beforeTokenTransfer`](https://docs.openzeppelin.com/contracts/5.x/extending-contracts#using-hooks) des nouveaux contrats OpenZeppelin v3.
 
 ```solidity
-pragma solidity ^0.6.0;
-
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "@openzeppelin/contracts/access/Ownable.sol";
-
-contract PrivateERC20 is ERC20, Ownable {
-    mapping (address => bool) public isPrivateUser;
-    uint256 private publicAfterTime;
-
-    constructor(uint256 privateERC20timeInSec) ERC20("PrivateERC20", "PRIV") public {
-        publicAfterTime = now + privateERC20timeInSec;
-    }
-
-    function addUser(address user) external onlyOwner {
-        isPrivateUser[user] = true;
-    }
-
-    function isPublic() public view returns (bool) {
-        return now >= publicAfterTime;
-    }
-
-    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
-        super._beforeTokenTransfer(from, to, amount);
-
-        require(_validRecipient(to), "PrivateERC20: invalid recipient");
-    }
-
-    function _validRecipient(address to) private view returns (bool) {
-        if (isPublic()) {
-            return true;
-        }
-
-        return isPrivateUser[to];
-    }
-}
+pragma solidity ^0.6.0;\n\nimport "@openzeppelin/contracts/token/ERC20/ERC20.sol";\nimport "@openzeppelin/contracts/access/Ownable.sol";\n\ncontract PrivateERC20 is ERC20, Ownable {\n    mapping (address => bool) public isPrivateUser;\n    uint256 private publicAfterTime;\n\n    constructor(uint256 privateERC20timeInSec) ERC20("PrivateERC20", "PRIV") public {\n        publicAfterTime = now + privateERC20timeInSec;\n    }\n\n    function addUser(address user) external onlyOwner {\n        isPrivateUser[user] = true;\n    }\n\n    function isPublic() public view returns (bool) {\n        return now >= publicAfterTime;\n    }\n\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\n        super._beforeTokenTransfer(from, to, amount);\n\n        require(_validRecipient(to), "PrivateERC20: invalid recipient");\n    }\n\n    function _validRecipient(address to) private view returns (bool) {\n        if (isPublic()) {\n            return true;\n        }\n\n        return isPrivateUser[to];\n    }\n}
 ```
 
 Nous allons maintenant en créer une version fictive.
@@ -87,20 +55,20 @@ contract PrivateERC20Mock is PrivateERC20 {
 
 Vous obtiendrez l'un des messages d'erreur suivants :
 
-- `PrivateERC20Mock.sol: TypeError: Overriding function is missing "override" specifier.`
-- `PrivateERC20.sol: TypeError: Trying to override non-virtual function. Did you forget to add "virtual"?.`
+- `PrivateERC20Mock.sol: TypeError: La fonction de remplacement ne comporte pas de spécificateur « override ».'
+- `PrivateERC20.sol : TypeError : Tentative de remplacement d'une fonction non virtuelle. Avez-vous oublié d'ajouter « virtual » ?. '
 
-Comme nous utilisons la nouvelle version 0.6 de Solidity, nous devons ajouter le mot clé `virtual` pour les fonctions qui peuvent être remplacées et remplacer pour la fonction de remplacement. Alors ajoutons-les aux deux fonctions `isPublic`.
+Puisque nous utilisons la nouvelle version 0.6 de Solidity, nous devons ajouter le mot-clé `virtual` pour les fonctions qui peuvent être surchargées, et `override` pour la fonction qui surcharge. Ajoutons-les donc aux deux fonctions `isPublic`.
 
-Dans vos tests unitaires, vous pouvez désormais utiliser `PrivateERC20Mock` à la place. Pour tester le comportement pendant le temps d'utilisation privée, utilisez `setIsPublic(false)` et, de la même manière, `setIsPublic(true)` pour tester le temps d'utilisation publique. Bien sûr, dans notre exemple, nous pourrions juste utiliser [des aides de temps](https://docs.openzeppelin.com/test-helpers/0.5/api#increase) pour également changer les temps correspondants. Mais l'utilisation d'une version fictive devrait désormais être plus claire. Vous pouvez imaginer des scénarios où il n'est pas aussi simple de faire avancer le temps.
+Maintenant, dans vos tests unitaires, vous pouvez utiliser `PrivateERC20Mock` à la place. Lorsque vous voulez tester le comportement pendant la période d'utilisation privée, utilisez `setIsPublic(false)` et de même `setIsPublic(true)` pour tester la période d'utilisation publique. Bien sûr, dans notre exemple, nous pourrions également utiliser des [utilitaires de temps](https://docs.openzeppelin.com/test-helpers/0.5/api#increase) pour modifier les temps en conséquence. Mais l'utilisation d'une version fictive devrait désormais être plus claire. Vous pouvez imaginer des scénarios où il n'est pas aussi simple de faire avancer le temps.
 
-## Simuler de nombreux contrats {#mocking-many-contracts}
+## Simulation de nombreux contrats {#mocking-many-contracts}
 
-La situation peut devenir confuse si vous devez créer un autre contrat pour chaque simulation. Si cela vous dérange, vous pouvez jeter un coup d'oeil à la bibliothèque [MockContract](https://github.com/gnosis/mock-contract). Elle vous permet de remplacer et de modifier les comportements des contrats à la volée. Cependant, cela ne fonctionne que pour simuler des appels à un autre contrat, cela ne fonctionnerait donc pas dans notre exemple.
+La situation peut devenir confuse si vous devez créer un autre contrat pour chaque simulation. Si cela vous dérange, vous pouvez jeter un œil à la bibliothèque [MockContract](https://github.com/gnosis/mock-contract). Elle vous permet de surcharger et de modifier les comportements des contrats à la volée. Cependant, cela ne fonctionne que pour simuler des appels à un autre contrat, cela ne fonctionnerait donc pas dans notre exemple.
 
 ## La simulation peut être encore plus puissante {#mocking-can-be-even-more-powerful}
 
 Les pouvoirs de la simulation ne s'arrêtent pas là.
 
-- Ajout de fonctions : Il peut être utile non seulement de remplacer une fonction spécifique, mais aussi d'ajouter des fonctions supplémentaires. Pour les jetons, un bon exemple est simplement d'avoir une fonction `mint` supplémentaire pour permettre à tout utilisateur d'obtenir de nouveaux jetons gratuitement.
+- Ajout de fonctions : Il peut être utile non seulement de remplacer une fonction spécifique, mais aussi d'ajouter des fonctions supplémentaires. Un bon exemple pour les jetons consiste simplement à disposer d'une fonction `mint` supplémentaire pour permettre à n'importe quel utilisateur d'obtenir gratuitement de nouveaux jetons.
 - Utilisation dans les réseaux de test : Lorsque vous déployez et testez vos contrats sur des réseaux de test avec votre dapp, envisagez d'utiliser une version fictive. Évitez de remplacer des fonctions à moins que cela ne soit indispensable. Après tout, vous voulez tester la logique réelle. Il peut néanmoins être utile d'ajouter, par exemple, une fonction de réinitialisation, celle-ci vous permettant de réinitialiser simplement l'état du contrat au début, sans avoir à effectuer de nouveau déploiement. Évidemment, vous ne voudriez pas de cela dans un contrat de réseau principal.
diff --git a/public/content/translations/fr/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md b/public/content/translations/fr/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
index 48ff428c35d..2ba9d9febf4 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
@@ -4,20 +4,22 @@ description: Comment utiliser Echidna pour tester automatiquement les contrats i
 author: "Trailofbits"
 lang: fr
 tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "sécurité"
-  - "test"
-  - "fuzzing"
+  [
+    "Solidity",
+    "contrats intelligents",
+    "sécurité",
+    "test",
+    "fuzzing"
+  ]
 skill: advanced
 published: 2020-04-10
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna
 ---
 
 ## Installation {#installation}
 
-Echidna peut être installé via Docker ou en utilisant un binaire pré-compilé.
+Echidna peut être installé via Docker ou en utilisant un binaire précompilé.
 
 ### Echidna via Docker {#echidna-through-docker}
 
@@ -26,9 +28,9 @@ docker pull trailofbits/eth-security-toolbox
 docker run -it -v "$PWD":/home/training trailofbits/eth-security-toolbox
 ```
 
-_La dernière commande exécute eth-security-toolbox dans un docker qui a accès à votre répertoire actuel. Vous pouvez changer les fichiers depuis votre invite, et exécuter les outils sur les fichiers depuis le docker_
+_La dernière commande exécute eth-security-toolbox dans un docker qui a accès à votre répertoire actuel. Vous pouvez modifier les fichiers depuis votre hôte, et exécuter les outils sur les fichiers depuis le docker_
 
-Dans docker, exécutez :
+Dans Docker, exécutez :
 
 ```bash
 solc-select 0.5.11
@@ -41,27 +43,27 @@ cd /home/training
 
 ## Introduction au fuzzing basé sur les propriétés {#introduction-to-property-based-fuzzing}
 
-Echidna est un fuzzer basé sur les propriétés que nous avons décrit dans nos blogs précédents ([1](https://blog.trailofbits.com/2018/03/09/echidna-a-smart-fuzzer-for-ethereum/), [2](https://blog.trailofbits.com/2018/05/03/state-machine-testing-with-echidna/), [3](https://blog.trailofbits.com/2020/03/30/an-echidna-for-all-seasons/)).
+Echidna est un fuzzer basé sur les propriétés, que nous avons décrit dans nos précédents articles de blog ([1](https://blog.trailofbits.com/2018/03/09/echidna-a-smart-fuzzer-for-ethereum/), [2](https://blog.trailofbits.com/2018/05/03/state-machine-testing-with-echidna/), [3](https://blog.trailofbits.com/2020/03/30/an-echidna-for-all-seasons/)).
 
-### Fuzzing (test à données aléatoires) {#fuzzing}
+### Fuzzing {#fuzzing}
 
-Le [Fuzzing](https://wikipedia.org/wiki/Fuzzing) est une technique bien connue dans la communauté concernée par la sécurité. Il consiste à générer des entrées plus ou moins aléatoires pour trouver des bogues dans le programme. Les fuzzers pour les logiciels traditionnels (comme [AFL](http://lcamtuf.coredump.cx/afl/) ou [LibFuzzer](https://llvm.org/docs/LibFuzzer.html)) sont connus pour être des outils efficaces quant au repérage des bogues.
+[Le fuzzing](https://wikipedia.org/wiki/Fuzzing) est une technique bien connue dans la communauté de la sécurité. Elle consiste à générer des entrées plus ou moins aléatoires pour trouver des bogues dans le programme. Les fuzzers pour les logiciels traditionnels (tels que [AFL](http://lcamtuf.coredump.cx/afl/) ou [LibFuzzer](https://llvm.org/docs/LibFuzzer.html)) sont connus pour être des outils efficaces pour trouver des bogues.
 
-Au-delà de la génération purement aléatoire d'entrées, il existe de nombreuse techniques et stratégies pour générer de bonnes contributions, y compris :
+Au-delà de la génération purement aléatoire d'entrées, il existe de nombreuses techniques et stratégies pour générer de bonnes entrées, notamment :
 
-- Obtenez des commentaires en retour de chaque exécution et la génération de guides en les utilisant. Par exemple, si une entrée nouvellement générée mène à la découverte d'un nouveau chemin, il peut y avoir un sens à générer de nouvelles entrées s'en rapprochant.
-- Génération d'entrée dans le respect d'une contrainte structurelle. Par exemple, si votre entrée contient un en-tête avec une somme de contrôle, il sera logique de laisser le fuzzer générer une entrée validant la somme de contrôle.
-- Utiliser des entrées connues pour générer de nouvelles entrées : si vous avez accès à un grand jeu de données d'entrée valide, votre fuzzer peut générer de nouvelles entrées à partir d'elles, plutôt que de faire partir de zéro sa génération. Elles sont généralement appelées _seeds_.
+- Obtenir des retours de chaque exécution et les utiliser pour guider la génération. Par exemple, si une nouvelle entrée générée mène à la découverte d'un nouveau chemin, il peut être judicieux de générer de nouvelles entrées proches de celle-ci.
+- Générer l'entrée en respectant une contrainte structurelle. Par exemple, si votre entrée contient un en-tête avec une somme de contrôle, il sera logique de laisser le fuzzer générer une entrée validant la somme de contrôle.
+- Utiliser des entrées connues pour en générer de nouvelles : si vous avez accès à un grand jeu de données d'entrées valides, votre fuzzer peut générer de nouvelles entrées à partir de celles-ci, plutôt que de commencer la génération à partir de zéro. On les appelle généralement des _seeds_.
 
-### Fuzzing orienté propriétés {#property-based-fuzzing}
+### Fuzzing basé sur les propriétés {#property-based-fuzzing}
 
-Echidna appartient à une famille spécifique de fuzzer : le fuzzing basé sur des propriétés fortement inspirées par [QuickCheck](https://wikipedia.org/wiki/QuickCheck). Contrairement au fuzzer classique qui va essayer de trouver des plantages, Echidna essayera de casser les invariants définis par l'utilisateur.
+Echidna appartient à une famille spécifique de fuzzer : le fuzzing basé sur les propriétés, fortement inspiré de [QuickCheck](https://wikipedia.org/wiki/QuickCheck). Contrairement à un fuzzer classique qui essaiera de trouver des plantages, Echidna essaiera de rompre des invariants définis par l'utilisateur.
 
-Dans les contrats intelligents, les invariants sont des fonctions Solidity qui peuvent représenter tout état incorrect ou non valide que le contrat peut atteindre, y compris :
+Dans les contrats intelligents, les invariants sont des fonctions Solidity, qui peuvent représenter n'importe quel état incorrect ou invalide que le contrat peut atteindre, notamment :
 
 - Contrôle d'accès incorrect : l'attaquant est devenu le propriétaire du contrat.
-- Machine d'état incorrecte : les jetons peuvent être transférés pendant que le contrat est suspendu.
-- Arithmétique incorrecte : l'utilisateur peut faire déborder son solde et obtenir des jetons gratuits en illimités.
+- Machine d'état incorrecte : les jetons peuvent être transférés alors que le contrat est en pause.
+- Arithmétique incorrecte : l'utilisateur peut provoquer un underflow de son solde et obtenir un nombre illimité de jetons gratuits.
 
 ### Tester une propriété avec Echidna {#testing-a-property-with-echidna}
 
@@ -83,7 +85,7 @@ contract Token{
 }
 ```
 
-Nous prendrons comme hypothèse que ce jeton doit avoir les propriétés suivantes :
+Nous supposerons que ce jeton doit avoir les propriétés suivantes :
 
 - N'importe qui peut avoir au maximum 1000 jetons
 - Le jeton ne peut pas être transféré (ce n'est pas un jeton ERC20)
@@ -92,17 +94,17 @@ Nous prendrons comme hypothèse que ce jeton doit avoir les propriétés suivant
 
 Les propriétés Echidna sont des fonctions Solidity. Une propriété doit :
 
-- Ne contenir aucun argument
-- Renvoyer `true` si elle a réussi
-- Avoir son nom commençant par `echidna`
+- Ne pas avoir d'argument
+- Renvoyer `true` si elle réussit
+- Avoir un nom qui commence par `echidna`
 
-Echidna va :
+Echidna :
 
 - Générer automatiquement des transactions arbitraires pour tester la propriété.
-- Signaler toute transaction menant à une propriété pour renvoyer `false` ou retourner une erreur.
-- Ignorer l'effet secondaire lors de l'appel d'une propriété (c'est-à-dire si la propriété change une variable d'état, elle est rejetée après le test)
+- Signaler toute transaction qui amène une propriété à renvoyer `false` ou à lever une erreur.
+- Ignorer les effets de bord lors de l'appel d'une propriété (c.-à-d. que si la propriété modifie une variable d'état, la modification est annulée après le test)
 
-La propriété suivante vérifie que l'appelant ne dispose pas de plus de 1000 jetons :
+La propriété suivante vérifie que l'appelant n'a pas plus de 1000 jetons :
 
 ```solidity
 function echidna_balance_under_1000() public view returns(bool){
@@ -120,18 +122,18 @@ contract TestToken is Token{
   }
 ```
 
-[`token.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/token.sol) implémente la propriété et hérite du jeton.
+[`token.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/token.sol) met en œuvre la propriété et hérite du jeton.
 
-### Démarrer un contrat {#initiate-a-contract}
+### Initialiser un contrat {#initiate-a-contract}
 
-Echidna a besoin d'un [constructeur](/developers/docs/smart-contracts/anatomy/#constructor-functions) sans argument. Si votre contrat nécessite une initialisation spécifique, vous devez le faire dans le constructeur.
+Echidna a besoin d'un [constructeur](/developers/docs/smart-contracts/anatomy/#constructor-functions) sans argument. Si votre contrat nécessite une initialisation spécifique, vous devez la faire dans le constructeur.
 
-Il existe quelques adresses spécifiques dans Echidna :
+Il y a quelques adresses spécifiques dans Echidna :
 
-- `0x00a329c0648769A73afAc7F9381E08FB43dBEA7` qui appelle le constructeur.
-- `0x10000`, `0x20000`, et `0x00a329C0648769a73afAC7F9381e08fb43DBEA70` qui appellent aléatoirement les autres fonctions.
+- `0x00a329c0648769A73afAc7F9381E08FB43dBEA72` qui appelle le constructeur.
+- `0x10000`, `0x20000` et `0x00a329C0648769a73afAC7F9381e08fb43DBEA70` qui appellent aléatoirement les autres fonctions.
 
-Nous n'avons pas besoin d'initialisation particulière dans notre exemple actuel, de fait, notre constructeur est vide.
+Nous n'avons pas besoin d'initialisation particulière dans notre exemple actuel, par conséquent notre constructeur est vide.
 
 ### Exécuter Echidna {#run-echidna}
 
@@ -149,7 +151,7 @@ echidna-test contract.sol --contract MyContract
 
 ### Résumé : Tester une propriété {#summary-testing-a-property}
 
-Ce qui suit permet de résumer le lancement d'Echidna pour notre exemple :
+Ce qui suit résume l'exécution d'Echidna sur notre exemple :
 
 ```solidity
 contract TestToken is Token{
@@ -172,11 +174,12 @@ echidna_balance_under_1000: failed!💥
 ...
 ```
 
-Echidna a trouvé que la propriété sera compromise si `backdoor` est appelé.
+Echidna a trouvé que la propriété est violée si `backdoor` est appelée.
 
-## Fonctions de filtrage à appeler lors d'une campagne de fuzzing {#filtering-functions-to-call-during-a-fuzzing-campaign}
+## Filtrer les fonctions à appeler pendant une campagne de fuzzing {#filtering-functions-to-call-during-a-fuzzing-campaign}
 
-Nous verrons comment filtrer les fonctions à fuzzer. La cible est le contrat intelligent suivant :
+Nous verrons comment filtrer les fonctions à fuzzer.
+La cible est le contrat intelligent suivant :
 
 ```solidity
 contract C {
@@ -227,7 +230,9 @@ contract C {
 }
 ```
 
-Ce petit exemple oblige Echidna à trouver une certaine séquence de transactions pour modifier une variable d'état. C'est une opération compliquée pour un fuzzer (il est recommandé d'utiliser un outil d'exécution symbolique comme [Manticore](https://github.com/trailofbits/manticore)). Nous pouvons exécuter Echidna pour vérifier ceci :
+Ce petit exemple force Echidna à trouver une certaine séquence de transactions pour modifier une variable d'état.
+C'est difficile pour un fuzzer (il est recommandé d'utiliser un outil d'exécution symbolique comme [Manticore](https://github.com/trailofbits/manticore)).
+Nous pouvons exécuter Echidna pour vérifier cela :
 
 ```bash
 echidna-test multi.sol
@@ -236,30 +241,32 @@ echidna_state4: passed! 🎉
 Seed: -3684648582249875403
 ```
 
-### Fonctions de filtrage {#filtering-functions}
+### Filtrage des fonctions {#filtering-functions}
 
-Echidna a du mal à trouver la séquence correcte pour tester ce contrat, car les deux fonctions de réinitialisation (`reset1` et `reset2`) mettront toutes les variables d'état sur `false`. Cependant, nous pouvons utiliser une fonctionnalité spéciale d'Echidna pour mettre sur liste noire la fonction reset ou pour ne mettre sur liste blanche que les fonctions `f`, `g`, `h` et `i`.
+Echidna a du mal à trouver la séquence correcte pour tester ce contrat, car les deux fonctions de réinitialisation (`reset1` et `reset2`) mettront toutes les variables d'état à `false`.
+Cependant, nous pouvons utiliser une fonctionnalité spéciale d'Echidna pour soit mettre sur liste noire la fonction de réinitialisation, soit mettre sur liste blanche uniquement les fonctions `f`, `g`,
+`h` et `i`.
 
-Pour bloquer les fonctions, nous pouvons utiliser ce fichier de configuration :
+Pour mettre des fonctions sur liste noire, nous pouvons utiliser ce fichier de configuration :
 
 ```yaml
 filterBlacklist: true
 filterFunctions: ["reset1", "reset2"]
 ```
 
-Une autre approche des fonctions de filtrage est de lister les fonctions dans une liste blanche. Pour cela, nous pouvons utiliser ce fichier de configuration :
+Une autre approche pour filtrer les fonctions consiste à lister les fonctions sur liste blanche. Pour ce faire, nous pouvons utiliser ce fichier de configuration :
 
 ```yaml
 filterBlacklist: false
 filterFunctions: ["f", "g", "h", "i"]
 ```
 
-- `filterBlacklist` est sur `true` par défaut.
-- Le filtrage sera effectué uniquement par le nom (sans les paramètres). Si vous avez `f()` et `f(uint256)`, le filtre `"f"` correspondra aux deux fonctions.
+- `filterBlacklist` est `true` par défaut.
+- Le filtrage sera effectué uniquement par nom (sans les paramètres). Si vous avez `f()` et `f(uint256)`, le filtre `"f"` correspondra aux deux fonctions.
 
 ### Exécuter Echidna {#run-echidna-1}
 
-Exécuter Echidna avec un fichier de configuration `blacklist.yaml` :
+Pour exécuter Echidna avec un fichier de configuration `blacklist.yaml` :
 
 ```bash
 echidna-test multi.sol --config blacklist.yaml
@@ -272,11 +279,11 @@ echidna_state4: failed!💥
     i()
 ```
 
-Echidna trouvera presque immédiatement la séquence des transactions pour falsifier la propriété.
+Echidna trouvera la séquence de transactions pour falsifier la propriété presque immédiatement.
 
-### Résumé : fonctions de filtrage {#summary-filtering-functions}
+### Résumé : Filtrage des fonctions {#summary-filtering-functions}
 
-Echidna peut soit mettre sur liste noire, soit mettre sur liste blanche des fonctions à appeler pendant une campagne de fuzzing en utilisant :
+Echidna peut soit mettre sur liste noire, soit mettre sur liste blanche les fonctions à appeler pendant une campagne de fuzzing en utilisant :
 
 ```yaml
 filterBlacklist: true
@@ -288,11 +295,11 @@ echidna-test contract.sol --config config.yaml
 ...
 ```
 
-Echidna débute une campagne de fuzzing soit en ajoutant `f1`, `f2` et `f3` sur la liste noire, ou en les appelant uniquement selon la valeur booléenne définie dans `filterBlacklist`.
+Echidna lance une campagne de fuzzing soit en mettant sur liste noire `f1`, `f2` et `f3`, soit en appelant uniquement celles-ci, en fonction de la valeur du booléen `filterBlacklist`.
 
-## Comment tester les assertions de Solidity avec Echidna {#how-to-test-soliditys-assert-with-echidna}
+## Comment tester l'assertion de Solidity avec Echidna {#how-to-test-soliditys-assert-with-echidna}
 
-Dans ce court tutoriel, nous allons montrer comment utiliser Echidna pour tester la vérification des assertions dans les contrats. Supposons que nous ayons un contrat comme celui-ci :
+Dans ce court tutoriel, nous allons montrer comment utiliser Echidna pour tester la vérification d'assertions dans les contrats. Supposons que nous ayons un contrat comme celui-ci :
 
 ```solidity
 contract Incrementor {
@@ -309,7 +316,8 @@ contract Incrementor {
 
 ### Écrire une assertion {#write-an-assertion}
 
-Nous voulons nous assurer que `tmp` est inférieur ou égal à `counter` après avoir retourné sa différence. Nous pourrions écrire une propriété Echidna, mais nous devrons stocker la valeur `tmp` quelque part. Au lieu de cela, nous pourrions utiliser une assertion comme celle-ci :
+Nous voulons nous assurer que `tmp` est inférieur ou égal à `counter` après avoir renvoyé leur différence. Nous pourrions écrire une propriété
+Echidna, mais nous devrons stocker la valeur de `tmp` quelque part. À la place, nous pourrions utiliser une assertion comme celle-ci :
 
 ```solidity
 contract Incrementor {
@@ -326,13 +334,13 @@ contract Incrementor {
 
 ### Exécuter Echidna {#run-echidna-2}
 
-Pour activer le test d'échec à l'assertion, créez un [fichier de configuration Echidna](https://github.com/crytic/echidna/wiki/Config) `config.yaml` :
+Pour activer le test d'échec d'assertion, créez un [fichier de configuration Echidna](https://github.com/crytic/echidna/wiki/Config) `config.yaml` :
 
 ```yaml
 checkAsserts: true
 ```
 
-Lorsque nous exécutons ce contrat sur Echidna, nous obtenons les résultats escomptés :
+Lorsque nous exécutons ce contrat dans Echidna, nous obtenons les résultats attendus :
 
 ```bash
 echidna-test assert.sol --config config.yaml
@@ -346,15 +354,15 @@ assertion in inc: failed!💥
 Seed: 1806480648350826486
 ```
 
-Comme vous pouvez le voir, Echidna signale un échec d'assertion dans la fonction `inc`. L'ajout de plus d'une assertion par fonction est possible, mais Echidna ne peut pas dire quelle assertion a échoué.
+Comme vous pouvez le voir, Echidna signale un échec d'assertion dans la fonction `inc`. Il est possible d'ajouter plus d'une assertion par fonction, mais Echidna ne peut pas dire quelle assertion a échoué.
 
 ### Quand et comment utiliser les assertions {#when-and-how-use-assertions}
 
-Les assertions peuvent être utilisées comme alternatives aux propriétés explicites, spécialement si les conditions à vérifier sont directement liées à l'utilisation correcte de certaines opérations `f`. Ajouter des assertions après certains codes garantira que la vérification se produira immédiatement après son exécution :
+Les assertions peuvent être utilisées comme alternatives aux propriétés explicites, surtout si les conditions à vérifier sont directement liées à l'utilisation correcte d'une opération `f`. L'ajout d'assertions après un morceau de code garantira que la vérification aura lieu immédiatement après son exécution :
 
 ```solidity
 function f(..) public {
-    // some complex code
+    // du code complexe
     ...
     assert (condition);
     ...
@@ -362,7 +370,7 @@ function f(..) public {
 
 ```
 
-Au contraire, utiliser une propriété Echidna explicite va exécuter aléatoirement des transactions et il n'y a pas de moyen facile de forcer le moment exact où elle sera vérifiée. Il est toujours possible de faire ce contournement :
+Au contraire, l'utilisation d'une propriété Echidna explicite exécutera des transactions de manière aléatoire et il n'y a aucun moyen simple de forcer le moment exact où elle sera vérifiée. Il est toujours possible d'utiliser cette solution de contournement :
 
 ```solidity
 function echidna_assert_after_f() public returns (bool) {
@@ -371,22 +379,22 @@ function echidna_assert_after_f() public returns (bool) {
 }
 ```
 
-Cependant, il existe quelques problèmes :
+Cependant, il y a quelques problèmes :
 
-- Il échoue si `f` est déclaré comme `internal` ou `external`.
-- Il n'est pas clair de savoir quels arguments doivent être utilisés pour appeler `f`.
-- Si `f` s'annule, la propriété échouera.
+- Elle échoue si `f` est déclarée comme `internal` ou `external`.
+- On ne sait pas clairement quels arguments devraient être utilisés pour appeler `f`.
+- Si `f` revert, la propriété échouera.
 
 En général, nous recommandons de suivre [la recommandation de John Regehr](https://blog.regehr.org/archives/1091) sur la façon d'utiliser les assertions :
 
-- Ne forcez aucun effet secondaire lors de la vérification de l'assertion. Par exemple : `assert(ChangeStateAndReturn() == 1)`
-- Ne revendiquez pas des déclarations évidentes. Par exemple `assert(var >= 0)` où `var` est déclaré comme `uint`.
+- Ne forcez aucun effet de bord lors de la vérification de l'assertion. Par exemple : `assert(ChangeStateAndReturn() == 1)`
+- Ne faites pas d'assertions sur des déclarations évidentes. Par exemple `assert(var >= 0)` où `var` est déclaré en tant que `uint`.
 
-Enfin, s'il vous plaît **n'utilisez pas** `require` au lieu de `assert`, car dans ce cas, Echidna ne sera pas en mesure de le détecter (mais le contrat sera annulé de toute façon).
+Enfin, veuillez **ne pas utiliser** `require` à la place d'`assert`, car Echidna ne sera pas en mesure de le détecter (mais le contrat sera annulé de toute façon).
 
-### Résumé : vérification d'assertion {#summary-assertion-checking}
+### Résumé : Vérification d'assertion {#summary-assertion-checking}
 
-Ce qui suit permet de résumer le lancement d'Echidna pour notre exemple :
+Ce qui suit résume l'exécution d'Echidna sur notre exemple :
 
 ```solidity
 contract Incrementor {
@@ -413,9 +421,9 @@ assertion in inc: failed!💥
 Seed: 1806480648350826486
 ```
 
-Echidna a trouvé que l'assertion dans `inc` peut échouer si cette fonction est appelée plusieurs fois avec de grands arguments.
+Echidna a découvert que l'assertion dans `inc` peut échouer si cette fonction est appelée plusieurs fois avec de grands arguments.
 
-## Collecte et modification d'un corpus Echidna {#collecting-and-modifying-an-echidna-corpus}
+## Collecter et modifier un corpus Echidna {#collecting-and-modifying-an-echidna-corpus}
 
 Nous verrons comment collecter et utiliser un corpus de transactions avec Echidna. La cible est le contrat intelligent suivant [`magic.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/magic.sol) :
 
@@ -437,7 +445,9 @@ contract C {
 }
 ```
 
-Ce simple exemple oblige Echidna à trouver certaines valeurs pour changer une variable d'état. C'est une opération compliquée pour un fuzzer (il est recommandé d'utiliser un outil d'exécution symbolique comme [Manticore](https://github.com/trailofbits/manticore)). Nous pouvons exécuter Echidna pour vérifier ceci :
+Ce simple exemple oblige Echidna à trouver certaines valeurs pour changer une variable d'état. C'est difficile pour un fuzzer
+(il est recommandé d'utiliser un outil d'exécution symbolique comme [Manticore](https://github.com/trailofbits/manticore)).
+Nous pouvons exécuter Echidna pour vérifier cela :
 
 ```bash
 echidna-test magic.sol
@@ -450,7 +460,7 @@ Seed: 2221503356319272685
 
 Cependant, nous pouvons toujours utiliser Echidna pour collecter le corpus lors de l'exécution de cette campagne de fuzzing.
 
-### Récupération d'un corpus {#collecting-a-corpus}
+### Collecte d'un corpus {#collecting-a-corpus}
 
 Pour activer la collecte de corpus, créez un répertoire de corpus :
 
@@ -471,7 +481,8 @@ Maintenant nous pouvons exécuter notre outil et vérifier le corpus collecté :
 echidna-test magic.sol --config config.yaml
 ```
 
-Echidna ne peut toujours pas trouver les bonnes valeurs magiques, mais nous pouvons jeter un œil sur le corpus qu'il a collecté. Par exemple, l'un de ces fichiers était :
+Echidna ne peut toujours pas trouver les bonnes valeurs magiques, mais nous pouvons jeter un œil sur le corpus qu'il a collecté.
+Par exemple, l'un de ces fichiers était :
 
 ```json
 [
@@ -518,9 +529,10 @@ Echidna ne peut toujours pas trouver les bonnes valeurs magiques, mais nous pouv
 
 Évidemment, cette entrée ne déclenchera pas l'échec de notre propriété. Cependant, au cours de la prochaine étape, nous verrons comment la modifier en ce sens.
 
-### Alimenter un corpus {#seeding-a-corpus}
+### Amorcer un corpus {#seeding-a-corpus}
 
-Echidna a besoin d'aide pour gérer la fonction `magic`. Nous allons copier et modifier l'entrée pour utiliser les paramètres appropriés :
+Echidna a besoin d'aide pour gérer la fonction `magic`. Nous allons copier et modifier l'entrée pour utiliser des paramètres appropriés
+pour elle :
 
 ```bash
 cp corpus/2712688662897926208.txt corpus/new.txt
@@ -544,7 +556,7 @@ Seed: -7293830866560616537
 
 Cette fois-ci, il a conclu immédiatement que la propriété a été compromise.
 
-## Recherche de transactions à forte consommation de gaz {#finding-transactions-with-high-gas-consumption}
+## Trouver les transactions à forte consommation de gaz {#finding-transactions-with-high-gas-consumption}
 
 Nous verrons comment trouver avec Echida les transactions à forte consommation de gaz. La cible est le contrat intelligent suivant :
 
@@ -571,9 +583,10 @@ contract C {
 }
 ```
 
-Ici `expensive` peut avoir une grande consommation de gaz.
+Ici, `expensive` peut avoir une grande consommation de gaz.
 
-Actuellement, Echidna a toujours besoin d'une propriété pour tester : ici `echidna_test` retourne toujours `true`. Nous pouvons exécuter Echidna pour vérifier ceci :
+Actuellement, Echidna a toujours besoin d'une propriété pour tester : ici, `echidna_test` renvoie toujours `true`.
+Nous pouvons exécuter Echidna pour vérifier cela :
 
 ```
 echidna-test gas.sol
@@ -585,7 +598,7 @@ Seed: 2320549945714142710
 
 ### Mesurer la consommation de gaz {#measuring-gas-consumption}
 
-Pour activer avec Echidna la consommation de gaz, créez un fichier de configuration `config.yaml` :
+Pour activer la consommation de gaz avec Echidna, créez un fichier de configuration `config.yaml` :
 
 ```yaml
 estimateGas: true
@@ -598,7 +611,7 @@ seqLen: 2
 estimateGas: true
 ```
 
-### Run Echidna {#run-echidna-3}
+### Exécuter Echidna {#run-echidna-3}
 
 Une fois que nous avons créé le fichier de configuration, nous pouvons exécuter Echidna comme ceci :
 
@@ -617,12 +630,14 @@ Seed: -325611019680165325
 
 ```
 
-- Le gaz affiché est une estimation fournie par [HEVM](https://github.com/dapphub/dapptools/tree/master/src/hevm#hevm-).
+- Le gaz indiqué est une estimation fournie par [HEVM](https://github.com/dapphub/dapptools/tree/master/src/hevm#hevm-).
 
-### Filtrer les appels de réduction de gaz {#filtering-out-gas-reducing-calls}
+### Filtrer les appels qui réduisent le gaz {#filtering-out-gas-reducing-calls}
 
-Le tutoriel ci-dessus sur les **fonctions de filtrage à appeler lors d'une campagne de fuzzing** montre comment supprimer certaines fonctions de votre test.  
-Cela peut être critique pour obtenir une estimation précise de gaz. Prenons l'exemple suivant :
+Le tutoriel ci-dessus sur le **filtrage des fonctions à appeler pendant une campagne de fuzzing** montre comment
+supprimer certaines fonctions de vos tests.  
+Cela peut être essentiel pour obtenir une estimation précise du gaz.
+Prenons l'exemple suivant :
 
 ```solidity
 contract C {
@@ -662,7 +677,8 @@ clear used a maximum of 35916 gas
 push used a maximum of 40839 gas
 ```
 
-C'est parce que le coût dépend de la taille des `addrs` et que les appels aléatoires ont tendance à laisser le tableau presque vide. Mettre sur liste noire `pop` et `clear` nous donne de bien meilleurs résultats :
+C'est parce que le coût dépend de la taille de `addrs` et que les appels aléatoires ont tendance à laisser le tableau presque vide.
+Mettre sur liste noire `pop` et `clear` nous donne de bien meilleurs résultats :
 
 ```yaml
 filterBlacklist: true
@@ -677,7 +693,7 @@ push used a maximum of 40839 gas
 check used a maximum of 1484472 gas
 ```
 
-### Résumé : trouver des transactions avec une forte consommation de gaz {#summary-finding-transactions-with-high-gas-consumption}
+### Résumé : Trouver les transactions à forte consommation de gaz {#summary-finding-transactions-with-high-gas-consumption}
 
 Echidna peut trouver des transactions avec une forte consommation de gaz en utilisant l'option de configuration `estimateGas` :
 
diff --git a/public/content/translations/fr/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md b/public/content/translations/fr/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
index 8190b8b8b95..e9c234dd9ee 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
@@ -1,36 +1,38 @@
 ---
 title: Comment utiliser Manticore pour trouver des bugs dans les contrats intelligents
-description: Comment utiliser Manticore pour trouver automatiquement des bugs dans les smart contracts
+description: Comment utiliser Manticore pour trouver automatiquement des bugs dans les contrats intelligents
 author: Trailofbits
 lang: fr
 tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "sécurité"
-  - "test"
-  - "vérification formelle"
+  [
+    "Solidity",
+    "contrats intelligents",
+    "sécurité",
+    "test",
+    "vérification formelle"
+  ]
 skill: advanced
 published: 2020-01-13
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore
 ---
 
-Le but de ce tutoriel est de démontrer comment utiliser Manticore pour trouver automatiquement des bugs dans les contrats intelligents.
+Le but de ce tutoriel est de montrer comment utiliser Manticore pour trouver automatiquement des bugs dans les contrats intelligents.
 
 ## Installation {#installation}
 
-Manticore requiert >= python 3.6. Il peut être installé via pip ou avec docker.
+Manticore requiert python >= 3.6. Il peut être installé via pip ou en utilisant docker.
 
-### Manticore via Docker {#manticore-through-docker}
+### Manticore via docker {#manticore-through-docker}
 
 ```bash
 docker pull trailofbits/eth-security-toolbox
 docker run -it -v "$PWD":/home/training trailofbits/eth-security-toolbox
 ```
 
-_La dernière commande exécute eth-security-toolbox dans un docker qui a accès à votre répertoire actif. Vous pouvez changer les fichiers depuis votre invite, et exécuter les outils sur les fichiers depuis le docker_
+_La dernière commande exécute eth-security-toolbox dans un docker qui a accès à votre répertoire actuel. Vous pouvez modifier les fichiers depuis votre hôte, et exécuter les outils sur les fichiers depuis le docker_
 
-Dans docker, lancez :
+À l'intérieur de docker, exécutez :
 
 ```bash
 solc-select 0.5.11
@@ -55,18 +57,18 @@ python3 script.py
 
 ## Introduction à l'exécution symbolique dynamique {#introduction-to-dynamic-symbolic-execution}
 
-### L'exécution symbolique dynamique en quelques mots {#dynamic-symbolic-execution-in-a-nutshell}
+### L'exécution symbolique dynamique en bref {#dynamic-symbolic-execution-in-a-nutshell}
 
-L'exécution symbolique dynamique (DSE) est une technique d'analyse de programme qui explore un espace d'état avec un degré élevé de conscience sémantique. Cette technique est basée sur la découverte de « chemins de programme », représentée sous la forme de formules mathématiques appelées `prédicats de chemin`. Conceptuellement, cette technique opère sur les prédicats de chemin en deux étapes :
+L'exécution symbolique dynamique (DSE) est une technique d'analyse de programme qui explore un espace d'état avec un degré élevé de conscience sémantique. Cette technique est basée sur la découverte de « chemins de programme », représentés par des formules mathématiques appelées `prédicats de chemin`. Conceptuellement, cette technique opère sur les prédicats de chemin en deux étapes :
 
 1. Ils sont construits en utilisant des contraintes sur les entrées du programme.
 2. Ils sont utilisés pour générer des entrées de programme qui entraîneront l'exécution des chemins associés.
 
-Cette approche ne produit aucun faux positif dans le sens où tous les états de programme identifiés peuvent être déclenchés lors de l'exécution concrète. Par exemple, si l'analyse trouve un dépassement d'entier, il est garanti reproductible.
+Cette approche ne produit aucun faux positif dans le sens où tous les états de programme identifiés peuvent être déclenchés lors de l'exécution concrète. Par exemple, si l'analyse trouve un dépassement d'entier, sa reproductibilité est garantie.
 
 ### Exemple de prédicat de chemin {#path-predicate-example}
 
-Pour avoir une idée du fonctionnement du DSE, prenez l'exemple suivant :
+Pour avoir un aperçu du fonctionnement du DSE, considérez l'exemple suivant :
 
 ```solidity
 function f(uint a){
@@ -83,17 +85,17 @@ Comme `f()` contient deux chemins, un DSE construira deux prédicats de chemin d
 - Chemin 1 : `a == 65`
 - Chemin 2 : `Not (a == 65)`
 
-Chaque prédicat de chemin est une formule mathématique qui peut être donnée à un solveur [SMT](https://wikipedia.org/wiki/Satisfiability_modulo_theories), qui tentera de résoudre l'équation. Pour le `chemin 1`, le solveur dira que le chemin peut être exploré avec `a = 65`. Pour le `Chemin 2`, le solveur peut attribuer à `a` toute valeur autre que 65, par exemple `a = 0`.
+Chaque prédicat de chemin est une formule mathématique qui peut être donnée à un [solveur SMT](https://wikipedia.org/wiki/Satisfiability_modulo_theories), qui tentera de résoudre l'équation. Pour le `Chemin 1`, le solveur dira que le chemin peut être exploré avec `a = 65`. Pour le `Chemin 2`, le solveur peut donner à `a` n'importe quelle valeur autre que 65, par exemple `a = 0`.
 
-### Vérification des propriétés {#verifying-properties}
+### Vérifier les propriétés {#verifying-properties}
 
-Manticore permet un contrôle total sur toutes les exécutions de chaque chemin. En conséquence, il vous permet d'ajouter des contraintes arbitraires à pratiquement n'importe quoi. Ce contrôle permet la création de propriétés sur le contrat.
+Manticore permet un contrôle total sur l'exécution de chaque chemin. En conséquence, il vous permet d'ajouter des contraintes arbitraires à pratiquement n'importe quoi. Ce contrôle permet la création de propriétés sur le contrat.
 
 Prenons l'exemple suivant :
 
 ```solidity
 function unsafe_add(uint a, uint b) returns(uint c){
-  c = a + b; // pas de protections d’overflow
+  c = a + b; // aucune protection contre le dépassement
   return c;
 }
 ```
@@ -102,13 +104,13 @@ Il n'y a ici qu'un seul chemin à explorer dans la fonction :
 
 - Chemin 1 : `c = a + b`
 
-En utilisant Manticore, vous pouvez vérifier le dépassement, et ajouter des contraintes au prédicat de chemin :
+En utilisant Manticore, vous pouvez vérifier le dépassement et ajouter des contraintes au prédicat de chemin :
 
 - `c = a + b AND (c < a OR c < b)`
 
-S'il est possible de trouver une valorisation de `a` et `b` pour laquelle le prédicat de chemin ci-dessus est réalisable, cela signifie que vous avez trouvé un dépassement. Par exemple, le solveur peut générer l'entrée `a = 10 , b = MAXUINT256`.
+S'il est possible de trouver des valeurs pour `a` et `b` pour lesquelles le prédicat de chemin ci-dessus est réalisable, cela signifie que vous avez trouvé un dépassement. Par exemple, le solveur peut générer l'entrée `a = 10, b = MAXUINT256`.
 
-Si vous envisagez une version fixe:
+Si vous considérez une version corrigée :
 
 ```solidity
 function safe_add(uint a, uint b) returns(uint c){
@@ -119,17 +121,17 @@ function safe_add(uint a, uint b) returns(uint c){
 }
 ```
 
-La formule associée au contrôle de l'overflow serait :
+La formule associée à la vérification de dépassement serait :
 
 - `c = a + b AND (c >= a) AND (c=>b) AND (c < a OR c < b)`
 
-Cette formule ne peut pas être résolue, autrement dit c’est la **preuve** que la valeur `safe_add`, `c` augmentera toujours.
+Cette formule ne peut pas être résolue ; en d'autres termes, c'est une **preuve** que dans `safe_add`, `c` augmentera toujours.
 
-DSE est un outil puissant qui peut vérifier des contraintes arbitraires sur votre code.
+DSE est donc un outil puissant, qui peut vérifier des contraintes arbitraires sur votre code.
 
-## Lancer dans Manticore {#running-under-manticore}
+## Exécution sous Manticore {#running-under-manticore}
 
-Nous allons voir comment explorer un contrat intelligent avec l'API Manticore. La cible est le contrat intelligent suivant [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
+Nous allons voir comment explorer un contrat intelligent avec l'API Manticore. La cible est le contrat intelligent suivant [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol) :
 
 ```solidity
 pragma solidity >=0.4.24 <0.6.0;
@@ -145,13 +147,13 @@ contract Simple {
 
 ### Lancer une exploration autonome {#run-a-standalone-exploration}
 
-Vous pouvez exécuter Manticore directement sur le contrat intelligent par la commande suivante (`project` peut être un fichier Solidity, ou un répertoire de projet) :
+Vous pouvez exécuter Manticore directement sur le contrat intelligent avec la commande suivante (`project` peut être un fichier Solidity, ou un répertoire de projet) :
 
 ```bash
 $ manticore project
 ```
 
-Vous obtiendrez une liste des cas de tests comme par exemple (l'ordre peut changer) :
+Vous obtiendrez en sortie des cas de test comme celui-ci (l'ordre peut changer) :
 
 ```
 ...
@@ -166,39 +168,40 @@ Vous obtiendrez une liste des cas de tests comme par exemple (l'ordre peut chang
 ...
 ```
 
-Sans informations supplémentaires, Manticore explorera le contrat avec de nouvelles transactions symboliques jusqu’à ce qu’il n’explore plus de nouveaux chemins dans le contrat. Manticore ne lance pas de nouvelle transactions après le premier echec (par exemple : après un revert).
+Sans informations supplémentaires, Manticore explorera le contrat avec de nouvelles transactions symboliques
+jusqu’à ce qu’il n’explore plus de nouveaux chemins dans le contrat. Manticore n'exécute pas de nouvelles transactions après un échec (p. ex., après une annulation).
 
-Le type de donnée que Manticore produira comme résultat sera de type dossier `mcore_*`. Parmi d’autres, vous trouverez dans le dossier :
+Manticore générera les informations dans un répertoire `mcore_*`. Vous trouverez notamment dans ce répertoire :
 
-- `global.summary` : avertissements de couverture de code et de compilateur
-- `test_XXXXX.summary`: couverture de code, dernière instruction, soldes du compte par cas de test
-- `test_XXXXX.tx`: liste détaillée des transactions par cas de test
+- `global.summary` : couverture et avertissements du compilateur
+- `test_XXXXX.summary` : couverture, dernière instruction, soldes des comptes par cas de test
+- `test_XXXXX.tx` : liste détaillée des transactions par cas de test
 
 Ici, Manticore a trouvé 7 cas de test, qui correspondent à (l'ordre des noms de fichier peut changer) :
 
-|                      |      Transaction 0       |    Transaction 1    | Transaction 2       | Résultat |
-| :------------------: | :----------------------: | :-----------------: | ------------------- | :------: |
-| **test_00000000.tx** | La création des contrats |       f(!=65)       | f(!=65)             |   STOP   |
-| **test_00000001.tx** |   Création du contrat    | fonction de secours |                     |  REVERT  |
-| **test_00000002.tx** |   Création du contrat    |                     |                     |  RETOUR  |
-| **test_00000003.tx** |   Création du contrat    |        f(65)        |                     |  REVERT  |
-| **test_00000004.tx** |   Création du contrat    |       f(!=65)       |                     |   STOP   |
-| **test_00000005.tx** |   Création du contrat    |       f(!=65)       | f(65)               |  REVERT  |
-| **test_00000006.tx** |   Création du contrat    |       f(!=65)       | fonction de secours |  REVERT  |
+|                                                           |    Transaction 0    |        Transaction 1       | Transaction 2              | Résultat |
+| :-------------------------------------------------------: | :-----------------: | :------------------------: | -------------------------- | :------: |
+| **test_00000000.tx** | Création du contrat | f(!=65) | f(!=65) |   STOP   |
+| **test_00000001.tx** | Création du contrat |     fonction de secours    |                            |  REVERT  |
+| **test_00000002.tx** | Création du contrat |                            |                            |  RETOUR  |
+| **test_00000003.tx** | Création du contrat |  f(65)  |                            |  REVERT  |
+| **test_00000004.tx** | Création du contrat | f(!=65) |                            |   STOP   |
+| **test_00000005.tx** | Création du contrat | f(!=65) | f(65)   |  REVERT  |
+| **test_00000006.tx** | Création du contrat | f(!=65) | fonction de secours        |  REVERT  |
 
-_Le résumé d'exploration f(!=65) indique f appelé avec une valeur différente de 65._
+_Le résumé d'exploration f(!=65) indique que f est appelée avec une valeur différente de 65._
 
-Comme vous pouvez le constater, Manticore génère un scénario de test unique pour chaque transaction réussie ou annulée.
+Comme vous pouvez le constater, Manticore génère un cas de test unique pour chaque transaction réussie ou annulée.
 
-Utilisez le flag `--quick-mode` si vous voulez une exploration rapide du code (il désactive les détecteurs de bugs, le calcul du gaz, ...)
+Utilisez l'option `--quick-mode` si vous voulez une exploration rapide du code (elle désactive les détecteurs de bugs, le calcul du gaz, etc.)
 
 ### Manipuler un contrat intelligent via l'API {#manipulate-a-smart-contract-through-the-api}
 
-Cette section décrit comment manipuler un contrat intelligent à travers l'API Python de Manticore. Vous pouvez créer un nouveau fichier avec l'extension python `*.py` et écrivez le code nécessaire en ajoutant les commandes API (dont les bases seront décrites ci-dessous) dans ce fichier, puis exécutez-le avec la commande `$ python3 *. py`. Vous pouvez également exécuter les commandes ci-dessous directement dans la console python, pour exécuter la console en utilisant la commande `$ python3`.
+Cette section décrit en détail comment manipuler un contrat intelligent via l'API Python de Manticore. Vous pouvez créer un nouveau fichier avec l'extension python `.py` et y écrire le code nécessaire en ajoutant les commandes de l'API (dont les bases sont décrites ci-dessous), puis l'exécuter avec la commande `$ python3 *.py`. Vous pouvez également exécuter les commandes ci-dessous directement dans la console Python ; pour lancer la console, utilisez la commande `$ python3`.
 
-### Création des comptes {#creating-accounts}
+### Créer des comptes {#creating-accounts}
 
-La première chose que vous devriez faire est d'initier une nouvelle blockchain avec les commandes suivantes :
+La première chose à faire est d'initialiser une nouvelle blockchain avec les commandes suivantes :
 
 ```python
 from manticore.ethereum import ManticoreEVM
@@ -206,13 +209,13 @@ from manticore.ethereum import ManticoreEVM
 m = ManticoreEVM()
 ```
 
-Une transaction brute est exécutée en utilisant [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account):
+Un compte externe (non-contrat) est créé à l'aide de [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account) :
 
 ```python
 user_account = m.create_account(balance=1000)
 ```
 
-Une transaction brute est exécutée en utilisant [m.solidity_create_contract](https://manticore.readthedocs.io/en/latest/evm.html?highlight=solidity_create#manticore.ethereum.ManticoreEVM.create_contract):
+Un contrat Solidity peut être déployé à l'aide de [m.solidity_create_contract](https://manticore.readthedocs.io/en/latest/evm.html?highlight=solidity_create#manticore.ethereum.ManticoreEVM.create_contract) :
 
 ```solidity
 source_code = '''
@@ -225,24 +228,24 @@ contract Simple {
     }
 }
 '''
-# Init le contrat
+# Initialiser le contrat
 contract_account = m.solidity_create_contract(source_code, owner=user_account)
 ```
 
 #### Résumé {#summary}
 
-- Vous pouvez créer des comptes utilisateur et de contrat avec [m.create_account](https://manticore.readthedocs.io/en/latest/api.html#manticore.ethereum.ManticoreEVM.create_account) et [m.solidity_create_contract](https://manticore.readthedocs.io/en/latest/evm.html?highlight=solidity_create#manticore.ethereum.ManticoreEVM.create_contract).
+- Vous pouvez créer des comptes d'utilisateur et des comptes de contrat avec [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account) et [m.solidity_create_contract](https://manticore.readthedocs.io/en/latest/evm.html?highlight=solidity_create#manticore.ethereum.ManticoreEVM.create_contract).
 
-### Exécution des transactions {#executing-transactions}
+### Exécuter des transactions {#executing-transactions}
 
-Manticore supporte deux types de transactions :
+Manticore prend en charge deux types de transactions :
 
 - Transaction brute : toutes les fonctions sont explorées
 - Transaction nommée : une seule fonction est explorée
 
 #### Transaction brute {#raw-transaction}
 
-Une transaction brute est exécutée en utilisant [m.transaction](https://manticore.readthedocs.io/en/latest/evm.html?highlight=transaction#manticore.ethereum.ManticoreEVM.transaction) :
+Une transaction brute est exécutée à l'aide de [m.transaction](https://manticore.readthedocs.io/en/latest/evm.html?highlight=transaction#manticore.ethereum.ManticoreEVM.transaction) :
 
 ```python
 m.transaction(caller=user_account,
@@ -251,10 +254,10 @@ m.transaction(caller=user_account,
               value=value)
 ```
 
-L'appelant, l'adresse, les données ou la valeur de la transaction peut être soit concrète ou symbolique :
+L'appelant, l'adresse, les données ou la valeur de la transaction peuvent être soit concrets, soit symboliques :
 
 - [m.make_symbolic_value](https://manticore.readthedocs.io/en/latest/evm.html?highlight=make_symbolic_value#manticore.ethereum.ManticoreEVM.make_symbolic_value) crée une valeur symbolique.
-- [m.make_symbolic_buffer(size)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=make_symbolic_buffer#manticore.ethereum.ManticoreEVM.make_symbolic_buffer) crée une valeur symbolique.
+- [m.make_symbolic_buffer(size)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=make_symbolic_buffer#manticore.ethereum.ManticoreEVM.make_symbolic_buffer) crée un tableau d'octets symbolique.
 
 Par exemple :
 
@@ -267,40 +270,41 @@ m.transaction(caller=user_account,
               value=symbolic_value)
 ```
 
-Si les données sont symboliques, Manticore explorera toutes les fonctions du contrat pendant l'exécution de la transaction. Il sera utile de voir l'explication de la fonction de repli dans l'article [Hands on the Ethernaut CTF](https://blog.trailofbits.com/2017/11/06/hands-on-the-ethernaut-ctf/) pour comprendre comment fonctionne la sélection de fonctions.
+Si les données sont symboliques, Manticore explorera toutes les fonctions du contrat pendant l'exécution de la transaction. Il sera utile de consulter l'explication de la fonction de secours dans l'article [Hands on the Ethernaut CTF](https://blog.trailofbits.com/2017/11/06/hands-on-the-ethernaut-ctf/) pour comprendre comment fonctionne la sélection de fonction.
 
 #### Transaction nommée {#named-transaction}
 
-Les fonctions peuvent être exécutées via leur nom. Pour exécuter `f(uint var)` avec une valeur symbolique, à partir de user_account et avec 0 ether, utilisez :
+Les fonctions peuvent être exécutées via leur nom.
+Pour exécuter `f(uint var)` avec une valeur symbolique, à partir de user_account et avec 0 ether, utilisez :
 
 ```python
 symbolic_var = m.make_symbolic_value()
 contract_account.f(symbolic_var, caller=user_account, value=0)
 ```
 
-Si la `value` de la transaction n'est pas spécifiée, elle est de 0 par défaut.
+Si la `valeur` de la transaction n'est pas spécifiée, elle est de 0 par défaut.
 
 #### Résumé {#summary-1}
 
 - Les arguments d'une transaction peuvent être concrets ou symboliques
 - Une transaction brute explorera toutes les fonctions
-- Les fonctions peuvent être exécutées via leurs noms
+- Les fonctions peuvent être appelées par leur nom
 
 ### Espace de travail {#workspace}
 
 `m.workspace` est le répertoire utilisé comme répertoire de sortie pour tous les fichiers générés :
 
 ```python
-print("Les resultats sont dans {}".format(m.workspace))
+print("Les résultats se trouvent dans {}".format(m.workspace))
 ```
 
 ### Terminer l'exploration {#terminate-the-exploration}
 
-Pour arrêter l'exploration utilisez [m.finalize()](https://manticore.readthedocs.io/en/latest/evm.html?highlight=finalize#manticore.ethereum.ManticoreEVM.finalize). Aucune autre transaction ne devrait être envoyée une fois que cette méthode est appelée et Manticore génère des scénarios de test pour chaque chemin exploré.
+Pour arrêter l'exploration, utilisez [m.finalize()](https://manticore.readthedocs.io/en/latest/evm.html?highlight=finalize#manticore.ethereum.ManticoreEVM.finalize). Aucune autre transaction ne devrait être envoyée une fois cette méthode appelée. Manticore génère alors des cas de test pour chaque chemin exploré.
 
-### Résumé: Exécution sous Manticore {#summary-running-under-manticore}
+### Résumé : Exécution sous Manticore {#summary-running-under-manticore}
 
-En réunissant toutes les étapes précédentes, nous obtenons:
+En réunissant toutes les étapes précédentes, nous obtenons :
 
 ```python
 from manticore.ethereum import ManticoreEVM
@@ -316,15 +320,15 @@ contract_account = m.solidity_create_contract(source_code, owner=user_account)
 symbolic_var = m.make_symbolic_value()
 contract_account.f(symbolic_var)
 
-print("Results are in {}".format(m.workspace))
-m.finalize() # stop the exploration
+print("Les résultats se trouvent dans {}".format(m.workspace))
+m.finalize() # arrête l'exploration
 ```
 
-Vous trouverez tout le code ci-dessus dans le fichier [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
+Vous pouvez retrouver tout le code ci-dessus dans [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
 
-## Obtenir des chemins de lancement {#getting-throwing-paths}
+## Obtenir les chemins qui lèvent une exception {#getting-throwing-paths}
 
-Nous allons maintenant générer des entrées spécifiques pour les chemins soulevant une exception dans `f()`. La cible est le contrat intelligent suivant [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
+Nous allons maintenant générer des entrées spécifiques pour les chemins levant une exception dans `f()`. La cible est toujours le contrat intelligent suivant [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol) :
 
 ```solidity
 pragma solidity >=0.4.24 <0.6.0;
@@ -337,17 +341,17 @@ contract Simple {
 }
 ```
 
-### Utiliser les informations sur l'état d'objet {#using-state-information}
+### Utiliser les informations d'état {#using-state-information}
 
-Chaque chemin exécuté a son état de la blockchain. Un état est soit prêt, soit il est tué, ce qui signifie qu'il atteint une instruction THROW ou REVERT :
+Chaque chemin exécuté a son propre état de la blockchain. Un état est soit prêt, soit il est tué, ce qui signifie qu'il atteint une instruction THROW ou REVERT :
 
-- [m.ready_states](https://manticore.readthedocs.io/en/latest/states.html#accessing) : la liste des états qui sont prêts (ils n'ont pas exécuté de REVERT/INVALID)
-- [m.killed_states](https://manticore.readthedocs.io/en/latest/states.html#accessings) : liste des états qui sont morts
+- [m.ready_states](https://manticore.readthedocs.io/en/latest/states.html#accessing) : la liste des états qui sont prêts (ils n'ont pas exécuté d'instruction REVERT/INVALID)
+- [m.killed_states](https://manticore.readthedocs.io/en/latest/states.html#accessings) : la liste des états qui sont tués
 - [m.all_states](https://manticore.readthedocs.io/en/latest/states.html#accessings) : tous les états
 
 ```python
 for state in m.all_states:
-    # do something with state
+    # faire quelque chose avec l'état
 ```
 
 Vous pouvez accéder aux informations d'état. Par exemple :
@@ -363,7 +367,7 @@ data = state.platform.transactions[0].return_data
 data = ABI.deserialize("uint", data)
 ```
 
-### Comment générer des cas de test {#how-to-generate-testcase}
+### Comment générer un cas de test {#how-to-generate-testcase}
 
 Utilisez [m.generate_testcase(state, name)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=generate_testcase#manticore.ethereum.ManticoreEVM.generate_testcase) pour générer un cas de test :
 
@@ -373,13 +377,13 @@ m.generate_testcase(state, 'BugFound')
 
 ### Résumé {#summary-2}
 
-- Vous pouvez itérer sur l'état avec m.all_states
+- Vous pouvez itérer sur l'état avec `m.all_states`
 - `state.platform.get_balance(account.address)` retourne le solde du compte
 - `state.platform.transactions` retourne la liste des transactions
-- `transaction.return_data` constitue les données retournées
+- `transaction.return_data` correspond aux données retournées
 - `m.generate_testcase(state, name)` génère des entrées pour l'état
 
-### Résumé : Obtenir un chemin de lancement {#summary-getting-throwing-path}
+### Résumé : Obtenir le chemin qui lève une exception {#summary-getting-throwing-path}
 
 ```python
 from manticore.ethereum import ManticoreEVM
@@ -395,21 +399,23 @@ contract_account = m.solidity_create_contract(source_code, owner=user_account)
 symbolic_var = m.make_symbolic_value()
 contract_account.f(symbolic_var)
 
-## Verifie si l’execution se termine avec REVERT ou INVALID
+## Vérifier si une exécution se termine par REVERT ou INVALID
+
 for state in m.terminated_states:
     last_tx = state.platform.transactions[-1]
     if last_tx.result in ['REVERT', 'INVALID']:
-        print('Throw found {}'.format(m.workspace))
+        print('Exception trouvée {}'.format(m.workspace))
         m.generate_testcase(state, 'ThrowFound')
 ```
 
-Vous trouverez tout le code ci-dessus dans le fichier [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
+Vous pouvez retrouver tout le code ci-dessus dans [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
 
-_Notez que nous aurions pu générer un script beaucoup plus simple, comme tous les états retournés par terminated_state ont REVERT ou INVALID dans leur résultat : cet exemple était uniquement destiné à montrer comment manipuler l'API._
+_Remarque : nous aurions pu générer un script beaucoup plus simple, car tous les états renvoyés par `terminated_state` ont REVERT ou INVALID dans leur résultat. Cet exemple visait uniquement à montrer comment manipuler l'API._
 
 ## Ajouter des contraintes {#adding-constraints}
 
-Nous verrons comment limiter l'exploration. Nous ferons l'hypothèse que la documentation de `f()` indique que la fonction n'est jamais appelée avec `a == 65`, donc tout bogue avec `a == 65` n'est pas un vrai bogue. La cible est le contrat intelligent suivant [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
+Nous allons voir comment contraindre l'exploration. Nous ferons l'hypothèse que la
+documentation de `f()` indique que la fonction n'est jamais appelée avec `a == 65`, donc tout bug avec `a == 65` n'est pas un vrai bug. La cible est toujours le contrat intelligent suivant [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol) :
 
 ```solidity
 pragma solidity >=0.4.24 <0.6.0;
@@ -424,14 +430,14 @@ contract Simple {
 
 ### Opérateurs {#operators}
 
-Le module [Opérateurs](https://github.com/trailofbits/manticore/blob/master/manticore/core/smtlib/operators.py) facilite la manipulation des contraintes, entre autres il fournit :
+Le module [Opérateurs](https://github.com/trailofbits/manticore/blob/master/manticore/core/smtlib/operators.py) facilite la manipulation des contraintes. Il fournit entre autres :
 
 - Operators.AND,
 - Operators.OR,
-- Operators.UGT (unsigned greater than),
-- Operators.UGE (unsigned greater than or equal to),
-- Operators.ULT (unsigned lower than),
-- Operators.ULE (unsigned lower than or equal to).
+- Operators.UGT (supérieur à, non signé),
+- Operators.UGE (supérieur ou égal à, non signé),
+- Operators.ULT (inférieur à, non signé),
+- Operators.ULE (inférieur ou égal à, non signé).
 
 Pour importer le module, utilisez ce qui suit :
 
@@ -439,7 +445,7 @@ Pour importer le module, utilisez ce qui suit :
 from manticore.core.smtlib import Operators
 ```
 
-`Operators.CONCAT` est utilisé pour concaténer une table à une valeur. Par exemple, la valeur return_data d'une transaction doit être remplacée par une valeur à vérifier avec une autre valeur :
+`Operators.CONCAT` est utilisé pour concaténer un tableau à une valeur. Par exemple, les `return_data` d'une transaction doivent être transformées en une valeur pour être comparées à une autre valeur :
 
 ```python
 last_return = Operators.CONCAT(256, *last_return)
@@ -447,11 +453,12 @@ last_return = Operators.CONCAT(256, *last_return)
 
 ### Contraintes {#state-constraint}
 
-Vous pouvez utiliser des contraintes globalement ou pour un état spécifique.
+Vous pouvez utiliser des contraintes de manière globale ou pour un état spécifique.
 
 #### Contrainte globale {#state-constraint}
 
-Utilisez `m.constrain(constraint)` pour ajouter une contrainte globale. Par exemple, vous pouvez appeler un contrat à partir d'une adresse symbolique, et restreindre cette adresse à des valeurs spécifiques:
+Utilisez `m.constrain(constraint)` pour ajouter une contrainte globale.
+Par exemple, vous pouvez appeler un contrat depuis une adresse symbolique et restreindre cette adresse à des valeurs spécifiques :
 
 ```python
 symbolic_address = m.make_symbolic_value()
@@ -464,21 +471,23 @@ m.transaction(caller=user_account,
 
 #### Contrainte d'état {#state-constraint}
 
-Utiliser l'état [state.constrain(contrainte)](https://manticore.readthedocs.io/en/latest/states.html?highlight=StateBase#manticore.core.state.StateBase.constrain) pour ajouter une contrainte à un état spécifique Il peut être utilisé pour contraindre l'état après son exploration pour vérifier une propriété dessus.
+Utilisez [state.constrain(constraint)](https://manticore.readthedocs.io/en/latest/states.html?highlight=StateBase#manticore.core.state.StateBase.constrain) pour ajouter une contrainte à un état spécifique.
+Cela peut être utilisé pour contraindre l'état après son exploration afin de vérifier une propriété sur celui-ci.
 
-### Vérifier les contraintes {#checking-constraint}
+### Vérification de contrainte {#checking-constraint}
 
-Utilisez `solver.check(state.contraints)` pour savoir si une contrainte est toujours faisable. Par exemple, ce qui suit contraindra symbolic_value à être différent de 65 et vérifiera si l'état est toujours réalisable :
+Utilisez `solver.check(state.constraints)` pour savoir si une contrainte est toujours réalisable.
+Par exemple, ce qui suit contraindra `symbolic_value` à être différent de 65 et vérifiera si l'état est toujours réalisable :
 
 ```python
 state.constrain(symbolic_var != 65)
 if solver.check(state.constraints):
-    # l’etat est possible
+    # l'état est réalisable
 ```
 
-### Résumé: Ajouter des contraintes {#summary-adding-constraints}
+### Résumé : Ajouter des contraintes {#summary-adding-constraints}
 
-En ajoutant des contraintes au code précédent, nous obtenons :
+En ajoutant une contrainte au code précédent, nous obtenons :
 
 ```python
 from manticore.ethereum import ManticoreEVM
@@ -499,18 +508,19 @@ contract_account.f(symbolic_var)
 
 no_bug_found = True
 
-## Verifie si l’execution se termine par REVERT ou INVALID
+## Vérifier si une exécution se termine par REVERT ou INVALID
+
 for state in m.terminated_states:
     last_tx = state.platform.transactions[-1]
     if last_tx.result in ['REVERT', 'INVALID']:
-        # on ne considere pas le chemin quand a==65
+        # nous ne considérons pas le chemin où a == 65
         condition = symbolic_var != 65
         if m.generate_testcase(state, name="BugFound", only_if=condition):
-            print(f'Bug trouve, les resultats sont dans {m.workspace}')
+            print(f'Bug trouvé, les résultats sont dans {m.workspace}')
             no_bug_found = False
 
 if no_bug_found:
-    print(f'Pas de bug trouve')
+    print(f'Aucun bug trouvé')
 ```
 
-Vous trouverez tout le code ci-dessus dans le fichier [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
+Vous pouvez retrouver tout le code ci-dessus dans [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
diff --git a/public/content/translations/fr/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md b/public/content/translations/fr/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
index 5c6198a7ca4..9cc8063d2f2 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
@@ -1,49 +1,50 @@
 ---
-title: Comment utiliser Slither pour trouver des bugs de contrat intelligent
-description: Comment utiliser Slither pour trouver automatiquement des bugs dans les contrats intelligents
+title: Comment utiliser Slither pour trouver des bogues dans les contrats intelligents
+description: Comment utiliser Slither pour trouver automatiquement des bogues dans les contrats intelligents
 author: Trailofbits
 lang: fr
 tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "sécurité"
-  - "test"
-  - "analyse statique"
+  [
+    "Solidity",
+    "contrats intelligents",
+    "sécurité",
+    "test"
+  ]
 skill: advanced
 published: 2020-06-09
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/slither
 ---
 
 ## Comment utiliser Slither {#how-to-use-slither}
 
-Le but de ce tutoriel est de démontrer comment utiliser Slither pour trouver automatiquement des bugs dans les contrats intelligents.
+Le but de ce tutoriel est de montrer comment utiliser Slither pour trouver automatiquement des bogues dans les contrats intelligents.
 
 - [Installation](#installation)
-- [Utilisation des lignes de commande](#command-line)
-- [Introduction à l'analyse statique](#static-analysis): Brève introduction à l'analyse statique
-- [API](#api-basics) : Description de l'API Python
+- [Utilisation de la ligne de commande](#command-line)
+- [Introduction à l'analyse statique](#static-analysis) : brève introduction à l'analyse statique
+- [API](#api-basics) : description de l'API Python
 
 ## Installation {#installation}
 
-Slither nécessite Python >= 3.6. Il peut être installé via pip ou avec docker.
+Slither requiert Python >= 3.6. Il peut être installé via pip ou en utilisant docker.
 
-Slither via pip :
+Slither via pip :
 
 ```bash
 pip3 install --user slither-analyzer
 ```
 
-Slither via docker :
+Slither via docker :
 
 ```bash
 docker pull trailofbits/eth-security-toolbox
 docker run -it -v "$PWD":/home/trufflecon trailofbits/eth-security-toolbox
 ```
 
-_La dernière commande exécute eth-security-toolbox dans un docker qui a accès à votre répertoire courant. Vous pouvez changer les fichiers depuis votre hôte et exécuter les outils sur les fichiers depuis le docker_
+_La dernière commande exécute eth-security-toolbox dans un docker qui a accès à votre répertoire actuel. Vous pouvez modifier les fichiers depuis votre hôte, et exécuter les outils sur les fichiers depuis le docker_
 
-Dans docker, lancez :
+À l'intérieur de docker, exécutez :
 
 ```bash
 solc-select 0.5.11
@@ -60,37 +61,37 @@ python3 script.py
 
 ### Ligne de commande {#command-line}
 
-**Ligne de commande contre scripts définis par l'utilisateur.** Slither est livré avec un ensemble de détecteurs prédéfinis qui trouvent beaucoup de bogues communs. Faire appel à Slither à partir de la ligne de commande exécutera tous les détecteurs, aucune connaissance détaillée de l'analyse statique requise :
+**Ligne de commande ou scripts définis par l'utilisateur.** Slither est livré avec un ensemble de détecteurs prédéfinis qui trouvent de nombreux bogues courants. Appeler Slither depuis la ligne de commande exécutera tous les détecteurs, aucune connaissance détaillée de l'analyse statique n'est requise :
 
 ```bash
 slither project_paths
 ```
 
-En plus des détecteurs, Slither dispose de capacités de révision de code grâce à ses [printers](https://github.com/crytic/slither#printers) et [outils](https://github.com/crytic/slither#tools).
+En plus des détecteurs, Slither dispose de fonctionnalités de révision de code via ses [printers](https://github.com/crytic/slither#printers) et ses [tools](https://github.com/crytic/slither#tools).
 
-Utilisez [crytic.io](https://github.com/crytic) pour avoir accès à des détecteurs privés et à l'intégration GitHub.
+Utilisez [crytic.io](https://github.com/crytic) pour accéder à des détecteurs privés et à l'intégration GitHub.
 
 ## Analyse statique {#static-analysis}
 
-Les capacités et la conception du cadre d'analyse statique Slither ont été décrites dans les articles de blog ([1](https://blog.trailofbits.com/2018/10/19/slither-a-solidity-static-analysis-framework/), [2](https://blog.trailofbits.com/2019/05/27/slither-the-leading-static-analyzer-for-smart-contracts/)) et un [document académique](https://github.com/trailofbits/publications/blob/master/papers/wetseb19.pdf).
+Les capacités et la conception du framework d'analyse statique Slither ont été décrites dans des articles de blog ([1](https://blog.trailofbits.com/2018/10/19/slither-a-solidity-static-analysis-framework/), [2](https://blog.trailofbits.com/2019/05/27/slither-the-leading-static-analyzer-for-smart-contracts/)) et un [article académique](https://github.com/trailofbits/publications/blob/master/papers/wetseb19.pdf).
 
-L'analyse statique existe dans différentes saveurs. Vous réalisez très probablement que les compilateurs comme [clang](https://clang-analyzer.llvm.org/) et [gcc](https://lwn.net/Articles/806099/) dépendent de ces techniques de recherche, mais il soutient aussi ([Infer](https://fbinfer.com/), [CodeClimate](https://codeclimate.com/), [FindBugs](http://findbugs.sourceforge.net/) et les outils basés sur des méthodes formelles telles que [Frama-C](https://frama-c.com/) et [Polyspace](https://www.mathworks.com/products/polyspace.html).
+L'analyse statique se présente sous différentes formes. Vous savez probablement que les compilateurs comme [clang](https://clang-analyzer.llvm.org/) et [gcc](https://lwn.net/Articles/806099/) s'appuient sur ces techniques de recherche, mais elles sous-tendent également ([Infer](https://fbinfer.com/), [CodeClimate](https://codeclimate.com/), [FindBugs](http://findbugs.sourceforge.net/) et des outils basés sur des méthodes formelles comme [Frama-C](https://frama-c.com/) et [Polyspace](https://www.mathworks.com/products/polyspace.html)).
 
-Nous ne passerons pas en revue de façon exhaustive les techniques d'analyse statique et le chercheur ici. Au lieu de cela, nous nous concentrerons sur ce qui est nécessaire pour comprendre le fonctionnement de Slither afin que vous puissiez l'utiliser plus efficacement pour trouver des bogues et comprendre du code.
+Nous n'allons pas passer en revue de manière exhaustive les techniques d'analyse statique et les chercheurs ici. Au lieu de cela, nous nous concentrerons sur ce qui est nécessaire pour comprendre le fonctionnement de Slither afin que vous puissiez l'utiliser plus efficacement pour trouver des bogues et comprendre le code.
 
 - [Représentation du code](#code-representation)
-- [Analyse de code](#analysis)
-- [Représentation Intermédiaire](#intermediate-representation)
+- [Analyse du code](#analysis)
+- [Représentation intermédiaire](#intermediate-representation)
 
 ### Représentation du code {#code-representation}
 
-Contrairement à une analyse dynamique, qui explique les raisons d'un seul chemin d'exécution, l'analyse statique explique tous les chemins en même temps. Pour ce faire, il repose sur une représentation du code différente. Les deux plus courants sont l'arborescence de syntaxe abstraite (AST) et le graphique de flux de contrôle (CFG).
+Contrairement à une analyse dynamique, qui raisonne sur un seul chemin d'exécution, l'analyse statique raisonne sur tous les chemins à la fois. Pour ce faire, elle s'appuie sur une représentation différente du code. Les deux plus courantes sont l'arbre de syntaxe abstraite (AST) et le graphe de flot de contrôle (CFG).
 
-### Arbres syntaxiques abstraits (AST) {#abstract-syntax-trees-ast}
+### Arbres de syntaxe abstraits (AST) {#abstract-syntax-trees-ast}
 
-AST est utilisé chaque fois que le compilateur analyse le code. C'est probablement la structure la plus basique sur laquelle une analyse statique peut être effectuée.
+Les AST sont utilisés chaque fois que le compilateur analyse le code. C'est probablement la structure la plus élémentaire sur laquelle une analyse statique peut être effectuée.
 
-En un mot, un AST est un arbre structuré où, habituellement, chaque feuille contient une variable ou une constante, et les nœuds internes sont des opérandes ou des opérations de contrôle de flux. Considérez les codes suivants :
+En bref, un AST est un arbre structuré où, généralement, chaque feuille contient une variable ou une constante et les nœuds internes sont des opérandes ou des opérations de flux de contrôle. Considérons le code suivant :
 
 ```solidity
 function safeAdd(uint a, uint b) pure internal returns(uint){
@@ -101,15 +102,15 @@ function safeAdd(uint a, uint b) pure internal returns(uint){
 }
 ```
 
-L'AST correspondant est affiché dans :
+L'AST correspondant est présenté ci-dessous :
 
 ![AST](./ast.png)
 
 Slither utilise l'AST exporté par solc.
 
-Bien que simple à construire, l'AST est une structure imbriquée. Parfois, ce n'est pas le plus simple à analyser. Par exemple, pour identifier les opérations utilisées par l'expression `a + b <= a`, vous devez d'abord analyser `<=` puis `+`. Une approche commune est d'utiliser le design pattern « visiteur » pour naviguer dans l'arbre récursivement. Slither contient un visiteur générique dans [`ExpressionVisitor`](https://github.com/crytic/slither/blob/master/slither/visitors/expression/expression.py).
+Bien que simple à construire, l'AST est une structure imbriquée. Parfois, ce n'est pas la plus simple à analyser. Par exemple, pour identifier les opérations utilisées par l'expression `a + b <= a`, vous devez d'abord analyser `<=` puis `+`. Une approche courante consiste à utiliser le patron de conception visiteur, qui parcourt l'arbre de manière récursive. Slither contient un visiteur générique dans [`ExpressionVisitor`](https://github.com/crytic/slither/blob/master/slither/visitors/expression/expression.py).
 
-Le code suivant utilise `ExpressionVisitor` pour détecter si l'expression contient un ajout :
+Le code suivant utilise `ExpressionVisitor` pour détecter si l'expression contient une addition :
 
 ```python
 from slither.visitors.expression.expression import ExpressionVisitor
@@ -124,58 +125,58 @@ class HasAddition(ExpressionVisitor):
         if expression.type == BinaryOperationType.ADDITION:
             self._result = True
 
-visitor = HasAddition(expression) # expression correspond a l'expression qui sera testé
-print(f'L’expression {expression} contient une addition: {visitor.result()}')
+visitor = HasAddition(expression) # expression est l'expression à tester
+print(f'L\'expression {expression} contient une addition : {visitor.result()}')
 ```
 
-### Graphe de contrôle du flux (CFG) {#control-flow-graph-cfg}
+### Graphe de flot de contrôle (CFG) {#control-flow-graph-cfg}
 
-La deuxième représentation de code la plus courante est le graphique de flux de contrôle (CFG). Comme son nom l'indique, il s'agit d'une représentation graphique qui expose tous les chemins d'exécution. Chaque nœud contient une ou plusieurs instructions. Les bords dans le graphique représentent les opérations de contrôle du flux (if/then/else, loop, etc.). Le CFG de notre exemple précédent est :
+La deuxième représentation de code la plus courante est le graphe de flot de contrôle (CFG). Comme son nom l'indique, il s'agit d'une représentation basée sur un graphe qui expose tous les chemins d'exécution. Chaque nœud contient une ou plusieurs instructions. Les arêtes du graphe représentent les opérations de flux de contrôle (if/then/else, boucle, etc.). Le CFG de notre exemple précédent est :
 
 ![CFG](./cfg.png)
 
 Le CFG est la représentation sur laquelle la plupart des analyses sont construites.
 
-De nombreuses autres représentations de code existent. Chaque représentation a des avantages et des inconvénients en fonction de l'analyse que vous voulez effectuer.
+Il existe de nombreuses autres représentations du code. Chaque représentation a ses avantages et ses inconvénients en fonction de l'analyse que vous souhaitez effectuer.
 
 ### Analyse {#analysis}
 
-Les analyses les plus simples que vous pouvez effectuer avec Slither sont des analyses syntaxiques.
+Les types d'analyses les plus simples que vous pouvez effectuer avec Slither sont les analyses syntaxiques.
 
 ### Analyse syntaxique {#syntax-analysis}
 
-Slither peut naviguer à travers les différents composants du code et de leur représentation pour trouver des incohérences et des défauts en utilisant une approche similaire à la recherche de modèles.
+Slither peut naviguer à travers les différents composants du code et leur représentation pour trouver des incohérences et des défauts en utilisant une approche de type reconnaissance de formes.
 
-Par exemple, les détecteurs suivants recherchent les problèmes liés à la syntaxe :
+Par exemple, les détecteurs suivants recherchent des problèmes liés à la syntaxe :
 
-- [State variavle shadowing>](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variable-shadowing) : itère sur toutes les variables d'état et vérifie si une variable est masquée à partir d'un contrat hérité ([état. y#L51-L62](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/shadowing/state.py#L51-L62))
+- [Masquage de variable d'état](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variable-shadowing) : itère sur toutes les variables d'état et vérifie si l'une d'entre elles masque une variable d'un contrat hérité ([state.py#L51-L62](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/shadowing/state.py#L51-L62))
 
-- [Interface ERC20 incorrecte](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-erc20-interface) : recherche des signatures de fonction ERC20 incorrectes ([incorrect_erc20_interface.py#L34-L55](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/erc/incorrect_erc20_interface.py#L34-L55))
+- [Interface ERC20 incorrecte](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-erc20-interface) : recherche les signatures de fonction ERC20 incorrectes ([incorrect_erc20_interface.py#L34-L55](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/erc/incorrect_erc20_interface.py#L34-L55))
 
 ### Analyse sémantique {#semantic-analysis}
 
-Contrairement à l'analyse syntaxique, une analyse sémantique ira plus loin et analysera le « sens » du code. Cette famille comprend quelques grands types d'analyse. Ils conduisent à des résultats plus puissants et utiles, mais sont également plus complexes à rédiger.
+Contrairement à l'analyse syntaxique, une analyse sémantique va plus loin et analyse la « signification » du code. Cette famille comprend quelques grands types d'analyses. Elles mènent à des résultats plus puissants et utiles, mais sont aussi plus complexes à écrire.
 
-Les analyses sémantiques sont utilisées pour les détections de vulnérabilité les plus avancées.
+Les analyses sémantiques sont utilisées pour les détections de vulnérabilités les plus avancées.
 
-#### Analyse des dépendances des données {#fixed-point-computation}
+#### Analyse de dépendance des données {#fixed-point-computation}
 
-Une variable `variable_a` est dite dépendante des données de `variable_b` s'il y a un chemin pour lequel la valeur de `variable_a` est influencée par `variable_b`.
+Une variable `variable_a` est dite dépendante des données de `variable_b` s'il existe un chemin pour lequel la valeur de `variable_a` est influencée par `variable_b`.
 
-Dans le code suivant, `variable_a` est dépendant de `variable_b`:
+Dans le code suivant, `variable_a` dépend de `variable_b` :
 
 ```solidity
 // ...
 variable_a = variable_b + 1;
 ```
 
-Slither est livré avec des capacités intégrées grâce à sa représentation intermédiaire (discutée dans une section ultérieure).
+Slither dispose de fonctionnalités intégrées de [dépendance des données](https://github.com/crytic/slither/wiki/data-dependency), grâce à sa représentation intermédiaire (abordée dans une section ultérieure).
 
-Un exemple d'utilisation de la dépendance des données peut être trouvé dans le [dangereux détecteur strict d'égalité](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-strict-equalities). Ici, Slither recherchera une comparaison stricte de l'égalité avec une valeur dangereuse ([incorrect_strict_equality. y#L86-L87](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L86-L87)), et informera l'utilisateur qu'il doit utiliser `>=` ou `<=` au lieu de `==`, pour empêcher un attaquant de piéger le contrat. Entre autres, le détecteur considérera comme dangereux la valeur de retour d'un appel à `balanceOf(address)` ([incorrect_strict_equality. y#L63-L64](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L63-L64)), et utilisera le moteur de dépendance de données pour suivre son utilisation.
+Un exemple d'utilisation de la dépendance des données se trouve dans le [détecteur d'égalité stricte dangereuse](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-strict-equalities). Ici, Slither recherchera une comparaison d'égalité stricte à une valeur dangereuse ([incorrect_strict_equality.py#L86-L87](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L86-L87)), et informera l'utilisateur qu'il doit utiliser `>=` ou `<=` plutôt que `==`, pour empêcher un attaquant de piéger le contrat. Entre autres, le détecteur considérera comme dangereuse la valeur de retour d'un appel à `balanceOf(address)` ([incorrect_strict_equality.py#L63-L64](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L63-L64)), et utilisera le moteur de dépendance des données pour suivre son utilisation.
 
-#### Calcul à decimales fixes {#fixed-point-computation}
+#### Calcul de point fixe {#fixed-point-computation}
 
-Si votre analyse navigue à travers le CFG et suit les bords, vous êtes susceptible de voir des nœuds déjà visités. Par exemple, si une boucle est présentée tel qu'illustré ci-dessous :
+Si votre analyse parcourt le CFG et suit les arêtes, vous êtes susceptible de voir des nœuds déjà visités. Par exemple, si une boucle est présentée comme ci-dessous :
 
 ```solidity
 for(uint i; i < range; ++){
@@ -183,56 +184,56 @@ for(uint i; i < range; ++){
 }
 ```
 
-Votre analyse devra savoir quand s'arrêter. Il y a deux stratégies principales ici : (1) itérer sur chaque noeud un nombre limité de fois, (2) calculer un _fixpoint_. Un point fixe signifie que l'analyse de ce noeud ne fournit aucune information significative.
+Votre analyse devra savoir quand s'arrêter. Il y a deux stratégies principales ici : (1) itérer sur chaque nœud un nombre fini de fois, (2) calculer un soi-disant _point fixe_. Un point fixe signifie essentiellement que l'analyse de ce nœud ne fournit plus aucune information significative.
 
-Un exemple de point fixe utilisé peut être trouvé dans les détecteurs de rétractation : Slither explore les nœuds et il est possible de chercher des appels externes, écrire et lire sur le stockage. Une fois qu'il a atteint un point fixe ([réentrance. y#L125-L131](https://github.com/crytic/slither/blob/master/slither/detectors/reentrancy/reentrancy.py#L125-L131)), il arrête l'exploration, et analyse les résultats pour voir si une réentrance est présente, à travers différents modèles de réentrance ([reentrancy_benign. y](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_benign.py), [reentrancy_read_before_write.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_read_before_write.py), [reentrancy_eth.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_eth.py)).
+Un exemple d'utilisation de point fixe se trouve dans les détecteurs de réentrance : Slither explore les nœuds et recherche les appels externes, l'écriture et la lecture dans le stockage. Une fois qu'il a atteint un point fixe ([reentrancy.py#L125-L131](https://github.com/crytic/slither/blob/master/slither/detectors/reentrancy/reentrancy.py#L125-L131)), il arrête l'exploration et analyse les résultats pour voir si une réentrance est présente, à travers différents modèles de réentrance ([reentrancy_benign.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_benign.py), [reentrancy_read_before_write.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_read_before_write.py), [reentrancy_eth.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_eth.py)).
 
-Écrire des analyses à l'aide de calculs fixes efficaces nécessite une bonne compréhension de la manière dont l'analyse propage ses informations.
+L'écriture d'analyses utilisant un calcul de point fixe efficace requiert une bonne compréhension de la manière dont l'analyse propage ses informations.
 
-### Représentation Intermédiaire {#intermediate-representation}
+### Représentation intermédiaire {#intermediate-representation}
 
-Une représentation intermédiaire (IR) est un langage destiné à être plus apte à une analyse statique que le langage original. Slither traduit Solidity à son propre IR : [SlithIR](https://github.com/crytic/slither/wiki/SlithIR).
+Une représentation intermédiaire (RI) est un langage destiné à être plus adapté à l'analyse statique que le langage original. Slither traduit Solidity dans sa propre RI : [SlithIR](https://github.com/crytic/slither/wiki/SlithIR).
 
-Comprendre SlithIR n'est pas nécessaire si vous voulez seulement écrire des vérifications de base. Cependant, il sera pratique si vous prévoyez d'écrire des analyses sémantiques avancées. Les imprimantes [SlithIR](https://github.com/crytic/slither/wiki/Printer-documentation#slithir) et [SSA](https://github.com/crytic/slither/wiki/Printer-documentation#slithir-ssa) vous aideront à comprendre comment le code est traduit.
+Comprendre SlithIR n'est pas nécessaire si vous voulez seulement écrire des vérifications de base. Cependant, ce sera utile si vous prévoyez d'écrire des analyses sémantiques avancées. Les printers [SlithIR](https://github.com/crytic/slither/wiki/Printer-documentation#slithir) et [SSA](https://github.com/crytic/slither/wiki/Printer-documentation#slithir-ssa) vous aideront à comprendre comment le code est traduit.
 
-## Les bases de l’API {#api-basics}
+## Principes de base de l'API {#api-basics}
 
-Slither a une API qui vous permet d'explorer les attributs de base du contrat et de ses fonctions.
+Slither dispose d'une API qui vous permet d'explorer les attributs de base du contrat et de ses fonctions.
 
-Pour charger le code base :
+Pour charger une base de code :
 
 ```python
 from slither import Slither
-slither = Slither('/chemin/vers/projet')
+slither = Slither('/chemin/vers/le/projet')
 
 ```
 
-### Exploration des contrats et fonctions {#exploring-contracts-and-functions}
+### Explorer les contrats et les fonctions {#exploring-contracts-and-functions}
 
-Un objet `Slither` a :
+Un objet `Slither` possède :
 
-- `contrats (list(Contrat)` : liste des contrats
-- `contracts_derived (list(Contrat)` : liste des contrats qui ne sont pas hérités par un autre contrat (sous-ensemble de contrats)
-- `get_contract_from_name (str)` : Renvoie un contrat à partir de son nom
+- `contracts (list(Contract)` : liste de contrats
+- `contracts_derived (list(Contract)` : liste de contrats qui ne sont pas hérités par un autre contrat (sous-ensemble de contrats)
+- `get_contract_from_name (str)` : renvoie un contrat à partir de son nom
 
-Un objet `Contract` a :
+Un objet `Contract` possède :
 
-- `name(str)` : Nom du contrat
-- `fonctions(list(fonction))` : Liste des fonctions
-- `modifiers(list(Modifier))` : Liste des fonctions
-- `all_functions_called(list(Function/Modifier))` : Liste de toutes les fonctions internes accessibles par le contrat
-- `inheritance(list(Contract))` : Liste des contrats hérités
-- `get_function_from_signature(str)` : Renvoie une fonction à partir de sa signature
-- `get_modifier_from_signature(str)` : Renvoie un Modifier à partir de sa signature
-- `get_state_variable_from_name(str)` : Renvoie une StateVariable à partir de son nom
+- `name (str)` : nom du contrat
+- `functions (list(Function))` : liste des fonctions
+- `modifiers (list(Modifier))` : liste de modificateurs
+- `all_functions_called (list(Function/Modifier))` : liste de toutes les fonctions internes accessibles par le contrat
+- `inheritance (list(Contract))` : liste des contrats hérités
+- `get_function_from_signature (str)` : renvoie une fonction à partir de sa signature
+- `get_modifier_from_signature (str)` : renvoie un modificateur à partir de sa signature
+- `get_state_variable_from_name (str)` : renvoie une StateVariable à partir de son nom
 
-Un objet `Function` ou un `Modifier` a :
+Un objet `Function` ou `Modifier` possède :
 
-- `name(str)` : Nom de la fonction
-- `contract (contract)` : le contrat où la fonction est déclarée
-- `nodes(list(Node))` : Liste des noeuds composant la fonction/modifier de CFG
-- `entry_point(Node)` : Point d’entrée du CFG
-- `variables_read(list(Variable))` : Liste des variables de lecture
-- `variables_written(list(Variable))` : Liste des variable d’écritures
-- `state_variables_read(list(StateVariable))` : Liste des variables d’états de lectures (sous-ensemble de lecture des variables)
-- `state_variables_read(list(StateVariable))` : Liste des variables d’états de lectures (sous-ensemble de lecture des variables)
+- `name (str)` : nom de la fonction
+- `contract (contract)` : le contrat où la fonction est déclarée
+- `nodes (list(Node))` : liste des nœuds composant le CFG de la fonction/du modificateur
+- `entry_point (Node)` : point d'entrée du CFG
+- `variables_read (list(Variable))` : liste des variables lues
+- `variables_written (list(Variable))` : liste des variables écrites
+- `state_variables_read (list(StateVariable))` : liste des variables d'état lues (sous-ensemble de `variables_read`)
+- `state_variables_written (list(StateVariable))` : liste des variables d'état écrites (sous-ensemble de `variables_written`)
diff --git a/public/content/translations/fr/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md b/public/content/translations/fr/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
index 95aa75cad9a..ca7a9cfd3ee 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
@@ -1,55 +1,52 @@
 ---
-title: Comment configurer Tellor comme Oracle
-description: Un guide pour débuter l'intégration de l'oracle Tellor dans votre protocole
+title: Comment configurer Tellor comme oracle
+description: "Un guide pour débuter l'intégration de l'oracle Tellor dans votre protocole"
 author: "Tellor"
 lang: fr
-tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "oracles"
+tags: [ "Solidity", "contrats intelligents", "oracles" ]
 skill: beginner
 published: 2021-06-29
 source: Tellor Docs
 sourceUrl: https://docs.tellor.io/tellor/
 ---
 
-Quiz Pop : Votre protocole est à peine terminé, mais il a besoin d'un oracle pour avoir accès aux données hors chaîne... Que faites-vous ?
+Question surprise : votre protocole est presque terminé, mais il a besoin d'un oracle pour accéder aux données hors chaîne... Que faites-vous ?
 
-## Prérequis (simple) {#soft-prerequisites}
+## (Prérequis recommandés) {#soft-prerequisites}
 
-Cet article a pour objectif de permettre l'accès à un flux oracle aussi simplement et efficacement que possible. Cela étant dit, nous supposons que votre niveau de compétence en codage est le suivant pour nous concentrer sur l'aspect oracle.
+Cet article vise à rendre l'accès à un flux d'oracle aussi simple et direct que possible. Cela dit, nous partons du principe que vous avez les compétences de codage suivantes afin de nous concentrer sur l'aspect oracle.
 
 Hypothèses :
 
 - vous pouvez naviguer dans un terminal
-- vous avez un npm installé
-- vous savez comment utiliser le npm pour gérer les dépendances
+- vous avez installé npm
+- vous savez utiliser npm pour gérer les dépendances
 
-Tellor est un oracle direct et open source prêt à l'emploi. Ce guide pour débutants a pour objectif de montrer la facilité d'utilisation de Tellor, et de doter votre projet d'un oracle entièrement décentralisé et résistant à la censure.
+Tellor est un oracle actif et open source, prêt à être implémenté. Ce guide du débutant est là pour montrer la facilité avec laquelle on peut se lancer avec Tellor, fournissant à votre projet un oracle entièrement décentralisé et résistant à la censure.
 
-## Aperçu {#overview}
+## Vue d'ensemble {#overview}
 
-Tellor est un système Oracle où les parties peuvent demander la valeur d'un point de données hors chaîne (par ex. BTC/USD). Les rapporteurs sont en concurrence pour ajouter cette valeur à une banque de données en chaîne accessible par tous les contrats intelligents Ethereum. Les entrées de cette banque de données sont sécurisées par un réseau de mises en jeu par des rapporteurs. Tellor utilise des mécanismes d'incitation crypto-économique, récompensant les déclarations honnêtes de données effectuées par des rapporteurs et punissant les mauvais acteurs grâce à la délivrance d'un jeton Tellor (les Tributes, ou TRB), et d'un mécanisme de conflit.
+Tellor est un système d'oracle où les parties peuvent demander la valeur d'un point de données hors chaîne (p. ex., BTC/USD) et où des rapporteurs s'affrontent pour ajouter cette valeur à une banque de données en chaîne, accessible par tous les contrats intelligents Ethereum. Les entrées de cette banque de données sont sécurisées par un réseau de rapporteurs ayant mis des actifs en jeu. Tellor utilise des mécanismes d'incitation crypto-économiques, récompensant les soumissions de données honnêtes des rapporteurs et punissant les mauvais acteurs par l'émission du jeton de Tellor, Tributes (TRB), et un mécanisme de litige.
 
-Dans ce tutoriel, nous allons passer en revue :
+Dans ce tutoriel, nous aborderons :
 
-- La mise en place de la boite à outils initiale dont vous aurez besoin pour démarrer.
-- Un exemple simple.
-- La liste des adresses testnet des réseaux sur lesquels vous pourrez tester Tellor.
+- La configuration de la boîte à outils initiale dont vous aurez besoin pour être opérationnel.
+- La présentation d'un exemple simple.
+- La liste des adresses de réseaux de test sur lesquels vous pouvez actuellement tester Tellor.
 
-## Utiliser Tellor {#usingtellor}
+## UsingTellor {#usingtellor}
 
-La première chose à faire est d'installer les outils de base nécessaires pour utiliser Tellor comme oracle. Utilisez [ce paquet](https://github.com/tellor-io/usingtellor) pour installer les contrats utilisateur de Tellor :
+La première chose à faire est d'installer les outils de base nécessaires pour utiliser Tellor comme votre oracle. Utilisez [ce paquet](https://github.com/tellor-io/usingtellor) pour installer les contrats utilisateur de Tellor :
 
 `npm install usingtellor`
 
-Une fois ces derniers installés, cela permettra à vos contrats d'hériter des fonctions du contrat 'UsingTellor'.
+Une fois installé, cela permettra à vos contrats d'hériter des fonctions du contrat « UsingTellor ».
 
-Génial ! Maintenant que vos outils sont prêts, intéressons-nous à un exercice simple où nous récupérons le prix de bitcoin :
+Super ! Maintenant que vous avez préparé les outils, passons à un exercice simple où nous récupérons le prix du bitcoin :
 
 ### Exemple BTC/USD {#btcusd-example}
 
-Hériter du contrat UsingTellor, en transmettant l'adresse Tellor en tant qu'argument de constructeur :
+Héritez du contrat UsingTellor, en passant l'adresse Tellor comme argument du constructeur :
 
 Voici un exemple :
 
@@ -59,13 +56,13 @@ import "usingtellor/contracts/UsingTellor.sol";
 contract PriceContract is UsingTellor {
   uint256 public btcPrice;
 
- //This Contract now has access to all functions in UsingTellor
+ //Ce contrat a maintenant accès à toutes les fonctions dans UsingTellor
 
 constructor(address payable _tellorAddress) UsingTellor(_tellorAddress) public {}
 
 function setBtcPrice() public {
     bytes memory _b = abi.encode("SpotPrice",abi.encode("btc","usd"));
-    bytes32 _queryID = keccak256(_b);
+    bytes32 _queryId = keccak256(_b);
 
     uint256 _timestamp;
     bytes _value;
@@ -77,8 +74,8 @@ function setBtcPrice() public {
 }
 ```
 
-Pour une liste complète des adresses de contrat, veuillez cliquer [ici](https://docs.tellor.io/tellor/the-basics/contracts-reference).
+Pour obtenir la liste complète des adresses de contrat, référez-vous à [ce document](https://docs.tellor.io/tellor/the-basics/contracts-reference).
 
-Pour en faciliter l’utilisation, le dépôt de UsingTellor est livré avec une version du contrat [Tellor Playground](https://github.com/tellor-io/TellorPlayground) pour une intégration plus facile. Cliquez [ici](https://github.com/tellor-io/sampleUsingTellor#tellor-playground) pour une liste des fonctions utiles.
+Pour en faciliter l'utilisation, le dépôt UsingTellor est fourni avec une version du contrat [Tellor Playground](https://github.com/tellor-io/TellorPlayground) pour une intégration plus facile. Consultez [cette page](https://github.com/tellor-io/sampleUsingTellor#tellor-playground) pour une liste des fonctions utiles.
 
-Pour une implémentation plus robuste de l'oracle Tellor, consultez la liste complète des fonctions disponibles [ici.](https://github.com/tellor-io/usingtellor/blob/master/README.md)
+Pour une implémentation plus robuste de l'oracle Tellor, consultez la liste complète des fonctions disponibles [ici](https://github.com/tellor-io/usingtellor/blob/master/README.md).
diff --git a/public/content/translations/fr/developers/tutorials/how-to-view-nft-in-metamask/index.md b/public/content/translations/fr/developers/tutorials/how-to-view-nft-in-metamask/index.md
index 3bd9e95879b..07b125a4710 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-view-nft-in-metamask/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-view-nft-in-metamask/index.md
@@ -1,35 +1,32 @@
 ---
-title: Comment voir votre NFT dans votre portefeuille (Partie 3/3 de la série des tutoriels NFT)
-description: Ce tutoriel décrit comment visualiser un NFT existant sur MetaMask !
+title: "Comment voir votre NFT dans votre portefeuille (Partie 3/3 de la série de tutoriels NFT)"
+description: "Ce tutoriel décrit comment visualiser un NFT existant sur MetaMask !"
 author: "Sumi Mudgil"
-tags:
-  - "ERC-721"
-  - "Alchemy"
-  - "Solidity"
+tags: [ "ERC-721", "Alchemy", "Solidity" ]
 skill: beginner
 lang: fr
 published: 2021-04-22
 ---
 
-Ce tutoriel est la Partie 3/3 de la série de tutoriels NFT où l'on visualise nos NFT fraîchement créés. Vous pouvez toutefois utiliser le tutoriel général pour n'importe quel jeton ERC-721 en utilisant MetaMask, y compris sur le réseau principal ou un testnet. Si vous souhaitez apprendre à créer votre propre NFT sur Ethereum, veuillez consulter [la Partie 1 relative à la façon d'Écrire & Déployer un contrat intelligent NFT](/developers/tutorials/how-to-write-and-deploy-an-nft) !
+Ce tutoriel est la partie 3/3 de la série de tutoriels sur les NFT, où nous visualisons nos NFT fraîchement frappés. Vous pouvez toutefois utiliser le tutoriel général pour n'importe quel jeton ERC-721 en utilisant MetaMask, y compris sur le réseau principal ou n'importe quel réseau de test. Si vous souhaitez apprendre à frapper votre propre NFT sur Ethereum, consultez la [Partie 1 sur Comment écrire et déployer un contrat intelligent NFT](/developers/tutorials/how-to-write-and-deploy-an-nft) !
 
-Félicitations ! Vous avez réussi la partie la plus courte et la plus simple de notre série de tutoriels NFT — comment voir votre NFT fraîchement créé sur un portefeuille virtuel. Nous utiliserons MetaMask pour cet exemple, car nous l'avons utilisé dans les deux parties précédentes.
+Félicitations ! Vous êtes arrivé à la partie la plus courte et la plus simple de notre série de tutoriels NFT — comment voir votre NFT fraîchement frappé sur un portefeuille virtuel. Nous utiliserons MetaMask pour cet exemple, car nous l'avons utilisé dans les deux parties précédentes.
 
-En prérequis, vous devriez déjà avoir MetaMask installé sur votre mobile, et ce dernier devrait inclure le compte sur lequel vous avez miné votre NFT — vous pouvez télécharger l'application gratuitement sur [iOS](https://apps.apple.com/us/app/metamask-blockchain-wallet/id1438144202) ou [Android](https://play.google.com/store/apps/details?id=io.metamask&hl=en_US&gl=US).
+Comme prérequis, vous devez déjà avoir installé MetaMask sur votre mobile, et il doit inclure le compte sur lequel vous avez frappé votre NFT — vous pouvez obtenir l'application gratuitement sur [iOS](https://apps.apple.com/us/app/metamask-blockchain-wallet/id1438144202) ou [Android](https://play.google.com/store/apps/details?id=io.metamask&hl=en_US&gl=US).
 
 ## Étape 1 : Configurez votre réseau sur Sepolia {#set-network-to-sepolia}
 
-En haut de l'application, appuyez sur le bouton « Portefeuille », après quoi vous serez invité à sélectionner un réseau. Comme notre NFT a été miné sur le réseau Sepolia, vous devez sélectionner Sepolia comme votre réseau.
+En haut de l'application, appuyez sur le bouton « Portefeuille », après quoi vous serez invité à sélectionner un réseau. Comme notre NFT a été frappé sur le réseau Sepolia, vous devrez sélectionner Sepolia comme votre réseau.
 
-![Comment définir Sepolia comme votre réseau sur MetaMask Mobile](./goerliMetamask.gif)
+![Comment configurer Sepolia comme votre réseau sur MetaMask Mobile](./goerliMetamask.gif)
 
 ## Étape 2 : Ajoutez votre article de collection à MetaMask {#add-nft-to-metamask}
 
-Une fois que vous êtes sur le réseau Sepolia, sélectionner l'onglet « Articles de collection » sur la droite et ajoutez l'adresse du contrat intelligent NFT et l'identifiant du jeton ERC-721 de votre NFT — que vous devriez pouvoir trouver sur Etherscan en fonction du hachage de la transaction de votre NFT déployé dans la Partie II de notre tutoriel.
+Une fois que vous êtes sur le réseau Sepolia, sélectionnez l'onglet « Articles de collection » sur la droite et ajoutez l'adresse du contrat intelligent NFT et l'ID du jeton ERC-721 de votre NFT — que vous devriez pouvoir trouver sur Etherscan en vous basant sur le hachage de la transaction de votre NFT déployé dans la Partie II de notre tutoriel.
 
-![Comment trouver votre hachage de transaction et votre identifiant de jeton ERC-721](./findNFTEtherscan.png)
+![Comment trouver le hachage de votre transaction et l'ID de votre jeton ERC-721](./findNFTEtherscan.png)
 
-Vous devrez peut-être procéder à quelques actualisations pour voir votre NFT — mais il sera là <Emoji text="😄" size={1} />!
+Vous devrez peut-être actualiser plusieurs fois pour voir votre NFT — mais il sera là <Emoji text="😄" size={1} /> !
 
 ![Comment téléverser votre NFT sur MetaMask](./findNFTMetamask.gif)
 
diff --git a/public/content/translations/fr/developers/tutorials/how-to-write-and-deploy-an-nft/index.md b/public/content/translations/fr/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
index 11f94fd11cb..2a7cc3723d5 100644
--- a/public/content/translations/fr/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
+++ b/public/content/translations/fr/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
@@ -1,12 +1,14 @@
 ---
-title: Comment écrire & déployer un NFT (Partie 1/3 du tutoriel NFT)
-description: Ce tutoriel est la première partie de la série sur les NFT et vous guidera pas-à-pas sur la façon d'écrire et de déployer un contrat intelligent de jeton non fongible (jeton ERC-721) avec Ethereum et IPFS (Inter Planetary File System).
+title: "Comment écrire et déployer un NFT (Partie 1/3 de la série de tutoriels NFT)"
+description: "Ce tutoriel est la première partie de la série sur les NFT et vous guidera pas-à-pas sur la façon d'écrire et de déployer un contrat intelligent de jeton non fongible (jeton ERC-721) avec Ethereum et IPFS (Inter Planetary File System)."
 author: "Sumi Mudgil"
 tags:
-  - "ERC-721"
-  - "Alchemy"
-  - "Solidity"
-  - "contrats intelligents"
+  [
+    "ERC-721",
+    "Alchemy",
+    "Solidity",
+    "contrats intelligents"
+  ]
 skill: beginner
 lang: fr
 published: 2021-04-22
@@ -14,72 +16,79 @@ published: 2021-04-22
 
 Grâce aux NFT, la blockchain a été découverte par le grand public. C'est l'occasion rêvée de comprendre cet engouement en publiant votre propre contrat NFT (jeton ERC-721) sur la blockchain Ethereum !
 
-Alchemy est extrêmement fier d'alimenter les plus grands noms du monde des NFT, notamment Makersplace (qui a récemment établi un record de ventes d'œuvres d'art numériques chez Christie's pour 69 millions de dollars), Dapper Labs (créateurs de NBA Top Shot & Crypto Kitties), OpenSea (la plus grande place de marché NFT du monde), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable, et bien d'autres.
+Alchemy est extrêmement fier d'alimenter les plus grands noms de l'espace NFT, y compris Makersplace (qui a récemment établi un record de vente d'œuvres d'art numériques chez Christie's pour 69 millions de dollars), Dapper Labs (créateurs de NBA Top Shot & Crypto Kitties), OpenSea (le plus grand marché NFT du monde), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable, et plus encore.
 
-Dans ce tutoriel, nous allons créer et déployer un contrat intelligent ERC-721 sur le réseau de test Sepolia à l'aide de [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), [Pinata](https://pinata.cloud/) et [Alchemy](https://alchemy.com/signup/eth) (ne vous inquiétez pas si vous ne comprenez pas encore ce que cela signifie - nous vous l'expliquerons !).
+Dans ce tutoriel, nous allons voir comment créer et déployer un contrat intelligent ERC-721 sur le réseau de test Sepolia en utilisant [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), [Pinata](https://pinata.cloud/) et [Alchemy](https://alchemy.com/signup/eth) (ne vous inquiétez pas si vous ne comprenez pas encore ce que tout cela signifie, nous allons tout vous expliquer !).
 
 Dans la deuxième partie de ce tutoriel, nous verrons comment utiliser notre contract intelligent pour créer un NFT, et dans la troisième partie, nous expliquerons comment visualiser votre NFT sur MetaMask.
 
-Bien sûr, si vous avez des questions à n'importe quel moment, n'hésitez pas à contacter [le discord d'Alchemy](https://discord.gg/gWuC7zB) ou consultez [la documentation de l'API NFT d'Alchemy](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api) !
+Et bien sûr, si vous avez des questions, n'hésitez pas à les poser sur le [Discord d'Alchemy](https://discord.gg/gWuC7zB) ou à consulter la [documentation de l'API NFT d'Alchemy](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api) !
 
 ## Étape 1 : Se connecter au réseau Ethereum {#connect-to-ethereum}
 
-Il existe de nombreuses façons d'émettre des requêtes sur la blockchain Ethereum, mais pour faciliter les choses, nous utiliserons un compte gratuit sur [Alchemy](https://alchemy.com/signup/eth), une plateforme pour développeurs de blockchain et une API nous permettant de communiquer avec la chaîne Ethereum sans avoir à exécuter nos propres nœuds.
+Il existe de nombreuses façons de faire des requêtes à la blockchain Ethereum, mais pour simplifier les choses, nous utiliserons un compte gratuit sur [Alchemy](https://alchemy.com/signup/eth), une plateforme de développement blockchain et une API qui nous permet de communiquer avec la chaîne Ethereum sans avoir à exécuter nos propres nœuds.
 
 Dans ce tutoriel, nous allons également tirer parti des outils de développement d'Alchemy pour le suivi et l'analyse afin de comprendre ce qui se passe sous le capot concernant le déploiement de notre contract intelligent. Si vous n'avez pas encore de compte Alchemy, vous pouvez vous inscrire gratuitement [ici](https://alchemy.com/signup/eth).
 
-## Étape 2 : Créer votre application (et votre clé d'API) {#make-api-key}
+## Étape 2 : Créer votre application (et votre clé API) {#make-api-key}
 
-Une fois que vous avez créé un compte Alchemy, vous pouvez générer une clé d'API en créant une application. Cela va nous permettre d'émettre des requêtes sur le réseau de test Sepolia. Consultez [ce guide](https://docs.alchemyapi.io/guides/choosing-a-network), si vous voulez en apprendre plus sur les réseaux de test.
+Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela va nous permettre d'émettre des requêtes sur le réseau de test Sepolia. Consultez [ce guide](https://docs.alchemyapi.io/guides/choosing-a-network) si vous souhaitez en savoir plus sur les réseaux de test.
 
 1. Accédez à la page « Create App » dans votre Tableau de bord Alchemy, en survolant « Apps » dans la barre de navigation et en cliquant sur « Create App »
 
-![Créez votre application](./create-your-app.png)
+![Créer votre application](./create-your-app.png)
 
 2. Nommez votre application (nous avons choisi « Mon premier NFT ! »), donnez une brève description, sélectionnez « Ethereum » pour la chaine, et choisissez « Sepolia » pour votre réseau. Depuis la fusion, les autres réseaux de test sont obsolètes.
 
-![Configurez et publiez votre application](./alchemy-explorer-sepolia.png)
+![Configurer et publier votre application](./alchemy-explorer-sepolia.png)
 
-3. Cliquez sur « Create App » et voilà ! Votre application devrait apparaître dans le tableau ci-dessous.
+3. Cliquez sur « Create app », et voilà ! Votre application devrait apparaître dans le tableau ci-dessous.
 
-## Étape 3 : Créer un compte Ethereum (une adresse) {#create-eth-address}
+## Étape 3 : Créer un compte Ethereum (adresse) {#create-eth-address}
 
-Nous avons besoin d'un compte Ethereum pour effectuer des transactions (envoyer et recevoir). Pour ce tutoriel, nous utiliserons MetaMask, un portefeuille virtuel utilisable dans le navigateur servant à gérer les adresses Ethereum. Si vous voulez en savoir plus sur le fonctionnement des transactions sur Ethereum, consultez [cette page](/developers/docs/transactions/) de la fondation Ethereum.
+Nous avons besoin d'un compte Ethereum pour effectuer des transactions (envoyer et recevoir). Pour ce tutoriel, nous allons utiliser MetaMask, un portefeuille virtuel intégré au navigateur, servant à gérer les adresses de votre compte Ethereum. Si vous voulez mieux comprendre le fonctionnement des transactions sur Ethereum, consultez [cette page](/developers/docs/transactions/) de la Fondation Ethereum.
 
 Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer sur « Réseau de test Sepolia » en haut à droite (afin de ne pas utiliser d'argent réel).
 
 ![Définir Sepolia comme votre réseau](./metamask-goerli.png)
 
-## Étape 4 : Ajouter des ethers depuis un faucet {#step-4-add-ether-from-a-faucet}
+## Étape 4 : Ajouter de l'ether à partir d'un robinet {#step-4-add-ether-from-a-faucet}
 
-Afin de déployer notre contrat intelligent sur le réseau de test, nous aurons besoin de faux ETH. Pour obtenir l'ETH, vous pouvez vous rendre sur le [Robinet Sepolia](https://sepoliafaucet.com/) hébergé par Alchemy, vous connecter et entrer l'adresse de votre compte, puis cliquez sur « Envoyez-moi des ETH ». Vous devriez voir les ETH sur votre compte MetaMask rapidement après !
+Afin de déployer notre contrat intelligent sur le serveur test, nous aurons besoin de faux ETH. Pour obtenir des ETH, vous pouvez vous rendre sur le [robinet Sepolia](https://sepoliafaucet.com/) hébergé par Alchemy, vous connecter et entrer l'adresse de votre compte, puis cliquer sur « Send Me ETH ». Vous devriez voir votre ETH dans votre compte MetaMask peu de temps après !
 
-## Étape 5 : Vérifiez votre solde {#check-balance}
+## Étape 5 : Vérifier votre solde {#check-balance}
 
-Pour vérifier notre solde, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant [l'outil de composition d'Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va renvoyer la quantité d'ETH dans notre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
+Pour vérifier que notre solde est bien là, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant l'[outil de composition d'Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va renvoyer la quantité d'ETH dans notre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
 
-    `{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}`
+    ```
+    {"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
+    ```
 
-> **Remarque** Ce résultat est en wei et non pas en ETH. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion entre wei et ETH est 1 eth = 10<sup>18</sup> wei. Donc si on convertit 0xde0b6b3a7640000 en décimale, nous obtenons 1\*10<sup>18</sup> wei, ce qui équivaut à 1 ETH.
+> **Remarque :** ce résultat est en wei, pas en ETH. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion entre wei et ETH est 1 eth = 10<sup>18</sup> wei. Donc si on convertit 0xde0b6b3a7640000 en décimale, nous obtenons 1\*10<sup>18</sup> wei, ce qui équivaut à 1 ETH.
 
 Ouf ! Notre faux argent est bien là.
 
-## Étape 6 : Initialisons notre projet {#initialize-project}
+## Étape 6 : Initialiser notre projet {#initialize-project}
 
 Pour commencer, nous allons devoir créer un dossier pour notre projet. Ouvrez votre ligne de commande et tapez :
 
+    ```
     mkdir my-nft
     cd my-nft
+    ```
 
-Maintenant que nous sommes dans le dossier de notre projet, nous allons utiliser npm init pour initialiser le projet. Si vous n'avez pas encore installé npm, suivez [ces instructions](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (nous allons également avoir besoin de [Node.js](https://nodejs.org/en/download/); donc téléchargez-le aussi !).
+Maintenant que nous sommes dans le dossier de notre projet, nous allons utiliser npm init pour initialiser le projet. Si vous n'avez pas encore installé npm, suivez [ces instructions](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (nous aurons également besoin de [Node.js](https://nodejs.org/en/download/), alors téléchargez-le aussi !).
 
+    ```
     npm init
+    ```
 
 La manière dont vous répondez à ces questions d'installation a peu d'importance ; pour référence, voici comment nous avons répondu :
+
 ```json
     package name: (my-nft)
     version: (1.0.0)
-    description: My first NFT!
+    description: Mon premier NFT !
     entry point: (index.js)
     test command:
     git repository:
@@ -91,7 +100,7 @@ La manière dont vous répondez à ces questions d'installation a peu d'importan
     {
       "name": "my-nft",
       "version": "1.0.0",
-      "description": "My first NFT!",
+      "description": "Mon premier NFT !",
       "main": "index.js",
       "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1"
@@ -100,6 +109,7 @@ La manière dont vous répondez à ces questions d'installation a peu d'importan
       "license": "ISC"
     }
 ```
+
 Approuvez le package.json, et nous sommes prêts à démarrer !
 
 ## Étape 7 : Installer [Hardhat](https://hardhat.org/getting-started/#overview) {#install-hardhat}
@@ -108,18 +118,23 @@ Hardhat est un environnement de développement qui permet de compiler, déployer
 
 Dans notre projet my-nft, exécutez :
 
+    ```
     npm install --save-dev hardhat
+    ```
 
-Consultez cette page pour plus de détails sur [les instructions d'installation](https://hardhat.org/getting-started/#overview).
+Consultez cette page pour plus de détails sur les [instructions d'installation](https://hardhat.org/getting-started/#overview).
 
-## Étape 8 : Créer un projet Hardhat {#create-hardhat-project}
+## Étape 8 : Créer le projet Hardhat {#create-hardhat-project}
 
 Dans notre dossier de projet, exécutez :
 
+    ```
     npx hardhat
+    ```
 
-Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour séléctionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :
+Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour sélectionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :
 
+    ```
     888    888                      888 888               888
     888    888                      888 888               888
     888    888                      888 888               888
@@ -128,20 +143,23 @@ Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour s
     888    888 .d888888 888    888  888 888  888 .d888888 888
     888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
     888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
-    👷 Welcome to Hardhat v2.0.11 👷‍
-    ? Que voulez vous faire ? …
-    Create a sample project
-    ❯ Create an empty hardhat.config.js
-    Quit
+    👷 Bienvenue dans Hardhat v2.0.11 👷‍
+    ? Que voulez-vous faire ? …
+    Créer un projet d'exemple
+    ❯ Créer un fichier hardhat.config.js vide
+    Quitter
+    ```
 
 Cela va générer un fichier 'hardhar.config.js' dans lequel nous allons spécifier tous les paramètres de notre projet (à l'étape 13).
 
 ## Étape 9 : Ajouter les dossiers du projet {#add-project-folders}
 
-Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. Naviguez vers le répertoire racine de votre projet dans votre ligne de commande et tapez :
+Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. Naviguez vers le répertoire racine de votre projet dans votre invite de commande en ligne et tapez :
 
+    ```
     mkdir contracts
     mkdir scripts
+    ```
 
 - contracts/ est l'endroit où nous garderons notre code de contrat intelligent NFT
 
@@ -149,16 +167,16 @@ Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. N
 
 ## Étape 10 : Écrire notre contrat {#write-contract}
 
-Maintenant que notre environnement est configuré, passons aux choses plus excitantes : _écrire le code de notre contrat intelligent !_
+Maintenant que notre environnement est configuré, passons à des choses plus passionnantes : _l'écriture du code de notre contrat intelligent !_
 
-Ouvrez le projet my-nft dans votre éditeur de code favori (nous apprécions [VSCode](https://code.visualstudio.com/)). Les contrats intelligents sont écrits dans un langage appelé Solidity, qui est celui que nous allons utiliser pour écrire notre contrat intelligent MyNFT.sol.
+Ouvrez le projet my-nft dans votre éditeur préféré (nous aimons [VSCode](https://code.visualstudio.com/)). Les contrats intelligents sont écrits dans un langage appelé Solidity, qui est celui que nous allons utiliser pour écrire notre contrat intelligent MyNFT.sol.
 
-1. Naviguez vers le dossier `contracts` et créez un nouveau fichier appelé MyNFT.sol
+1. Allez dans le dossier `contracts` et créez un nouveau fichier nommé MyNFT.sol
 
-2. Ci-dessous vous trouverez le code de notre contrat intelligent NFT, que nous avons basé sur l'implémentation ERC-721 de la bibliothèque [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc721). Copiez et collez le contenu ci-dessous dans votre fichier MyNFT.sol.
+2. Vous trouverez ci-dessous le code de notre contrat intelligent NFT, que nous avons basé sur l'implémentation ERC-721 de la bibliothèque [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc721). Copiez et collez le contenu ci-dessous dans votre fichier MyNFT.sol.
 
    ```solidity
-   //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
+   // Contrat basé sur [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
 
@@ -188,54 +206,58 @@ Ouvrez le projet my-nft dans votre éditeur de code favori (nous apprécions [VS
    }
    ```
 
-3. Comme nous héritons des classes de la bibliothèque de contrats OpenZeppelin, dans votre ligne de commande, exécutez `npm install @openzeppelin/contracts` pour installer la bibliothèque dans notre dossier.
+3. Puisque nous héritons des classes de la bibliothèque de contrats OpenZeppelin, exécutez `npm install @openzeppelin/contracts^4.0.0` dans votre ligne de commande pour installer la bibliothèque dans notre dossier.
 
-Que _fait_ donc exactement ce code ? Décortiquons-le ligne par ligne.
+Alors, que _fait_ ce code exactement ? Décortiquons-le ligne par ligne.
 
-En haut de notre contrat intelligent, nous importons trois classes des contrats intelligents d'[OpenZeppelin](https://openzeppelin.com/) :
+En haut de notre contrat intelligent, nous importons trois classes de contrats intelligents [OpenZeppelin](https://openzeppelin.com/) :
 
-- @openzeppelin/contracts/token/ERC721/ERC721.sol contient l'implémentation de la norme ERC-721, dont notre contrat intelligent NFT héritera. (Pour être un NFT valide, votre contrat intelligent doit implémenter toutes les méthodes de la norme ERC-721.) Pour en savoir plus sur les fonctions héritées d'ERC-721, consultez la définition de l'interface [ici](https://eips.ethereum.org/EIPS/eip-721).
+- @openzeppelin/contracts/token/ERC721/ERC721.sol contient l'implémentation de la norme ERC-721, dont notre contrat intelligent NFT héritera. (Pour être un NFT valide, votre contrat intelligent doit implémenter toutes les méthodes de la norme ERC-721.) Pour en savoir plus sur les fonctions ERC-721 héritées, consultez la définition de l'interface [ici](https://eips.ethereum.org/EIPS/eip-721).
 
 - @openzeppelin/contracts/utils/Counters.sol fournit des compteurs qui ne peuvent être incrémentés ou décrémentés que de un. Notre contrat intelligent utilise des compteurs pour garder une trace du nombre total de NFT créés et définir l'ID unique de votre nouveau NFT. (Chaque NFT créé à l'aide d'un contrat intelligent doit se voir attribuer un ID unique - ici notre ID unique est simplement déterminé par le nombre total de NFT existants. Par exemple, le premier NFT que nous créons avec notre contrat intelligent a un ID de « 1 », le deuxième NFT a un ID de « 2 », etc.)
 
-- @openzeppelin/contracts/access/Ownable.sol met en place [un contrôle d'accès](https://docs.openzeppelin.com/contracts/3.x/access-control) sur notre contrat intelligent, de sorte que seul le propriétaire du contrat intelligent (vous) puisse créer des NFT. (Remarque : l'inclusion du contrôle d'accès est entièrement une préférence. Si vous souhaitez que n'importe qui puisse créer un NFT en utilisant votre contrat intelligent, supprimez le mot « Ownable » à la ligne 10 et « onlyOwner » à la ligne 17.)
+- @openzeppelin/contracts/access/Ownable.sol met en place un [contrôle d'accès](https://docs.openzeppelin.com/contracts/3.x/access-control) sur notre contrat intelligent, de sorte que seul le propriétaire du contrat intelligent (vous) puisse frapper des NFT. (Remarque : l'inclusion du contrôle d'accès est entièrement une préférence. Si vous souhaitez que n'importe qui puisse créer un NFT en utilisant votre contrat intelligent, supprimez le mot « Ownable » à la ligne 10 et « onlyOwner » à la ligne 17.)
 
-Après nos déclarations d'importation, nous obtenons notre contrat intelligent NFT personnalisé, qui est étonnamment court - il ne contient qu'un compteur, un constructeur et une seule fonction ! Ceci grâce à nos contrats OpenZeppelin hérités, qui mettent en œuvre la plupart des méthodes dont nous avons besoin pour créer un NFT, comme `ownerOf` qui renvoie le propriétaire du NFT, et `transferFrom`, qui transfère la propriété du NFT d'un compte à un autre.
+Après nos déclarations d'importation, nous obtenons notre contrat intelligent NFT personnalisé, qui est étonnamment court - il ne contient qu'un compteur, un constructeur et une seule fonction ! C'est grâce à nos contrats OpenZeppelin hérités, qui implémentent la plupart des méthodes dont nous avons besoin pour créer un NFT, comme `ownerOf` qui renvoie le propriétaire du NFT, et `transferFrom`, qui transfère la propriété du NFT d'un compte à un autre.
 
 Dans notre constructeur ERC-721, vous remarquerez que nous passons deux chaînes de caractères, « MyNFT » et « NFT ». La première variable est le nom de notre contrat intelligent, et le second est son symbole. Vous pouvez nommer chacune de ces variables comme vous le souhaitez !
 
-Enfin, nous avons notre fonction `mintNFT (destinataire de l'adresse, string memory tokenURI)` qui nous permet de frapper un NFT ! Vous remarquerez que cette fonction prend en paramètre deux variables :
+Enfin, nous avons notre fonction `mintNFT(address recipient, string memory tokenURI)` qui nous permet de frapper un NFT ! Vous remarquerez que cette fonction prend en paramètre deux variables :
 
-- `address recipient` spécifie l'addresse qui recevra votre NFT fraîchement créé
+- `address recipient` spécifie l'adresse qui recevra votre NFT fraîchement frappé.
 
-- `string memory tokenURI` est une chaîne de caractères qui doit se résoudre en un document JSON décrivant les métadonnées du NFT. Les métadonnées d'un NFT sont ce qui lui donne vie, lui permettant d'avoir des propriétés configurables, comme un nom, une description, une image et d'autres attributs. Dans la deuxième partie de ce tutoriel, nous décrirons comment configurer ces métadonnées.
+- `string memory tokenURI` est une chaîne de caractères qui doit correspondre à un document JSON décrivant les métadonnées du NFT. Les métadonnées d'un NFT sont ce qui lui donne vie, lui permettant d'avoir des propriétés configurables, comme un nom, une description, une image et d'autres attributs. Dans la deuxième partie de ce tutoriel, nous décrirons comment configurer ces métadonnées.
 
 `mintNFT` appelle certaines méthodes de la bibliothèque ERC-721 héritée, et renvoie finalement un nombre qui représente l'ID du NFT fraîchement frappé.
 
-## Étape 11 : Connecter MetaMask & Alchemy à votre projet {#connect-metamask-and-alchemy}
+## Étape 11 : Connecter MetaMask et Alchemy à votre projet {#connect-metamask-and-alchemy}
 
 Maintenant que nous avons créé un portefeuille MetaMask, un compte Alchemy et écrit notre contrat intelligent, il est temps de connecter les trois.
 
 Chaque transaction envoyée depuis votre portefeuille virtuel nécessite une signature en utilisant votre clé privée unique. Pour donner cette permission à notre programme, nous pouvons stocker en toute sécurité notre clé privée (et la clé API Alchemy) dans un fichier d'environnement.
 
-Pour en savoir plus sur l'envoi de transactions, consultez [ce tutoriel](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sur l'envoi de transactions avec web3.
+Pour en savoir plus sur l'envoi de transactions, consultez [ce tutoriel](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sur l'envoi de transactions à l'aide de web3.
 
 Premièrement, installez le paquet dotenv dans votre dossier de projet :
 
+    ```
     npm install dotenv --save
+    ```
 
-Ensuite, créez un fichier `.env` dans le répertoire racine de notre projet et ajoutez-y votre clé privée MetaMask et l'URL de l'API HTTP Alchemy.
+Ensuite, créez un fichier `.env` à la racine de notre projet, et ajoutez-y votre clé privée MetaMask et votre URL d'API HTTP Alchemy.
 
-- Suivez [ces instructions](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) pour exporter votre clé privée de MetaMask
+- Suivez [ces instructions](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) pour exporter votre clé privée depuis MetaMask.
 
 - Voir ci-dessous pour obtenir l'URL de l'API HTTP Alchemy et la copier dans votre presse-papiers
 
-![Copiez l'URL de votre API Alchemy](./copy-alchemy-api-url.gif)
+![Copier votre URL d'API Alchemy](./copy-alchemy-api-url.gif)
 
-Votre fichier `.env` devrait ressembler à ceci :
+Votre fichier `.env` devrait maintenant ressembler à ceci :
 
+    ```
     API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key"
     PRIVATE_KEY="your-metamask-private-key"
+    ```
 
 Pour les relier effectivement à notre code, nous ferons référence à ces variables dans notre fichier hardhat.config.js à l'étape 13.
 
@@ -243,13 +265,15 @@ Pour les relier effectivement à notre code, nous ferons référence à ces vari
 
 ## Étape 12 : Installer Ethers.js {#install-ethers}
 
-Ethers.js est une bibliothèque qui permet facilement d'interagir et de faire des requêtes pour Ethereum en enveloppant les méthodes [standard JSON-RPC](/developers/docs/apis/json-rpc/) avec des méthodes plus conviviales d'utilisation.
+Ethers.js est une bibliothèque qui facilite l'interaction et l'envoi de requêtes à Ethereum en encapsulant les [méthodes JSON-RPC standard](/developers/docs/apis/json-rpc/) dans des méthodes plus conviviales.
 
-Hardhat facilite grandement l'intégration de [Plugins](https://hardhat.org/plugins/) pour des outils supplémentaires et des fonctionnalités étendues. Nous profiterons du [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) pour le déploiement de contrats ([Ethers.js](https://github.com/ethers-io/ethers.js/) dispose de quelques méthodes très nettes de déploiement de contrat).
+Hardhat facilite grandement l'intégration de [plugins](https://hardhat.org/plugins/) pour des outils supplémentaires et des fonctionnalités étendues. Nous allons profiter du [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) pour le déploiement du contrat ([Ethers.js](https://github.com/ethers-io/ethers.js/) a des méthodes de déploiement de contrat très propres).
 
 Dans votre dossier de projet, tapez :
 
+    ```
     npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0
+    ```
 
 Nous aurons également besoin d'ethers dans notre hardhat.config.js à l'étape suivante.
 
@@ -285,24 +309,26 @@ Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La t
 
 À partir de la ligne de commande, exécutez :
 
+    ```
     npx hardhat compile
+    ```
 
-Vous pourriez voir un avertissement du type « SPDX license identifier not provided in source file », mais nul besoin de vous inquiéter — espérons que tout le reste fonctionne ! Si ce n'est pas le cas, vous pouvez toujours envoyer un message dans le Discord [Alchemy](https://discord.gg/u72VCg3).
+Vous pourriez voir un avertissement du type « SPDX license identifier not provided in source file » (identifiant de licence SDPX non fourni dans le fichier source), mais nul besoin de vous inquiéter — espérons que tout le reste fonctionne ! Sinon, vous pouvez toujours envoyer un message sur le [Discord d'Alchemy](https://discord.gg/u72VCg3).
 
 ## Étape 15 : Écrire notre script de déploiement {#write-deploy}
 
 Maintenant que notre contrat est codé et que notre fichier de configuration est bon, il est temps d’écrire notre script de déploiement pour notre contrat.
 
-Naviguez vers le dossier `scripts/` et créez un nouveau fichier appelé `deploy.js`, en y ajoutant le contenu suivant :
+Allez dans le dossier `scripts/`, créez un nouveau fichier nommé `deploy.js` et ajoutez-y le contenu suivant :
 
 ```js
 async function main() {
   const MyNFT = await ethers.getContractFactory("MyNFT")
 
-  // Start deployment, returning a promise that resolves to a contract object
+  // Démarrer le déploiement, en retournant une promesse qui se résout en un objet de contrat
   const myNFT = await MyNFT.deploy()
   await myNFT.deployed()
-  console.log("Contract deployed to address:", myNFT.address)
+  console.log("Contrat déployé à l'adresse :", myNFT.address)
 }
 
 main()
@@ -313,40 +339,48 @@ main()
   })
 ```
 
-Hardhat est incroyable en ce sens qu'il explique clairement ce que fait chacune des lignes de code au travers de son [tutoriel sur les contrats](https://hardhat.org/tutorial/testing-contracts.html#writing-tests). Nous avons repris ces explications ici.
+Hardhat explique très bien ce que fait chacune de ces lignes de code dans son [tutoriel sur les contrats](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), nous avons repris leurs explications ici.
 
+    ```
     const MyNFT = await ethers.getContractFactory("MyNFT");
+    ```
 
 Un ContractFactory dans ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents, donc MyNFT est ici une usine pour les instances de notre contrat NFT. Lors de l'utilisation du plugin « hardhat-ethers », les instances de ContractFactory et de Contract sont connectées au premier signataire par défaut.
 
+    ```
     const myNFT = await MyNFT.deploy();
+    ```
 
-L'appel de deploy() sur un ContractFactory lancera le déploiement, et renverra une « Promise » qui se résout en un Contrat. C'est l'objet qui a une méthode pour chacune de nos fonctions de contrat intelligent.
+L'appel de deploy() sur un ContractFactory lancera le déploiement, et renverra une « Promise » qui se résout en un Contrat. C'est l'objet qui possède une méthode pour chacune des fonctions de notre contrat intelligent.
 
 ## Étape 16 : Déployer notre contrat {#deploy-contract}
 
 Nous sommes enfin prêts à déployer notre contrat intelligent ! Naviguez à nouveau vers la racine du répertoire de votre projet, et dans la ligne de commande, exécutez :
 
+    ```
     npx hardhat --network sepolia run scripts/deploy.js
+    ```
 
-Vous devriez dès lors voir quelque chose comme :
+Vous devriez maintenant voir quelque chose comme :
 
+    ```
     Contrat déployé à l'adresse : 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650
+    ```
 
-Si nous allons sur l'[etherscan Sepolia](https://sepolia.etherscan.io/) et que nous recherchons l'adresse de notre contrat, nous devrions constater qu'il a été déployé avec succès. Si vous ne pouvez pas le voir immédiatement, veuillez patienter, car cela peut prendre un certain temps. La transaction ressemblera à ceci :
+Si nous allons sur l'[Etherscan de Sepolia](https://sepolia.etherscan.io/) et que nous recherchons l'adresse de notre contrat, nous devrions pouvoir voir qu'il a été déployé avec succès. Si vous ne pouvez pas le voir immédiatement, veuillez patienter, car cela peut prendre un certain temps. La transaction ressemblera à quelque chose comme :
 
-![Consultez votre adresse de transaction sur Etherscan](./etherscan-sepoila-contract-creation.png)
+![Afficher l'adresse de votre transaction sur Etherscan](./etherscan-sepoila-contract-creation.png)
 
-L'adresse « From » doit correspondre à l'adresse de votre compte MetaMask et l'adresse « To » doit indiquer « Création de contrat ». Si nous cliquons sur la transaction, nous verrons l'adresse de notre contrat dans le champ « To » :
+L'adresse de l'expéditeur (From) doit correspondre à l'adresse de votre compte MetaMask et l'adresse du destinataire (To) indiquera « Création de contrat ». Si nous cliquons sur la transaction, nous verrons l'adresse de notre contrat dans le champ « To » :
 
-![Consultez l'adresse de votre contrat sur Etherscan](./etherscan-sepolia-tx-details.png)
+![Afficher l'adresse de votre contrat sur Etherscan](./etherscan-sepolia-tx-details.png)
 
 Super ! Vous venez de déployer votre contrat intelligent NFT sur la chaîne (réseau de test) d'Ethereum !
 
-Pour comprendre ce qui se passe sous le capot, naviguons dans l'onglet Explorer de notre [tableau de bord Alchemy](https://dashboard.alchemyapi.io/explorer). Si vous avez plusieurs applications Alchemy, veillez à filtrer par application et à sélectionner « MyNFT ».
+Pour comprendre ce qui se passe en coulisses, allons dans l'onglet Explorer de notre [tableau de bord Alchemy](https://dashboard.alchemyapi.io/explorer). Si vous avez plusieurs applications Alchemy, veillez à filtrer par application et à sélectionner « MyNFT ».
 
-![Visualisez les appels effectués « sous le capot » avec le tableau de bord Explorer d'Alchemy](./alchemy-explorer-goerli.png)
+![Afficher les appels effectués « en coulisses » avec le tableau de bord Explorer d'Alchemy](./alchemy-explorer-goerli.png)
 
-Vous verrez ici un certain nombre d'appels JSON-RPC qu'Hardhat/Ethers ont effectué sous le capot pour nous lorsque nous avons appelé la fonction .deploy(). Les deux plus importants sont [eth_sendRawTransaction](/developers/docs/apis/json-rpc/#eth_sendrawtransaction), qui est la requête pour écrire réellement notre contrat intelligent sur la chaîne Sepolia, et [eth_getTransactionByHash](/developers/docs/apis/json-rpc/#eth_gettransactionbyhash) qui est une requête pour lire des informations sur notre transaction étant donné le hachage (un modèle type lors de l'envoi de transactions). Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur [l'envoi de transactions à l'aide de Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
+Vous verrez ici un certain nombre d'appels JSON-RPC qu'Hardhat/Ethers ont effectué sous le capot pour nous lorsque nous avons appelé la fonction .deploy(). Deux appels importants à signaler ici sont [eth_sendRawTransaction](/developers/docs/apis/json-rpc/#eth_sendrawtransaction), qui est la requête pour effectivement écrire notre contrat intelligent sur la chaîne Sepolia, et [eth_getTransactionByHash](/developers/docs/apis/json-rpc/#eth_gettransactionbyhash) qui est une requête pour lire des informations sur notre transaction à partir de son hachage (un modèle typique lors de l'envoi de transactions). Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur l'[envoi de transactions à l'aide de Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
 
-C'est tout pour la Partie 1 de ce tutoriel. Dans la [Partie 2, nous interagirons réellement avec notre contrat intelligent en créant notre NFT](/developers/tutorials/how-to-mint-an-nft/), et dans la [Partie 3, nous vous montrerons comment visualiser votre NFT dans votre portefeuille Ethereum](/developers/tutorials/how-to-view-nft-in-metamask/) !
+C'est tout pour la Partie 1 de ce tutoriel. Dans la [partie 2, nous interagirons avec notre contrat intelligent en frappant un NFT](/developers/tutorials/how-to-mint-an-nft/), et dans la [partie 3, nous vous montrerons comment voir votre NFT dans votre portefeuille Ethereum](/developers/tutorials/how-to-view-nft-in-metamask/) !
diff --git a/public/content/translations/fr/developers/tutorials/interact-with-other-contracts-from-solidity/index.md b/public/content/translations/fr/developers/tutorials/interact-with-other-contracts-from-solidity/index.md
index aa983a23a23..837ee103e52 100644
--- a/public/content/translations/fr/developers/tutorials/interact-with-other-contracts-from-solidity/index.md
+++ b/public/content/translations/fr/developers/tutorials/interact-with-other-contracts-from-solidity/index.md
@@ -1,13 +1,15 @@
 ---
-title: Interagir avec les autres contrats de Solidity
-description: Comment déployer un contrat intelligent à partir d'un contrat existant et interagir avec lui
+title: Interagir avec d'autres contrats depuis Solidity
+description: "Comment déployer un contrat intelligent à partir d'un contrat existant et interagir avec lui"
 author: "jdourlens"
 tags:
-  - "contrats intelligents"
-  - "solidity"
-  - "remix"
-  - "déploiement"
-  - "composabilité"
+  [
+    "contrats intelligents",
+    "Solidity",
+    "Remix",
+    "déploiement",
+    "composabilité"
+  ]
 skill: advanced
 lang: fr
 published: 2020-04-05
@@ -16,9 +18,9 @@ sourceUrl: https://ethereumdev.io/interact-with-other-contracts-from-solidity/
 address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 ---
 
-Dans le tutoriel précédent nous avons appris [Comment déployer votre premier contrat intelligent](/developers/tutorials/deploying-your-first-smart-contract/) et ajouter des fonctionnalité comme [le contrôle d'accès avec des modificateurs](https://ethereumdev.io/organize-your-code-and-control-access-to-your-smart-contract-with-modifiers/) ou [la gestion d'erreur avec Solidity](https://ethereumdev.io/handle-errors-in-solidity-with-require-and-revert/). Dans ce tutoriel, nous allons apprendre comment déployer un contrat intelligent à partir d'un contrat existant et interagir avec celui-ci.
+Dans les tutoriels précédents, nous avons beaucoup appris sur [comment déployer votre premier contrat intelligent](/developers/tutorials/deploying-your-first-smart-contract/), comment y ajouter certaines fonctionnalités comme le [contrôle d'accès avec des modificateurs](https://ethereumdev.io/organize-your-code-and-control-access-to-your-smart-contract-with-modifiers/) ou la [gestion des erreurs dans Solidity](https://ethereumdev.io/handle-errors-in-solidity-with-require-and-revert/). Dans ce tutoriel, nous allons apprendre comment déployer un contrat intelligent à partir d'un contrat existant et interagir avec celui-ci.
 
-Nous allons créer un contrat qui permet à quiconque de disposer de son propre contrat intelligent `Counter` en créant une usine. Nous l'appellerons `CounterFactory`. Tout d'abord voici le code de notre précèdent contrat intelligent `Counter` :
+Nous allons créer un contrat qui permet à quiconque d'avoir son propre contrat intelligent `Counter` en créant une fabrique pour celui-ci. Son nom sera `CounterFactory`. Voici d'abord le code de notre contrat intelligent `Counter` initial :
 
 ```solidity
 pragma solidity 0.5.17;
@@ -31,12 +33,12 @@ contract Counter {
 
 
      modifier onlyOwner(address caller) {
-        require(caller == _owner, "Vous le proprietaire du contrat");
+        require(caller == _owner, "Vous n'êtes pas le propriétaire du contrat");
         _;
     }
 
     modifier onlyFactory() {
-        require(msg.sender == _factory, "Vous avez besoin d’un factory");
+        require(msg.sender == _factory, "Vous devez utiliser la fabrique");
         _;
     }
 
@@ -56,19 +58,19 @@ contract Counter {
 }
 ```
 
-Notez que nous avons légèrement modifié le code du contrat pour garder une trace de l'adresse de la Factory et de l'adresse du titulaire du contrat. Lorsque vous appelez un code contrat depuis un autre contrat, msg.render se réfère à l'adresse de notre contrat Factory. C'est **un point vraiment important à comprendre** car utiliser un contrat pour interagir avec d'autres contrats est une pratique courante. Il convient donc de déterminer qui est l'expéditeur dans des cas complexes.
+Notez que nous avons légèrement modifié le code du contrat pour garder une trace de l'adresse de la fabrique et de l'adresse du propriétaire du contrat. Lorsque vous appelez un code de contrat depuis un autre contrat, `msg.sender` fera référence à l'adresse de notre fabrique de contrats. C'est un **point vraiment important à comprendre**, car l'utilisation d'un contrat pour interagir avec d'autres contrats est une pratique courante. Vous devez donc faire attention à qui est l'expéditeur dans les cas complexes.
 
-Pour cela, nous avons également ajouté un modificateur `onlyFactory` qui s'assure que la fonction de changement d'état ne peut être appelée que par la Factory qui passera l'appelant original comme paramètre.
+Pour cela, nous avons également ajouté un modificateur `onlyFactory` qui s'assure que la fonction de changement d'état ne peut être appelée que par la fabrique qui transmettra l'appelant original en tant que paramètre.
 
-À l'intérieur de notre nouvelle `CounterFactory` qui gérera tous les autres contre-contrats, nous ajouterons un mapping qui associera un titulaire à l'adresse de son contrat:
+À l'intérieur de notre nouvelle `CounterFactory` qui gérera tous les autres contrats Compteur, nous ajouterons un mapping qui associera un propriétaire à l'adresse de son contrat Compteur :
 
 ```solidity
 mapping(address => Counter) _counters;
 ```
 
-Dans Ethereum, le mapping est équivalent aux objets en javascript, il permet de faire correspondre une clé de type A à une valeur de type B. Dans ce cas, nous cartographions l'adresse d'un propriétaire avec l'instance de son contre-contrat.
+Dans Ethereum, les mappings sont l'équivalent des objets en JavaScript. Ils permettent de mapper une clé de type A à une valeur de type B. Dans ce cas, nous mappons l'adresse d'un propriétaire avec l'instance de son Compteur.
 
-Instancier un nouveau contre-contrat pour quelqu'un ressemblera à ceci :
+Instancier un nouveau Compteur pour quelqu'un ressemblera à ceci :
 
 ```solidity
   function createCounter() public {
@@ -77,9 +79,9 @@ Instancier un nouveau contre-contrat pour quelqu'un ressemblera à ceci :
   }
 ```
 
-Nous vérifions d'abord si la personne est déjà propriétaire d'un contre-contrat. S'il ne possède pas de contre-contrat, nous instancions un nouveau contre-contrat en passant son adresse au constructeur `Counter` et assignons l'instance nouvellement créée au mapping.
+Nous vérifions d'abord si la personne possède déjà un Compteur. S'il ne possède pas de Compteur, nous instancions un nouveau Compteur en passant son adresse au constructeur `Counter` et nous assignons l'instance nouvellement créée au mapping.
 
-Pour obtenir le nombre de vues d'un contre-contrat spécifique, il faudra faire comme ceci :
+Pour obtenir la valeur d'un Compteur spécifique, cela ressemblera à ceci :
 
 ```solidity
 function getCount(address account) public view returns (uint256) {
@@ -92,9 +94,9 @@ function getMyCount() public view returns (uint256) {
 }
 ```
 
-La première fonction vérifie s'il existe un contre-contrat pour une adresse donnée, puis appelle la méthode `getCount` de l'instance. La deuxième fonction : `getMyCount` est juste une courte opération pour passer le msg.sender directement à la fonction `getCount`.
+La première fonction vérifie si le contrat Compteur existe pour une adresse donnée, puis appelle la méthode `getCount` depuis l'instance. La deuxième fonction, `getMyCount`, est juste un raccourci pour passer directement `msg.sender` à la fonction `getCount`.
 
-La fonction `increment` est assez similaire mais bascule l'émetteur de la transaction originale vers le contrat `Counter`:
+La fonction `increment` est assez similaire, mais elle transmet l'expéditeur de la transaction originale au contrat `Counter` :
 
 ```solidity
 function increment() public {
@@ -103,11 +105,11 @@ function increment() public {
   }
 ```
 
-Notez que s'il est trop sollicité, notre compteur pourrait être saturé. Il convient d'utiliser la bibliothèque [SafeMath](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/) autant que possible pour se protéger de cette éventualité.
+Notez que s'il est appelé trop de fois, notre compteur pourrait être victime d'un dépassement de capacité (overflow). Vous devriez utiliser la [bibliothèque SafeMath](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/) autant que possible pour vous protéger de ce cas de figure.
 
-Pour déployer notre contrat, vous devrez fournir à la fois le code de la `CounterFactory` et du `Counter`. Lors du déploiement, dans Remix par exemple, vous devrez sélectionner CounterFactory.
+Pour déployer notre contrat, vous devrez fournir à la fois le code de `CounterFactory` et de `Counter`. Lors du déploiement, dans Remix par exemple, vous devrez sélectionner CounterFactory.
 
-Voici le code final :
+Voici le code complet :
 
 ```solidity
 pragma solidity 0.5.17;
@@ -120,12 +122,12 @@ contract Counter {
 
 
      modifier onlyOwner(address caller) {
-        require(caller == _owner, "Vous etes le proprietaire du contrat");
+        require(caller == _owner, "Vous n'êtes pas le propriétaire du contrat");
         _;
     }
 
     modifier onlyFactory() {
-        require(msg.sender == _factory, "Vous avez besoin d’un factory");
+        require(msg.sender == _factory, "Vous devez utiliser la fabrique");
         _;
     }
 
@@ -170,8 +172,8 @@ contract CounterFactory {
 }
 ```
 
-Après avoir compilé, dans la section de déploiement de Remix, vous sélectionnez la Factory à déployer :
+Après compilation, dans la section de déploiement de Remix, vous sélectionnerez la fabrique à déployer :
 
-![Sélection de la Factory à déployer dans Remix](./counterfactory-deploy.png)
+![Sélection de la fabrique à déployer dans Remix](./counterfactory-deploy.png)
 
-Ensuite, vous pouvez jouer avec votre Factory à contrat et suivre l'évolution de la valeur. Si vous souhaitez appeler le contrat intelligent à partir d'une adresse différente, vous devrez changer l'adresse dans la sélection de compte de Remix.
+Ensuite, vous pouvez vous amuser avec votre fabrique de contrats et vérifier que la valeur change. Si vous souhaitez appeler le contrat intelligent à partir d'une adresse différente, vous devrez changer l'adresse dans la sélection de compte de Remix.
diff --git a/public/content/translations/fr/developers/tutorials/ipfs-decentralized-ui/index.md b/public/content/translations/fr/developers/tutorials/ipfs-decentralized-ui/index.md
new file mode 100644
index 00000000000..a468c28e963
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/ipfs-decentralized-ui/index.md
@@ -0,0 +1,73 @@
+---
+title: "IPFS pour les interfaces utilisateur décentralisées"
+description: "Ce tutoriel explique au lecteur comment utiliser l'IPFS pour stocker l'interface utilisateur d'une dapp. Bien que les données et la logique métier de l'application soient décentralisées, sans une interface utilisateur résistante à la censure, les utilisateurs pourraient quand même en perdre l'accès."
+author: Ori Pomerantz
+tags: [ "ipfs" ]
+skill: beginner
+lang: fr
+published: 2024-06-29
+---
+
+Vous avez écrit une nouvelle dapp incroyable. Vous avez même écrit une [interface utilisateur](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) pour celle-ci. Mais maintenant, vous craignez que quelqu'un tente de la censurer en faisant tomber votre interface utilisateur, qui n'est qu'un simple serveur dans le cloud. Dans ce tutoriel, vous apprendrez comment éviter la censure en plaçant votre interface utilisateur sur le **[système de fichiers interplanétaire (IPFS)](https://ipfs.tech/developers/)** afin que toute personne intéressée puisse l'épingler sur un serveur pour un accès futur.
+
+Vous pourriez utiliser un service tiers tel que [Fleek](https://resources.fleek.xyz/docs/) pour faire tout le travail. Ce tutoriel s'adresse aux personnes qui veulent en faire assez pour comprendre ce qu'elles font, même si cela demande plus de travail.
+
+## Démarrer en local {#getting-started-locally}
+
+Il existe de multiples [fournisseurs IPFS tiers](https://docs.ipfs.tech/how-to/work-with-pinning-services/#use-a-third-party-pinning-service), mais il est préférable de commencer par exécuter IPFS localement pour les tests.
+
+1. Installez l'[interface utilisateur d'IPFS](https://docs.ipfs.tech/install/ipfs-desktop/#install-instructions).
+
+2. Créez un répertoire avec votre site web. Si vous utilisez [Vite](https://vite.dev/), utilisez cette commande :
+
+   ```sh
+   pnpm vite build
+   ```
+
+3. Dans IPFS Desktop, cliquez sur **Importer > Dossier** et sélectionnez le répertoire que vous avez créé à l'étape précédente.
+
+4. Sélectionnez le dossier que vous venez de télécharger et cliquez sur **Renommer**. Donnez-lui un nom plus significatif.
+
+5. Sélectionnez-le à nouveau et cliquez sur **Partager le lien**. Copiez l'URL dans le presse-papiers. Le lien sera similaire à `https://ipfs.io/ipfs/QmaCuQ7yN6iyBjLmLGe8YiFuCwnePoKfVu6ue8vLBsLJQJ`.
+
+6. Cliquez sur **Statut**. Développez l'onglet **Avancé** pour voir l'adresse de la passerelle. Par exemple, sur mon système, l'adresse est `http://127.0.0.1:8080`.
+
+7. Combinez le chemin de l'étape du lien avec l'adresse de la passerelle pour trouver votre adresse. Par exemple, pour l'exemple ci-dessus, l'URL est `http://127.0.0.1:8080/ipfs/QmaCuQ7yN6iyBjLmLGe8YiFuCwnePoKfVu6ue8vLBsLJQJ`. Ouvrez cette URL dans un navigateur pour voir votre site.
+
+## Mise en ligne {#uploading}
+
+Vous pouvez donc maintenant utiliser IPFS pour servir des fichiers localement, ce qui n'est pas très excitant. L'étape suivante consiste à les rendre disponibles au monde entier lorsque vous êtes hors ligne.
+
+Il existe un certain nombre de [services d'épinglage](https://docs.ipfs.tech/concepts/persistence/#pinning-services) bien connus. Choisissez l'un d'entre eux. Quel que soit le service que vous utilisez, vous devez créer un compte et lui fournir l'**identifiant de contenu (CID)** dans votre bureau IPFS.
+
+Personnellement, j'ai trouvé que [4EVERLAND](https://docs.4everland.org/storage/4ever-pin/guides) était le plus facile à utiliser. Voici les instructions pour cela :
+
+1. Accédez au [tableau de bord](https://dashboard.4everland.org/overview) et connectez-vous avec votre portefeuille.
+
+2. Dans la barre latérale gauche, cliquez sur **Stockage > 4EVER Pin**.
+
+3. Cliquez sur **Télécharger > CID sélectionné**. Donnez un nom à votre contenu et fournissez le CID depuis le bureau IPFS. Actuellement, un CID est une chaîne de caractères qui commence par `Qm` suivi de 44 lettres et chiffres qui représentent un hachage [encodé en base 58](https://medium.com/bootdotdev/base64-vs-base58-encoding-c25553ff4524), tel que `QmaCuQ7yN6iyBjLmLGe8YiFuCwnePoKfVu6ue8vLBsLJQJ`, mais [cela est susceptible de changer](https://docs.ipfs.tech/concepts/content-addressing/#version-1-v1).
+
+4. Le statut initial est **En file d'attente**. Rechargez jusqu'à ce qu'il passe à **Épinglé**.
+
+5. Cliquez sur votre CID pour obtenir le lien. Vous pouvez voir mon application [ici](https://bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im.ipfs.dweb.link/).
+
+6. Vous devrez peut-être activer votre compte pour qu'il soit épinglé pendant plus d'un mois. L'activation du compte coûte environ 1 $. Si vous l'avez fermé, déconnectez-vous et reconnectez-vous pour qu'on vous demande de l'activer à nouveau.
+
+## Utilisation depuis IPFS {#using-from-ipfs}
+
+À ce stade, vous disposez d'un lien vers une passerelle centralisée qui sert votre contenu IPFS. En bref, votre interface utilisateur est peut-être un peu plus sûre, mais elle n'est toujours pas résistante à la censure. Pour une véritable résistance à la censure, les utilisateurs doivent utiliser IPFS [directement depuis un navigateur](https://docs.ipfs.tech/install/ipfs-companion/#prerequisites).
+
+Une fois que vous l'avez installé (et que le bureau IPFS fonctionne), vous pouvez aller sur [/ipfs/`<CID>`](https://any.site/ipfs/bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im) sur n'importe quel site et vous obtiendrez ce contenu, servi de manière décentralisée.
+
+## Inconvénients {#drawbacks}
+
+Vous ne pouvez pas supprimer de manière fiable les fichiers IPFS, donc tant que vous modifiez votre interface utilisateur, il est probablement préférable de la laisser centralisée, ou d'utiliser le [système de nom interplanétaire (IPNS)](https://docs.ipfs.tech/concepts/ipns/#mutability-in-ipfs), un système qui fournit la mutabilité au-dessus d'IPFS. Bien sûr, tout ce qui est mutable peut être censuré, dans le cas d'IPNS en faisant pression sur la personne possédant la clé privée à laquelle il correspond.
+
+De plus, certains paquets ont un problème avec IPFS, donc si votre site web est très compliqué, ce n'est peut-être pas une bonne solution. Et bien sûr, tout ce qui repose sur l'intégration d'un serveur ne peut pas être décentralisé simplement en ayant le côté client sur IPFS.
+
+## Conclusion {#conclusion}
+
+Tout comme Ethereum vous permet de décentraliser la base de données et la logique métier de votre dapp, IPFS vous permet de décentraliser l'interface utilisateur. Cela vous permet de fermer un autre vecteur d'attaque contre votre dapp.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md b/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
index 8025a28644f..afd7824a244 100644
--- a/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
+++ b/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
@@ -1,14 +1,15 @@
 ---
-title: Démarrer le développement de votre interface dApp avec create-eth-app
-description: Aperçu de l'utilisation de create-eth-app et de ses fonctionnalités
+title: "Démarrez le développement de votre interface de dApp avec create-eth-app."
+description: "Un aperçu de l'utilisation de create-eth-app et de ses fonctionnalités."
 author: "Markus Waas"
 tags:
-  - "create-eth-app"
-  - "frontend"
-  - "javascript"
-  - "ethers.js"
-  - "the graph"
-  - "DeFi"
+  [
+    "frontend",
+    "JavaScript",
+    "ethers.js",
+    "the graph",
+    "DeFi"
+  ]
 skill: beginner
 lang: fr
 published: 2020-04-27
@@ -16,11 +17,11 @@ source: soliditydeveloper.com
 sourceUrl: https://soliditydeveloper.com/create-eth-app
 ---
 
-La dernière fois nous nous sommes intéressés à [Solidity](https://soliditydeveloper.com/solidity-overview-2020) et avons mentionné [create-eth-app](https://github.com/PaulRBerg/create-eth-app). Vous allez maintenant découvrir comment l'utiliser, quelles fonctionnalités y sont intégrées et comment l'étendre encore. Initiée par Paul Razvan Berg, fondateur de [Sablier](http://sablier.com/), cette application livrée avec plusieurs intégrations facultatives au choix va vous permettre de débuter le développement de votre interface.
+La dernière fois, nous avons examiné [la vue d'ensemble de Solidity](https://soliditydeveloper.com/solidity-overview-2020) et déjà mentionné [create-eth-app](https://github.com/PaulRBerg/create-eth-app). Vous allez maintenant découvrir comment l'utiliser, quelles fonctionnalités sont intégrées et des idées supplémentaires sur la façon de l'étendre. Lancée par Paul Razvan Berg, le fondateur de [Sablier](http://sablier.com/), cette application donnera un coup d'envoi à votre développement d'interface et est livrée avec plusieurs intégrations optionnelles au choix.
 
 ## Installation {#installation}
 
-L'installation nécessite au minimum Yarn 0.25 (`npm install yarn --global`). L'installation est aussi simple que l'exécution :
+L'installation nécessite Yarn 0.25 ou une version ultérieure (`npm install yarn --global`). C'est aussi simple que d'exécuter :
 
 ```bash
 yarn create eth-app my-eth-app
@@ -28,44 +29,44 @@ cd my-eth-app
 yarn react-app:start
 ```
 
-Elle s'appuie sur [create-react-app](https://github.com/facebook/create-react-app). Pour voir votre application, ouvrez `http://localhost:3000/`. Lorsque vous êtes prêt à déployer en production, créez un paquet minifié avec le constructeur yarn. Un moyen simple de l'héberger est [Netlify](https://www.netlify.com/). Vous pouvez créer un dépôt GitHub, l'ajouter à Netlify, configurer la commande de construction et le tour est joué ! Votre application sera hébergée et utilisable par tout le monde. Et tout ceci gratuitement.
+Elle utilise [create-react-app](https://github.com/facebook/create-react-app) sous le capot. Pour voir votre application, ouvrez `http://localhost:3000/`. Quand vous êtes prêt à déployer en production, créez un paquet minifié avec `yarn build`. Une façon simple de l'héberger serait d'utiliser [Netlify](https://www.netlify.com/). Vous pouvez créer un dépôt GitHub, l'ajouter à Netlify, configurer la commande de construction et le tour est joué ! Votre application sera hébergée et utilisable par tout le monde. Et tout cela, gratuitement.
 
 ## Fonctionnalités {#features}
 
-### React & create-react-app {#react--create-react-app}
+### React et create-react-app {#react--create-react-app}
 
-Premièrement, le coeur de l'application : React et toutes les fonctionnalités additionnelles livrées avec _create-react-app_. Utiliser cette seule application est une excellente option si vous ne souhaitez pas intégrer Ethereum. [React](https://reactjs.org/) rend la construction d'interfaces utilisateur interactives très facile. La prise en main n'est peut-être pas aussi facile qu'avec [Vue](https://vuejs.org/), mais l'application est encore largement utilisée, possède plus de fonctionnalités et surtout offre un choix de plusieurs milliers de bibliothèques supplémentaires. Avec _create-react-app_, le démarrage est très simple. L'application inclut :
+Tout d'abord, le cœur de l'application : React et toutes les fonctionnalités supplémentaires fournies avec _create-react-app_. Utiliser cette seule application est une excellente option si vous ne souhaitez pas intégrer Ethereum. [React](https://react.dev/) en soi facilite grandement la création d'interfaces utilisateur interactives. Sa prise en main n'est peut-être pas aussi facile qu'avec [Vue](https://vuejs.org/), mais il reste le plus utilisé, il possède plus de fonctionnalités et, surtout, il offre un choix de milliers de bibliothèques supplémentaires. _create-react-app_ facilite également le démarrage et inclut :
 
-- React, JSX, ES6, TypeScript et le support pour Flow syntax.
-- Langages complémentaires à ES6 comme l'opérateur de propagation d'objet.
-- CSS auto-préfixé, pour se passer de -webkit- ou d'autres préfixes.
+- Prise en charge de la syntaxe React, JSX, ES6, TypeScript et Flow.
+- Des fonctionnalités de langage au-delà d'ES6, comme l'opérateur de décomposition d'objet.
+- CSS avec préfixes automatiques, pour que vous n'ayez pas besoin de `-webkit-` ou d'autres préfixes.
 - Un exécuteur de test unitaire interactif rapide avec une prise en charge intégrée pour les rapports de couverture.
-- Un serveur de développement en direct qui signale les erreurs courantes.
-- Un script de construction pour associer du JS, du CSS et des images en vue de la mise en production, avec des hachages et une cartographie du code source.
+- Un serveur de développement en direct qui avertit des erreurs courantes.
+- Un script de construction pour empaqueter le JS, le CSS et les images pour la production, avec des hachages et des sourcemaps.
 
-_create-react-app_, en particulier, fait usage des nouveaux [effets hooks](https://reactjs.org/docs/hooks-effect.html). Une méthode pour écrire de puissants mais très petits composants, dits fonctionnels. Voir ci-dessous la section sur Apollo pour savoir comment ils sont utilisés dans _create-react-app_.
+L'application _create-eth-app_ utilise en particulier les nouveaux [effets de hooks](https://legacy.reactjs.org/docs/hooks-effect.html). Une méthode pour écrire de puissants mais très petits composants, dits fonctionnels. Consultez la section ci-dessous sur Apollo pour voir comment ils sont utilisés dans _create-eth-app_.
 
-### Espaces de travail Yarn {#yarn-workspaces}
+### Yarn Workspaces {#yarn-workspaces}
 
-[Les espaces de travail Yarn](https://classic.yarnpkg.com/en/docs/workspaces/) vous permettent de disposer de plusieurs paquets, mais également d'être en mesure de tous les gérer à partir du dossier racine et d'installer toutes leurs dépendances en une fois en utilisant `yarn install`. Ceci est particulièrement adapté pour les petits packs additionnels, tels que les adresses de contrats intelligents/la gestion ABI (les informations sur l'endroit où vous avez déployé tels contrats intelligents et comment communiquer avec eux) ou l'intégration de graphes, les deux parties de `create-eth-app`.
+[Yarn Workspaces](https://classic.yarnpkg.com/en/docs/workspaces/) vous permettent d'avoir plusieurs paquets, tout en pouvant les gérer tous depuis le dossier racine et installer les dépendances pour tous en même temps en utilisant `yarn install`. C'est particulièrement pertinent pour les paquets supplémentaires plus petits, comme la gestion des adresses de contrats intelligents/ABI (les informations sur l'endroit où vous avez déployé quels contrats intelligents et comment communiquer avec eux) ou l'intégration de graphe, qui font tous deux partie de `create-eth-app`.
 
 ### ethers.js {#ethersjs}
 
-Si [Web3](https://docs.web3js.org/) est encore largement utilisé, [ethers.js](https://docs.ethers.io/) a davantage été employé comme alternative l'année dernière et est intégré à _create-eth-app_. Vous pouvez travailler avec celui-ci, le faire évoluer vers Web3 ou envisager une mise à niveau pour passer à [ethers.js v5](https://docs.ethers.org/v5/) qui n'est pratiquement plus en version bêta.
+Bien que [Web3](https://docs.web3js.org/) soit encore majoritairement utilisé, [ethers.js](https://docs.ethers.io/) a gagné en popularité comme alternative au cours de l'année dernière et c'est lui qui est intégré dans _create-eth-app_. Vous pouvez travailler avec celui-ci, le remplacer par Web3 ou envisager de passer à [ethers.js v5](https://docs.ethers.org/v5/) qui est presque sorti de la version bêta.
 
-### Le réseau Graph {#the-graph}
+### The Graph {#the-graph}
 
-[GraphQL](https://graphql.org/) est un moyen alternatif de gérer les données par rapport à une [API Restful](https://restfulapi.net/). Il offre plusieurs avantages par rapport aux APIs REST, en particulier pour les données décentralisées de la blockchain. Si vous êtes intéressé par le raisonnement qui le sous-tend, jetez un œil à [GraphQL va propulser le Web décentralisé](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a).
+[GraphQL](https://graphql.org/) est une méthode alternative de gestion des données par rapport à une [API RESTful](https://restfulapi.net/). Il présente plusieurs avantages par rapport aux API RESTful, en particulier pour les données de blockchain décentralisées. Si les raisons qui motivent ce choix vous intéressent, consultez [GraphQL Will Power the Decentralized Web](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a).
 
-Vous récupérez normalement directement les données de votre contrat intelligent. Vous souhaitez connaître l'instant précis de la dernière transaction ? Appelez simplement `MyContract.methods.latestTradeTime().call()` qui récupère les données d'un nœud Ethereum comme Infura dans votre dApp. Mais que faire si vous avez besoin de centaines de points de données différents ? Il en résulterait des centaines d'extractions de données vers le nœud, nécessitant à chaque fois un [RTT](https://wikipedia.org/wiki/Round-trip_delay_time) qui ralentirait votre dApp et lui ferait perdre son efficacité. Pour éviter cela, une solution pourrait être d'utiliser une fonction d'appel de récupération dans votre contrat qui restitue plusieurs données à la fois. Ce n'est cependant pas toujours idéal.
+Habituellement, vous récupérez les données directement depuis votre contrat intelligent. Vous voulez lire l'heure de la dernière transaction ? Il suffit d'appeler `MyContract.methods.latestTradeTime().call()` qui récupère les données d'un nœud Ethereum dans votre dapp. Mais que faire si vous avez besoin de centaines de points de données différents ? Cela entraînerait des centaines de récupérations de données vers le nœud, chacune nécessitant un [RTT](https://wikipedia.org/wiki/Round-trip_delay_time), ce qui rendrait votre dapp lente et inefficace. Une solution de contournement pourrait être une fonction d'appel de récupération dans votre contrat qui renvoie plusieurs données à la fois. Ce n'est cependant pas toujours idéal.
 
-Vous pourriez également être intéressé par les données historiques. Vous souhaitez peut-être connaître non seulement le moment de la dernière transaction mais également le moment de chacune des transactions que vous avez réalisées vous-même. Utilisez le paquet subgraph de _create-eth-app_, lisez la [documentation](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph) et adaptez-la à vos propres contrats. Si vous êtes à la recherche de contrats intelligents populaires, il se peut même qu'il en existe déjà un avec subgraph. Jetez un œil à [l'explorateur de sous-graphes](https://thegraph.com/explorer/).
+Vous pourriez également être intéressé par les données historiques. Vous souhaitez peut-être connaître non seulement le moment de la dernière transaction mais également le moment de chacune des transactions que vous avez réalisées vous-même. Utilisez le paquet subgraph de _create-eth-app_, lisez la [documentation](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph) et adaptez-le à vos propres contrats. Si vous recherchez des contrats intelligents populaires, il se peut même qu'un subgraph existe déjà. Consultez l'[explorateur de subgraphs](https://thegraph.com/explorer/).
 
-Une fois que vous disposez d'un subgraph, vous pouvez écrire une simple requête dans votre dApp afin de récupérer toutes les données importantes de la blockchain, y compris les données historiques dont vous avez besoin. Une seule demande de récupération suffit.
+Une fois que vous disposez d'un subgraph, vous pouvez écrire une simple requête dans votre dapp afin de récupérer toutes les données importantes de la blockchain, y compris les données historiques dont vous avez besoin. Une seule récupération suffit.
 
 ### Apollo {#apollo}
 
-Grâce à l'intégration d'[Apollo Boost](https://www.apollographql.com/docs/react/get-started/), vous pouvez facilement intégrer Graph dans votre dApp React. Surtout lorsque vous utilisez [des hooks React et Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks), récupérer des données est aussi simple que d'écrire une requête GraphQl dans votre composant:
+Grâce à l'intégration de [Apollo Boost](https://www.apollographql.com/docs/react/get-started/), vous pouvez facilement intégrer The Graph dans votre dapp React. En particulier lorsque vous utilisez les [hooks React et Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks), la récupération de données est aussi simple que d'écrire une seule requête GraphQL dans votre composant :
 
 ```js
 const { loading, error, data } = useQuery(myGraphQlQuery)
@@ -77,34 +78,34 @@ React.useEffect(() => {
 }, [loading, error, data])
 ```
 
-## Modèles (Templates) {#templates}
+## Modèles {#templates}
 
-En haut, il est possible de choisir parmi différents modèles. À ce jour, vous pouvez utiliser une intégration Aave, Compound, UniSwap ou Sablier. Ces modèles ajoutent tous des adresses importantes de contrats intelligents de service ainsi que des intégrations pré-construites de subgraph. Il suffit d'ajouter le modèle à la commande de création comme `yarn create eth-app my-eth-app --with-template aav`.
+En plus, vous pouvez choisir parmi plusieurs modèles différents. Pour l'instant, vous pouvez utiliser une intégration Aave, Compound, Uniswap ou Sablier. Ces modèles ajoutent tous des adresses importantes de contrats intelligents de service ainsi que des intégrations pré-construites de subgraph. Il suffit d'ajouter le modèle à la commande de création, comme `yarn create eth-app my-eth-app --with-template aave`.
 
 ### Aave {#aave}
 
-[Aave](https://aave.com/) est un marché décentralisé de prêt d'argent. Les déposants fournissent des liquidités au marché pour gagner un revenu passif, tandis que les emprunteurs peuvent emprunter avec des garanties. Une fonctionnalité exclusive d'Aave réside dans ces [prêts flash](https://docs.aave.com/developers/guides/flash-loans) qui vous permettent d'emprunter de l'argent sans aucune garantie, pour autant que vous remboursiez le prêt en une seule transaction. Cela peut être utile par exemple pour vous donner de l'argent supplémentaire sur l'arbitrage d'échange.
+[Aave](https://aave.com/) est un marché de prêt d'argent décentralisé. Les déposants fournissent des liquidités au marché pour gagner un revenu passif, tandis que les emprunteurs peuvent emprunter avec des garanties. Une caractéristique unique d'Aave sont les [prêts flash](https://aave.com/docs/developers/flash-loans) qui vous permettent d'emprunter de l'argent sans aucune garantie, tant que vous remboursez le prêt en une seule transaction. Cela peut être utile, par exemple, pour vous donner des liquidités supplémentaires pour du trading d'arbitrage.
 
 Les jetons échangés qui vous rapportent des intérêts sont appelés _aTokens_.
 
-Si vous choisissez d'intégrer Aave avec _create-eth-app_, vous obtiendrez une [intégration subgraph](https://docs.aave.com/developers/getting-started/using-graphql). Aave utilise The Graph et vous fournit déjà plusieurs Subgraphs prêts à l'emploi sur [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) et [le réseau principal](https://thegraph.com/explorer/subgraph/aave/protocol) en formulaire [brut](https://thegraph.com/explorer/subgraph/aave/protocol-raw) ou [formaté](https://thegraph.com/explorer/subgraph/aave/protocol).
+Lorsque vous choisissez d'intégrer Aave avec _create-eth-app_, vous obtiendrez une [intégration de subgraph](https://docs.aave.com/developers/getting-started/using-graphql). Aave utilise The Graph et vous fournit déjà plusieurs subgraphs prêts à l'emploi sur [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) et [Mainnet](https://thegraph.com/explorer/subgraph/aave/protocol) sous forme [brute](https://thegraph.com/explorer/subgraph/aave/protocol-raw) ou [formatée](https://thegraph.com/explorer/subgraph/aave/protocol).
 
-![Aave Flash Loan meme - "Ouah, si je pouvais garder mon prêt flash plus longtemps qu'une transaction, ce serait génial" ;](./flashloan-meme.png)
+![Mème sur les prêts flash d'Aave – « Ouais, si je pouvais garder mon prêt flash plus d'une transaction, ce serait génial »](./flashloan-meme.png)
 
 ### Compound {#compound}
 
-[Compound](https://compound.finance/) est similaire à Aave. L'intégration inclut déjà le nouveau [Compound v2 Subgraph](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195). Les intérêts gagnés des jetons sont ici étonnamment appelés _cTokens_.
+[Compound](https://compound.finance/) est similaire à Aave. L'intégration inclut déjà le nouveau [subgraph Compound v2](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094595). De manière surprenante, les jetons qui rapportent des intérêts sont ici appelés _cTokens_.
 
 ### Uniswap {#uniswap}
 
-[Uniswap](https://uniswap.exchange/) est un système d'échange décentralisé (DEX). Les fournisseurs de liquidités peuvent percevoir des commissions en fournissant les jetons ou l'éther requis pour les deux parties d'une transaction. Le protocole est largement utilisé et dispose donc de liquidités très nombreuses pour une très large gamme de jetons. Vous pouvez facilement l'intégrer dans votre dApp pour permettre, par exemple, aux utilisateurs d'échanger leur ETH contre du DAI.
+[Uniswap](https://uniswap.exchange/) est une plateforme d'échange décentralisée (DEX). Les fournisseurs de liquidités peuvent percevoir des commissions en fournissant les jetons ou l'éther requis pour les deux parties d'une transaction. Il est largement utilisé et dispose donc de l'une des plus grandes liquidités pour une très large gamme de jetons. Vous pouvez facilement l'intégrer dans votre dapp pour, par exemple, permettre aux utilisateurs d'échanger leurs ETH contre des DAI.
 
-Malheureusement, à l'heure où ces lignes sont écrites, l'intégration est uniquement proposée pour Uniswap v1 et non pour la toute nouvelle version [v2](https://uniswap.org/blog/uniswap-v2/).
+Malheureusement, au moment de la rédaction, l'intégration n'est disponible que pour Uniswap v1 et non pour la [v2 qui vient de sortir](https://uniswap.org/blog/uniswap-v2/).
 
 ### Sablier {#sablier}
 
-[Sablier](https://sablier.com/) permet aux utilisateurs d'effectuer des paiements en continu. Au lieu d'un seul versement, vous recevez en fait votre argent en continu sans avoir rien d'autre à faire après la mise en place initiale. L'intégration inclut son [propre sous-graphe](https://thegraph.com/explorer/subgraph/sablierhq/sablier).
+[Sablier](https://sablier.com/) permet aux utilisateurs d'effectuer des paiements d'argent en continu. Au lieu d'un seul versement, vous recevez en fait votre argent en continu sans avoir rien d'autre à faire après la mise en place initiale. L'intégration inclut son [propre subgraph](https://thegraph.com/explorer/subgraph/sablierhq/sablier).
 
 ## Et après ? {#whats-next}
 
-Si vous avez des questions sur _create-eth-app_, allez sur le [serveur de la Communauté Sablier](https://discord.gg/bsS8T47), où vous pouvez entrer en contact avec les auteurs de _create-eth-app_. Dans un premier temps, vous pourriez vouloir intégrer un framework d'interface utilisateur comme [Material UI](https://material-ui.com/), écrire des requêtes GraphQL pour les données dont vous avez réellement besoin et configurer le déploiement.
+Si vous avez des questions sur _create-eth-app_, rendez-vous sur le [serveur communautaire de Sablier](https://discord.gg/bsS8T47), où vous pourrez contacter les auteurs de _create-eth-app_. Comme premières étapes, vous pourriez vouloir intégrer un framework d'interface utilisateur comme [Material UI](https://mui.com/material-ui/), écrire des requêtes GraphQL pour les données dont vous avez réellement besoin et configurer le déploiement.
diff --git a/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md b/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md
index 38b110610f2..2b534b86cb5 100644
--- a/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md
+++ b/public/content/translations/fr/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md
@@ -1,6 +1,6 @@
 ---
-title: Démarrer le développement de votre interface dApp avec create-eth-app
-description: Aperçu de l'utilisation de create-eth-app et de ses fonctionnalités
+title: "Démarrer le développement de votre interface dApp avec create-eth-app"
+description: "Aperçu de l'utilisation de create-eth-app et de ses fonctionnalités"
 author: "Markus Waas"
 tags:
   - "create-eth-app"
diff --git a/public/content/translations/fr/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md b/public/content/translations/fr/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
index e7cad8f1608..0518d560e8a 100644
--- a/public/content/translations/fr/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
+++ b/public/content/translations/fr/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
@@ -1,11 +1,8 @@
 ---
 title: Apprendre les sujets fondamentaux d'Ethereum avec SQL
-description: Ce tutoriel a pour objectif d'aider les lecteurs à comprendre les concepts fondamentaux d'Ethereum, y compris les transactions, les blocs et le gaz en interrogeant les données sur chaîne avec le Langage de Requête Structurée (SQL).
+description: "Ce tutoriel aide les lecteurs à comprendre les concepts fondamentaux d'Ethereum, notamment les transactions, les blocs et le gaz, en interrogeant les données sur la chaîne avec le langage de requête structuré (SQL)."
 author: "Paul Apivat"
-tags:
-  - "SQL"
-  - "Requêtes"
-  - "Transactions"
+tags: [ "SQL", "Requêtes", "Transactions" ]
 skill: beginner
 lang: fr
 published: 2021-05-11
@@ -13,27 +10,27 @@ source: paulapivat.com
 sourceUrl: https://paulapivat.com/post/query_ethereum/
 ---
 
-De nombreux tutoriels Ethereum ciblent les développeurs, mais il existe un manque de ressources éducatives pour les analystes de données ou pour les personnes qui souhaitent voir des données en chaîne sans faire tourner un client ou un nœud.
+De nombreux tutoriels Ethereum s'adressent aux développeurs, mais il y a un manque de ressources éducatives pour les analystes de données ou pour les personnes qui souhaitent consulter les données sur la chaîne sans exécuter un client ou un nœud.
 
-Ce tutoriel a pour objectif d'aider les lecteurs à comprendre les concepts fondamentaux d'Ethereum, y compris les transactions, les blocs et la notion de gaz en interrogeant les données en chaîne avec un langage SQL via une interface fournie par [Dune Analytics](https://dune.xyz/home).
+Ce tutoriel aide les lecteurs à comprendre les concepts fondamentaux d'Ethereum, notamment les transactions, les blocs et le gaz, en interrogeant les données sur la chaîne avec le langage de requête structuré (SQL) via une interface fournie par [Dune Analytics](https://dune.com/).
 
-Les données en chaîne (On-chain) peuvent nous aider à comprendre Ethereum, le réseau, permettre des économies de puissance informatique et devrait servir de base à la compréhension des défis auxquels Ethereum est confronté aujourd'hui (par exemple : la hausse des prix du gaz) et, plus important encore, avoir des discussions sur les solutions évolutives.
+Les données sur la chaîne peuvent nous aider à comprendre Ethereum, le réseau, et son rôle en tant qu'économie pour la puissance de calcul. Elles devraient servir de base à la compréhension des défis auxquels Ethereum est confronté aujourd'hui (par exemple, la hausse des prix du gaz) et, plus important encore, aux discussions sur les solutions de mise à l'échelle.
 
 ### Transactions {#transactions}
 
-Le voyage d'un utilisateur sur Ethereum débute par l'initialisation d'un compte utilisateur contrôlé ou d'une entité avec un solde ETH. Il existe deux types de comptes - contrôlé par l'utilisateur ou un contrat intelligent (voir [ethereum.org](/developers/docs/accounts/)).
+Le parcours d'un utilisateur sur Ethereum commence par l'initialisation d'un compte contrôlé par l'utilisateur ou d'une entité disposant d'un solde en ETH. Il existe deux types de comptes : les comptes contrôlés par l'utilisateur ou les contrats intelligents (voir [ethereum.org](/developers/docs/accounts/)).
 
-N'importe quel compte peut être consulté sur un explorateur de blocs comme [Etherscan](https://etherscan.io/). Les explorateurs de blocs sont votre portail vers les données Ethereum. Ils affichent, en temps réel, des données sur les blocs, les transactions, les mineurs, les comptes et autres activités en chaîne (voir [ici](/developers/docs/data-and-analytics/block-explorers/)).
+N'importe quel compte peut être consulté sur un explorateur de blocs comme [Etherscan](https://etherscan.io/) ou [Blockscout](https://eth.blockscout.com/). Les explorateurs de blocs sont un portail vers les données d'Ethereum. Ils affichent, en temps réel, les données sur les blocs, les transactions, les mineurs, les comptes et autres activités sur la chaîne (voir [ici](/developers/docs/data-and-analytics/block-explorers/)).
 
-Cependant, un utilisateur peut vouloir interroger directement les données pour reconsidérer les informations fournies par les explorateurs de blocs externes. [Dune Analytics](https://duneanalytics.com/) fournit cette capacité à quiconque ayant une certaine connaissance de SQL.
+Cependant, un utilisateur peut souhaiter interroger directement les données pour les rapprocher des informations fournies par des explorateurs de blocs externes. [Dune Analytics](https://dune.com/) offre cette possibilité à toute personne ayant quelques connaissances en SQL.
 
-Pour référence, le compte du contrat intelligent de la Fondation Ethereum (EF) peut être consulté sur [Etherscan](https://etherscan.io/address/0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae).
+À titre de référence, le compte de contrat intelligent de l'Ethereum Foundation (EF) peut être consulté sur [Blockscout](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe).
 
-Une chose à noter est que tous les comptes, y compris ceux de la Fondation Ethereum, disposent d'une adresse publique qui peut être utilisée pour envoyer et recevoir des transactions.
+Il est à noter que tous les comptes, y compris celui de l'EF, possèdent une adresse publique qui peut être utilisée pour envoyer et recevoir des transactions.
 
-Le solde du compte Etherscan comprend des transactions régulières et des transactions internes. Les transactions internes, malgré le nom, ne sont pas des transactions _réelles_ qui modifient l'état de la chaîne. Ce sont des transferts de valeur initiés par l'exécution d'un contrat ([source](https://ethereum.stackexchange.com/questions/3417/how-to-get-contract-internal-transactions)). Étant donné que les transactions internes n'ont pas de signature, elles ne sont **PAS** incluses sur la blockchain et ne peuvent pas être interrogées avec Dune Analytics.
+Le solde du compte sur Etherscan comprend des transactions ordinaires et des transactions internes. Les transactions internes, malgré leur nom, ne sont pas des transactions _réelles_ qui modifient l'état de la chaîne. Ce sont des transferts de valeur initiés par l'exécution d'un contrat ([source](https://ethereum.stackexchange.com/questions/3417/how-to-get-contract-internal-transactions)). Puisque les transactions internes n'ont pas de signature, elles ne sont **pas** incluses sur la blockchain et ne peuvent pas être interrogées avec Dune Analytics.
 
-Ainsi, ce tutoriel se concentrera sur les transactions dites régulières. Elles peuvent être questionnées ainsi :
+Par conséquent, ce tutoriel se concentrera sur les transactions ordinaires. Elles peuvent être interrogées comme suit :
 
 ```sql
 WITH temp_table AS (
@@ -61,33 +58,33 @@ SELECT
 FROM temp_table
 ```
 
-Cela donnera les mêmes informations que celles fournies sur la page de transaction Etherscan. À titre de comparaison, voici les deux sources :
+Cela produira les mêmes informations que celles fournies sur la page des transactions d'Etherscan. À titre de comparaison, voici les deux sources :
 
 #### Etherscan {#etherscan}
 
 ![](./etherscan_view.png)
 
-[La page du contrat de la Fondation Ethereum sur Etherscan.](https://etherscan.io/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)
+[Page du contrat de l'EF sur Blockscout.](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)
 
 #### Dune Analytics {#dune-analytics}
 
 ![](./dune_view.png)
 
-Vous pouvez trouver le tableau de bord [ici](https://duneanalytics.com/paulapivat/Learn-Ethereum). Cliquez sur la table pour voir la requête (voir aussi ci-dessus).
+Vous pouvez trouver le tableau de bord [ici](https://dune.com/paulapivat/Learn-Ethereum). Cliquez sur le tableau pour voir la requête (également visible ci-dessus).
 
-### Décortiquer les transactions {#breaking_down_transactions}
+### Analyse détaillée des transactions {#breaking_down_transactions}
 
-Une transaction soumise comprend plusieurs informations dont ([source](/developers/docs/transactions/) ) :
+Une transaction soumise comprend plusieurs informations, notamment ([source](/developers/docs/transactions/)) :
 
-- **Recipient** : (destinataire) l'adresse de réception (requête « to »)
-- **Signature** : Alors que la clé privée d'un expéditeur signe une transaction, ce que nous pouvons demander avec SQL est l'adresse publique de l'expéditeur (« from »).
-- **Value** : (valeur) Il s'agit du montant d'ETH transféré (voir colonne `ether`).
-- **Data** : (données) il s'agit de données arbitraires qui ont été hachées (voir colonne `data`).
-- **gasLimit** : Quantité maximum d’unités de gaz pouvant être consommée par la transaction. Les unités de gaz représentent les étapes de calcul.
-- **maxPriorityFeePerGas** : la quantité maximale de gaz à inclure comme un pourboire pour le mineur.
-- **maxFeePerGas** - le montant maximum de gaz prêt à être payé pour la transaction (incluant baseFeePerGas et maxPriorityFeePerGas)
+- **Destinataire** : l'adresse de réception (interrogée en tant que "to")
+- **Signature** : bien que la clé privée d'un expéditeur signe une transaction, ce que nous pouvons interroger avec SQL est l'adresse publique d'un expéditeur ("from").
+- **Valeur** : il s'agit du montant d'ETH transféré (voir la colonne `ether`).
+- **Données** : il s'agit de données arbitraires qui ont été hachées (voir la colonne `data`)
+- **gasLimit** – la quantité maximale d'unités de gaz qui peut être consommée par la transaction. Les unités de gaz représentent des étapes de calcul
+- **maxPriorityFeePerGas** - le montant maximum de gaz à inclure comme pourboire pour le mineur
+- **maxFeePerGas** - le montant maximum de gaz que l'on est prêt à payer pour la transaction (y compris `baseFeePerGas` et `maxPriorityFeePerGas`)
 
-Nous pouvons interroger ces informations spécifiques pour les transactions à l'adresse publique de la Fondation Ethereum :
+Nous pouvons interroger ces informations spécifiques pour les transactions vers l'adresse publique de l'Ethereum Foundation :
 
 ```sql
 SELECT
@@ -104,17 +101,17 @@ WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
 ORDER BY block_time DESC
 ```
 
-### Les blocs {#blocks}
+### Blocs {#blocks}
 
-Chaque transaction va changer l'état de la machine virtuelle Ethereum ([EVM](/developers/docs/evm/)) ([source](/developers/docs/transactions/)). Les transactions sont diffusées sur le réseau pour être vérifiées et incluses dans un bloc. Chaque transaction est associée à un numéro de bloc. Pour consulter les données, nous pourrions interroger un numéro de bloc spécifique : 12396854 (le bloc le plus récent parmi les transactions de la Fondation Ethereum à ce jour, 11/05/21).
+Chaque transaction modifiera l'état de la machine virtuelle Ethereum ([EVM](/developers/docs/evm/)) ([source](/developers/docs/transactions/)). Les transactions sont diffusées sur le réseau pour être vérifiées et incluses dans un bloc. Chaque transaction est associée à un numéro de bloc. Pour voir les données, nous pourrions interroger un numéro de bloc spécifique : 12396854 (le bloc le plus récent parmi les transactions de l'Ethereum Foundation au moment de la rédaction de cet article, 11/5/21).
 
-De plus, lorsque nous interrogeons les deux blocs suivants, nous pouvons constater que chaque bloc contient le hachage du bloc précédent (c.-à-d. parent hash), illustrant la façon dont la blockchain est formée.
+De plus, lorsque nous interrogeons les deux blocs suivants, nous pouvons voir que chaque bloc contient le hachage du bloc précédent (c'est-à-dire le hachage parent), ce qui illustre la façon dont la blockchain est formée.
 
-Chaque bloc contient une référence vers le bloc parent. Ceci est affiché ci-dessous entre les colonnes `hash` et `parent_hash` ([source](/developers/docs/blocks/) ) :
+Chaque bloc contient une référence à son bloc parent. Ceci est illustré ci-dessous entre les colonnes `hash` et `parent_hash` ([source](/developers/docs/blocks/)) :
 
 ![parent_hash](./parent_hash.png)
 
-Voici la [requête](https://duneanalytics.com/queries/44856/88292) sur Dune Analytics :
+Voici la [requête](https://dune.com/queries/44856/88292) sur Dune Analytics :
 
 ```sql
 SELECT
@@ -128,18 +125,18 @@ WHERE "number" = 12396854 OR "number" = 12396855 OR "number" = 12396856
 LIMIT 10
 ```
 
-Nous pouvons examiner un bloc en interrogeant le temps, le numéro de bloc, la difficulté, l'empreinte numérique, le hachage parent et le nonce.
+Nous pouvons examiner un bloc en interrogeant l'heure, le numéro de bloc, la difficulté, le hachage, le hachage parent et le nonce.
 
-La seule chose que cette requête ne couvre pas est _la liste de transactions_ qui nécessite une requête séparée ci-dessous et la _racine d'état_. Un nœud complet ou archivé stockera toutes les transactions et transitions d'état, permettant aux clients d'interroger l'état de la chaîne à tout moment. Parce que cela nécessite un grand espace de stockage, nous pouvons séparer les données de la chaîne des données d'état :
+La seule chose que cette requête ne couvre pas est la _liste des transactions_, qui nécessite une requête distincte ci-dessous, et la _racine d'état_. Un nœud complet ou d'archivage stockera toutes les transactions et les transitions d'état, ce qui permettra aux clients d'interroger l'état de la chaîne à tout moment. Comme cela nécessite un grand espace de stockage, nous pouvons séparer les données de la chaîne des données d'état :
 
-- Données de chaîne (liste des blocs, transactions)
-- Données d'état (résultat de la transition d'état pour chaque transaction)
+- Données de la chaîne (liste des blocs, transactions)
+- Données d'état (résultat de la transition d'état de chaque transaction)
 
-La racine d'état tombe dans cette dernière et sont des données _implicites_ (non stockées sur la chaîne), alors que les données en chaîne sont explicites et stockées sur la chaîne elle-même ([source](https://ethereum.stackexchange.com/questions/359/where-is-the-state-data-stored)).
+La racine d'état entre dans cette dernière catégorie et correspond à des données _implicites_ (non stockées sur la chaîne), tandis que les données de la chaîne sont explicites et stockées sur la chaîne elle-même ([source](https://ethereum.stackexchange.com/questions/359/where-is-the-state-data-stored)).
 
-Pour ce tutoriel, nous nous concentrerons sur les données en chaîne que l'on _peut_ interroger avec SQL via Dune Analytics.
+Pour ce tutoriel, nous nous concentrerons sur les données sur la chaîne qui _peuvent_ être interrogées avec SQL via Dune Analytics.
 
-Comme indiqué ci-dessus, chaque bloc contient une liste de transactions, nous pouvons les consulter en filtrant un bloc spécifique. Nous allons essayer le bloc le plus récent, 12396854 :
+Comme indiqué ci-dessus, chaque bloc contient une liste de transactions. Nous pouvons l'interroger en filtrant sur un bloc spécifique. Essayons avec le bloc le plus récent, 12396854 :
 
 ```sql
 SELECT * FROM ethereum."transactions"
@@ -147,13 +144,13 @@ WHERE block_number = 12396854
 ORDER BY block_time DESC`
 ```
 
-Voici la sortie SQL sur Dune :
+Voici le résultat SQL sur Dune :
 
 ![](./list_of_txn.png)
 
-Cet unique bloc étant ajouté à la chaîne change l'état de la Machine Virtuelle Ethereum ([EVM](/developers/docs/evm/)). Des dizaines de fois, des centaines de transactions sont vérifiées en même temps. Dans ce cas précis, 222 transactions ont été incluses.
+L'ajout de ce seul bloc à la chaîne modifie l'état de la machine virtuelle Ethereum ([EVM](/developers/docs/evm/)). Des dizaines, parfois des centaines de transactions sont vérifiées en une seule fois. Dans ce cas précis, 222 transactions ont été incluses.
 
-Pour voir combien de transactions ont réellement réussi, nous ajoutons un autre filtre pour compter les transactions réussies :
+Pour voir combien d'entre elles ont effectivement abouti, nous ajoutons un autre filtre pour compter les transactions réussies :
 
 ```sql
 WITH temp_table AS (
@@ -170,22 +167,22 @@ Pour le bloc 12396854, sur un total de 222 transactions, 204 ont été vérifié
 
 ![](./successful_txn.png)
 
-Les requêtes de transactions se produisent des dizaines de fois par seconde, mais les blocs sont produits environ une fois toutes les 15 secondes ([source](/developers/docs/blocks/)).
+Les demandes de transaction se produisent des dizaines de fois par seconde, mais les blocs sont validés environ une fois toutes les 15 secondes ([source](/developers/docs/blocks/)).
 
-Pour voir qu'un bloc est produit environ toutes les 15 secondes, nous pourrions prendre le nombre de secondes dans un jour (86400) divisé par 15 pour obtenir une estimation moyenne de blocs par jour (~ 5760).
+Pour voir qu'un bloc est produit environ toutes les 15 secondes, nous pourrions prendre le nombre de secondes dans une journée (86 400) et le diviser par 15 pour obtenir une estimation du nombre moyen de blocs par jour (~ 5 760).
 
-Le graphique des blocs Ethereum produits par jour (en 2016) est :
+Le graphique des blocs Ethereum produits par jour (de 2016 à aujourd'hui) est le suivant :
 
 ![](./daily_blocks.png)
 
-Le nombre moyen de blocs produits quotidiennement au cours de cette période est de ~5 874 :
+Le nombre moyen de blocs produits quotidiennement au cours de cette période est d'environ 5 874 :
 
 ![](./avg_daily_blocks.png)
 
-Les requêtes sont :
+Les requêtes sont :
 
 ```sql
-# query to visualize number of blocks produced daily since 2016
+# requête pour visualiser le nombre de blocs produits quotidiennement depuis 2016
 
 SELECT
     DATE_TRUNC('day', time) AS dt,
@@ -194,7 +191,7 @@ FROM ethereum."blocks"
 GROUP BY dt
 OFFSET 1
 
-# average number of blocks produced per day
+# nombre moyen de blocs produits par jour
 
 WITH temp_table AS (
 SELECT
@@ -209,13 +206,13 @@ SELECT
 FROM temp_table
 ```
 
-Le nombre moyen de blocs produits par jour depuis 2016 est légèrement supérieur à ce nombrede 5 874. Alternativement, diviser 86 400 secondes par 5 874 blocs en moyenne donne 14,7 secondes, soit environ un bloc toutes les 15 secondes.
+Le nombre moyen de blocs produits par jour depuis 2016 est légèrement supérieur à ce chiffre, à 5 874. Alternativement, en divisant 86 400 secondes par 5 874 blocs en moyenne, on obtient 14,7 secondes, soit environ un bloc toutes les 15 secondes.
 
 ### Gaz {#gas}
 
-Les blocs sont limités en taille. La taille maximale de bloc est dynamique et varie en fonction de la demande sur le réseau, entre 12 500 000 et 25 000 000 d'unités. Des limites sont requises pour éviter que des blocs de taille arbitraire puissent déformer des nœuds complets en termes d'espace disque et de vitesse requise ([source](/developers/docs/blocks/)).
+La taille des blocs est limitée. La taille maximale d'un bloc est dynamique et varie en fonction de la demande du réseau entre 12 500 000 et 25 000 000 d'unités. Des limites sont nécessaires pour empêcher que des blocs de taille arbitrairement grande ne surchargent les nœuds complets en termes d'espace disque et de vitesse ([source](/developers/docs/blocks/)).
 
-Une façon de conceptualiser la limite de gaz par bloc est de la considérer comme l'**approvisionnement** de l'espace disponible d'un bloc dans lequel réaliser les transactions par lots. La limite de gaz du bloc peut être consultée et visualisée de 2016 à nos jours :
+Une façon de conceptualiser la limite de gaz par bloc est de la considérer comme l'**offre** d'espace de bloc disponible pour regrouper les transactions. La limite de gaz par bloc peut être interrogée et visualisée de 2016 à aujourd'hui :
 
 ![](./avg_gas_limit.png)
 
@@ -228,7 +225,7 @@ GROUP BY dt
 OFFSET 1
 ```
 
-Ensuite, il existe le gaz réellement utilisé quotidiennement pour payer les calculs effectués sur la chaîne Ethereum (par exemple en envoyant une transaction, en appelant un contrat intelligent, en frappant un NFT). Ceci est la **demande** pour l'espace disponible de bloc Ethereum :
+Ensuite, il y a le gaz réellement utilisé quotidiennement pour payer les calculs effectués sur la chaîne Ethereum (par exemple, envoyer une transaction, appeler un contrat intelligent, frapper un NFT). C'est la **demande** pour l'espace de bloc Ethereum disponible :
 
 ![](./daily_gas_used.png)
 
@@ -241,17 +238,17 @@ GROUP BY dt
 OFFSET 1
 ```
 
-Nous pouvons également juxtaposer ces deux graphiques pour voir comment la ligne **demand and supply** se présente :
+Nous pouvons également juxtaposer ces deux graphiques pour voir comment l'**offre et la demande** s'alignent :
 
 ![gas_demand_supply](./gas_demand_supply.png)
 
-Par conséquent, nous pouvons comprendre les prix du gaz en fonction de la demande en blocs Ethereum, au regard de l'offre disponible.
+Par conséquent, nous pouvons comprendre les prix du gaz comme une fonction de la demande d'espace de bloc sur Ethereum, compte tenu de l'offre disponible.
 
-Enfin, nous pourrions vouloir interroger les prix quotidiens moyens du gaz sur la chaîne Ethereum. Cela entraînera un temps de requête particulièrement long. Nous filtrerons donc notre requête sur le montant moyen de gaz payé par la Fondation Ethereum.
+Enfin, nous pourrions vouloir interroger les prix moyens quotidiens du gaz pour la chaîne Ethereum. Cependant, cela entraînerait un temps de requête particulièrement long, nous allons donc filtrer notre requête sur le montant moyen de gaz payé par transaction par l'Ethereum Foundation.
 
 ![](./ef_daily_gas.png)
 
-Nous pouvons voir les prix de gaz payés au fil des années pour les transactions à l'adresse de la Fondation Ethereum. Voici la requête :
+Nous pouvons voir les prix du gaz payés pour toutes les transactions effectuées vers l'adresse de l'Ethereum Foundation au fil des ans. Voici la requête :
 
 ```sql
 SELECT
@@ -265,8 +262,8 @@ ORDER BY block_time DESC
 
 ### Résumé {#summary}
 
-Avec ce tutoriel, nous comprenons les concepts fondateurs d'Ethereum et comment fonctionne la blockchain d'Ethereum en interrogeant et en se donnant une idée des données en chaîne.
+Grâce à ce tutoriel, nous avons compris les concepts fondamentaux d'Ethereum et le fonctionnement de la blockchain Ethereum en interrogeant les données sur la chaîne et en nous familiarisant avec elles.
 
-Le tableau de bord qui contient tout le code utilisé dans ce tutoriel peut être trouvé [ici](https://duneanalytics.com/paulapivat/Learn-Ethereum).
+Le tableau de bord qui contient tout le code utilisé dans ce tutoriel peut être trouvé [ici](https://dune.com/paulapivat/Learn-Ethereum).
 
-Pour une plus grande utilisation des données à des fins d'analyse de web3 [vous pouvez me retrouver sur Twitter](https://twitter.com/paulapivat).
+Pour plus d'utilisation des données pour explorer le web3, [retrouvez-moi sur Twitter](https://twitter.com/paulapivat).
diff --git a/public/content/translations/fr/developers/tutorials/logging-events-smart-contracts/index.md b/public/content/translations/fr/developers/tutorials/logging-events-smart-contracts/index.md
index 6f8a89afd02..34c0e3f7764 100644
--- a/public/content/translations/fr/developers/tutorials/logging-events-smart-contracts/index.md
+++ b/public/content/translations/fr/developers/tutorials/logging-events-smart-contracts/index.md
@@ -1,12 +1,14 @@
 ---
-title: Consigner les données des contrats intelligents avec des événements
-description: Introduction aux événements de contrats intelligents et manière dont vous pouvez les utiliser pour enregistrer les données
+title: "Consigner les données des contrats intelligents avec des événements"
+description: "Une introduction aux événements de contrat intelligent et comment les utiliser pour consigner des données."
 author: "jdourlens"
 tags:
-  - "contrats intelligents"
-  - "remix"
-  - "solidity"
-  - "événements"
+  [
+    "contrats intelligents",
+    "Remix",
+    "Solidity",
+    "événements"
+  ]
 skill: intermediate
 lang: fr
 published: 2020-04-03
@@ -15,19 +17,19 @@ sourceUrl: https://ethereumdev.io/logging-data-with-events/
 address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 ---
 
-Dans Solidity, [les événements](/developers/docs/smart-contracts/anatomy/#events-and-logs) envoient des signaux que les contrats intelligents peuvent lancer. Les dApps, ou tout autre élément connecté à l'API Ethereum JSON-RPC, peuvent écouter ces événements et agir en conséquence. Un événement peut également être indexé de sorte que son historique soit consultable ultérieurement.
+En Solidity, les [événements](/developers/docs/smart-contracts/anatomy/#events-and-logs) sont des signaux que les contrats intelligents peuvent émettre. Les dapps, ou tout ce qui est connecté à l'API JSON-RPC d'Ethereum, peuvent écouter ces événements et agir en conséquence. Un événement peut également être indexé de sorte que son historique soit consultable ultérieurement.
 
-## Évènements {#events}
+## Événements {#events}
 
-L'événement le plus courant sur la blockchain Ethereum au moment de l'écriture de cet article est l'événement de 'Transfer' qui est émis par les jetons ERC20 lorsque quelqu'un transfère des jetons.
+L'événement le plus courant sur la blockchain Ethereum au moment de la rédaction de cet article est l'événement Transfer, qui est émis par les jetons ERC20 lorsque quelqu'un transfère des jetons.
 
 ```solidity
 event Transfer(address indexed from, address indexed to, uint256 value);
 ```
 
-La signature de l'événement est déclarée à l'intérieur du code du contrat et peut être émise avec le mot clé 'emit'. Par exemple, l'évènement 'transfert' enregistre qui a initié le transfert (_à partir de_), à qui (_à_) et combien de jetons ont été transférés (_valeur_).
+La signature de l'événement est déclarée dans le code du contrat et peut être émise avec le mot-clé « emit ». Par exemple, l'événement de transfert enregistre qui a envoyé le transfert (_from_), à qui (_to_) et combien de jetons ont été transférés (_value_).
 
-Si nous revenons à notre contrat intelligent Counter et décidons de procéder à un enregistrement chaque fois que la valeur est modifiée. Comme il n’est pas destiné à être déployé, ce contrat sert de base à la construction d’un autre contrat en l'étendant : cela s’appelle un contrat abstrait. Dans le cas de notre exemple de compteur, cela ressemblerait à ceci :
+Si nous revenons à notre contrat intelligent Counter et décidons de consigner chaque fois que la valeur est modifiée. Comme ce contrat n'est pas destiné à être déployé mais à servir de base à la construction d'un autre contrat en l'étendant : on l'appelle un contrat abstrait. Dans le cas de notre exemple de compteur, cela ressemblerait à ceci :
 
 ```solidity
 pragma solidity 0.5.17;
@@ -36,16 +38,16 @@ contract Counter {
 
     event ValueChanged(uint oldValue, uint256 newValue);
 
-    // Private variable of type unsigned int to keep the number of counts
+    // Variable privée de type entier non signé pour conserver le nombre de comptages
     uint256 private count = 0;
 
-    // Function that increments our counter
+    // Fonction qui incrémente notre compteur
     function increment() public {
         count += 1;
         emit ValueChanged(count - 1, count);
     }
 
-    // Getter to get the count value
+    // Getter pour obtenir la valeur du compteur
     function getCount() public view returns (uint256) {
         return count;
     }
@@ -53,14 +55,14 @@ contract Counter {
 }
 ```
 
-Notez que :
+Notez que :
 
-- **Ligne 5**: nous déclarons notre événement et ce qu'il contient, l'ancienne valeur et la nouvelle valeur.
+- **Ligne 5** : nous déclarons notre événement et ce qu'il contient, l'ancienne valeur et la nouvelle valeur.
 
-- **Ligne 13** : Lorsque nous incrémentons notre variable de nombre, nous émettons l'événement.
+- **Ligne 13** : Lorsque nous incrémentons notre variable de comptage, nous émettons l'événement.
 
-Si nous déployons maintenant le contrat et appelons la fonction d'incrémentation, nous verrons que Remix l'affichera automatiquement si vous cliquez sur la nouvelle transaction dans un tableau nommé logs.
+Si nous déployons maintenant le contrat et appelons la fonction d'incrémentation, nous verrons que Remix l'affichera automatiquement si vous cliquez sur la nouvelle transaction dans un tableau nommé « logs ».
 
-![Remixer une capture d'écran](./remix-screenshot.png)
+![Capture d'écran de Remix](./remix-screenshot.png)
 
-Les journaux sont vraiment utiles pour déboguer vos contrats intelligents, mais ils sont également importants si vous construisez des applications utilisées par différentes personnes et facilitent les analyses du suivi et de la compréhension de l'utilisation de votre contrat intelligent. Les journaux générés par les transactions sont affichés dans les explorateurs de blocs populaires et vous pouvez également les utiliser par exemple pour créer des scripts hors chaîne pour surveiller des événements spécifiques et prendre des mesures lorsqu'ils se produisent.
+Les journaux sont très utiles pour déboguer vos contrats intelligents, mais ils sont aussi importants si vous créez des applications utilisées par différentes personnes, car ils facilitent l'analyse pour suivre et comprendre comment votre contrat intelligent est utilisé. Les journaux générés par les transactions sont affichés dans les explorateurs de blocs populaires et vous pouvez également, par exemple, les utiliser pour créer des scripts hors chaîne pour surveiller des événements spécifiques et prendre des mesures lorsqu'ils se produisent.
diff --git a/public/content/translations/fr/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/fr/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
index 0da5ee8fa9f..69f47061cc4 100644
--- a/public/content/translations/fr/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
+++ b/public/content/translations/fr/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -1,9 +1,8 @@
 ---
-title: Preuves de Merkle relatives à l'intégrité des données hors ligne
-description: Assurer l'intégrité des données en chaîne pour les données stockées, principalement, hors chaîne
+title: "Preuves de Merkle relatives à l'intégrité des données hors ligne"
+description: "Assurer l'intégrité des données en chaîne pour les données qui sont stockées, principalement, hors chaîne"
 author: Ori Pomerantz
-tags:
-  - "stockage"
+tags: [ "stockage" ]
 skill: advanced
 lang: fr
 published: 2021-12-30
@@ -13,31 +12,31 @@ published: 2021-12-30
 
 Idéalement, nous souhaiterions tout conserver dans le stockage Ethereum, qui est lui-même stocké sur des milliers d'ordinateurs et bénéficie ainsi d'une disponibilité extrêmement élevée (les données ne peuvent pas être censurées) et d'une grande intégrité (les données ne peuvent pas être modifiées de manière non autorisée) sachant, cependant, que stocker un mot de 32 octets coûte normalement 20 000 gaz. Ce que je vais écrire ici aurait un coût équivalent à 6,60 $. À 21 cents par octet, c'est trop cher pour beaucoup d'utilisations.
 
-Pour résoudre ce problème, l'écosystème Ethereum a développé [de nombreuses façons alternatives de stocker des données d'une manière décentralisée](/developers/docs/storage/). Habituellement, elles impliquent un compromis entre disponibilité et prix. Toutefois, l’intégrité est généralement assurée.
+Pour résoudre ce problème, l'écosystème Ethereum a développé [de nombreuses façons alternatives de stocker des données de manière décentralisée](/developers/docs/storage/). Habituellement, elles impliquent un compromis entre disponibilité et prix. Toutefois, l’intégrité est généralement assurée.
 
-Dans cet article, vous apprendrez **comment** assurer l'intégrité des données sans avoir à les stocker sur la blockchain, en utilisant [les preuves de Merkle](https://computersciencewiki.org/index.php/Merkle_proof).
+Dans cet article, vous apprendrez **comment** garantir l'intégrité des données sans les stocker sur la blockchain, en utilisant les [preuves de Merkle](https://computersciencewiki.org/index.php/Merkle_proof).
 
 ## Comment ça marche ? {#how-does-it-work}
 
-En théorie, nous pourrions simplement stocker le hachage des données de la chaîne et envoyer toutes les données dans les transactions qui en ont besoin. Cependant, cela reste encore trop cher. Un octet de données lors d'une transaction a un coût d'environ 16 gaz, soit environ un demi-cent actuellement ou environ 5 $ par kilo-octets. À 5 000 $ le mégaoctet, c'est encore trop cher pour de nombreuses utilisations même sans le coût supplémentaire de hachage des données.
+En théorie, nous pourrions simplement stocker le hachage des données en chaîne, et envoyer toutes les données dans les transactions qui le requièrent. Cependant, cela reste encore trop cher. Un octet de données lors d'une transaction a un coût d'environ 16 gaz, soit environ un demi-cent actuellement ou environ 5 $ par kilo-octets. À 5 000 $ le mégaoctet, c'est encore trop cher pour de nombreuses utilisations même sans le coût supplémentaire de hachage des données.
 
 La solution est de hacher de façon répétée différents sous-ensembles de données. Pour les données que vous n'avez pas besoin d'envoyer, vous pouvez ainsi juste envoyer un hachage. Vous pouvez le faire en utilisant un arbre de Merkle, une structure de données en arborescence où chaque nœud est un hachage des nœuds en dessous :
 
 ![Arbre de Merkle](tree.png)
 
-Le hachage racine est la seule partie qui doit être stockée dans la chaîne. Pour prouver une certaine valeur, vous fournissez tous les hachages qui doivent être combinés avec elle pour obtenir la racine. Par exemple, pour prouver `C` vous fournissez `D`, `H(A-B)`, et `H(E-H)`.
+Le hachage racine est la seule partie qui doit être stockée en chaîne. Pour prouver une certaine valeur, vous fournissez tous les hachages qui doivent être combinés avec elle pour obtenir la racine. Par exemple, pour prouver `C`, vous fournissez `D`, `H(A-B)` et `H(E-H)`.
 
 ![Preuve de la valeur de C](proof-c.png)
 
 ## Implémentation {#implementation}
 
-[Le code échantillon est fourni ici](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity).
+[L'exemple de code est fourni ici](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity).
 
-### Code hors chaîne {#off-chain-code}
+### Code hors chaîne {#offchain-code}
 
 Dans cet article, nous utilisons JavaScript pour les calculs hors chaîne. La plupart des applications décentralisées ont leur composant hors chaîne en JavaScript.
 
-#### Création de la racine Merkle {#creating-the-merkle-root}
+#### Création de la racine de Merkle {#creating-the-merkle-root}
 
 Premièrement, nous devons apporter la racine Merkle à la chaîne.
 
@@ -45,19 +44,19 @@ Premièrement, nous devons apporter la racine Merkle à la chaîne.
 const ethers = require("ethers")
 ```
 
-[Nous utilisons la fonction de hachage du paquet ethers](https://docs.ethers.io/v5/api/utils/hashing/#utils-keccak256).
+[Nous utilisons la fonction de hachage du package ethers](https://docs.ethers.io/v5/api/utils/hashing/#utils-keccak256).
 
 ```javascript
-// The raw data whose integrity we have to verify. The first two bytes a
-// are a user identifier, and the last two bytes the amount of tokens the
-// user owns at present.
+// Les données brutes dont nous devons vérifier l'intégrité. Les deux premiers octets
+// sont un identifiant d'utilisateur, et les deux derniers octets le montant de jetons que
+// l'utilisateur possède actuellement.
 const dataArray = [
   0x0bad0010, 0x60a70020, 0xbeef0030, 0xdead0040, 0xca110050, 0x0e660060,
   0xface0070, 0xbad00080, 0x060d0091,
 ]
 ```
 
-Encoder chaque entrée sur un seul entier de 256 bits donne un code moins lisible que JSON, par exemple. Cependant, cela signifie un traitement beaucoup moins important pour récupérer les données contenues dans le contrat et ainsi, des frais de gaz moins élevés. [Vous pouvez lire le JSON sur la chaîne](https://github.com/chrisdotn/jsmnSol), c'est juste une mauvaise idée si celà peut-être évité.
+Encoder chaque entrée sur un seul entier de 256 bits donne un code moins lisible que JSON, par exemple. Cependant, cela signifie un traitement beaucoup moins important pour récupérer les données contenues dans le contrat et ainsi, des frais de gaz moins élevés. [Vous pouvez lire du JSON en chaîne](https://github.com/chrisdotn/jsmnSol), mais c'est une mauvaise idée si c'est évitable.
 
 ```javascript
 // The array of hash values, as BigInts
@@ -67,22 +66,26 @@ const hashArray = dataArray
 Dans notre cas et pour commencer, nos données ont une valeur de 256 bits. Ainsi, aucun traitement n'est nécessaire. Si nous utilisons une structure de données plus compliquée, comme des chaînes de caractères, nous devons nous assurer de d'abord hacher les données pour obtenir un tableau de hachages. Notez que c'est aussi parce que nous ne nous soucions pas de savoir que les utilisateurs connaissent les informations des autres utilisateurs. Sinon, nous aurions dû réaliser un hachage de sorte que l'utilisateur 1 ne connaisse pas la valeur pour l'utilisateur 0, que l'utilisateur 2 ne connaisse pas la valeur pour l'utilisateur 3, etc.
 
 ```javascript
-// Convert between the string the hash function expects and the
-// BigInt we use everywhere else.
+// Convertit entre la chaîne de caractères attendue par la fonction de hachage et le
+// BigInt que nous utilisons partout ailleurs.
 const hash = (x) =>
   BigInt(ethers.utils.keccak256("0x" + x.toString(16).padStart(64, 0)))
 ```
 
-La fonction de hachage des ethers s'attend à recevoir une chaîne JavaScript avec un nombre hexadécimal, tel que `0x60A7` et renvoie une autre chaîne de structure identique. Cependant, pour le reste du code, il est plus facile d'utiliser `BigInt` ainsi, nous convertissons en une chaîne hexadécimale et inversement.
+La fonction de hachage d'ethers s'attend à recevoir une chaîne de caractères JavaScript avec un nombre hexadécimal, tel que `0x60A7`, et répond avec une autre chaîne de caractères de même structure. Cependant, pour le reste du code, il est plus facile d'utiliser `BigInt`, nous convertissons donc en une chaîne hexadécimale et vice-versa.
 
 ```javascript
-// Symmetrical hash of a pair so we won't care if the order is reversed.
+// Hachage symétrique d'une paire pour que l'inversion de l'ordre n'ait pas d'importance.
 const pairHash = (a, b) => hash(hash(a) ^ hash(b))
 ```
 
-Cette fonction est symétrique (hachage d'un [xor](https://en.wikipedia.org/wiki/Exclusive_or) b). Cela signifie que lorsque nous vérifions la preuve de Merkle, nous n'avons pas à nous soucier de savoir s'il faut mettre la valeur de la preuve avant ou après la valeur calculée. C'est ainsi que l'on vérifie la preuve de Merkle, donc moins nous devons le faire, mieux ce sera.
+Cette fonction est symétrique (hachage de a [xor](https://en.wikipedia.org/wiki/Exclusive_or) b). Cela signifie que lorsque nous vérifions la preuve de Merkle, nous n'avons pas à nous soucier de savoir s'il faut mettre la valeur de la preuve avant ou après la valeur calculée. La vérification des preuves de Merkle se fait en chaîne, donc moins nous avons d'opérations à y effectuer, mieux c'est.
 
-Attention : La cryptographie est plus complexe qu'il n'y paraît. La version initiale de cet article avait la fonction de hachage `hash(a^b)`. C'était une **mauvaise** idée car cela signifiait que si vous connaissiez les valeurs légitimes de `a` et `b` vous pouviez utiliser `b' = a^b^a` pour prouver la valeur désirée `a'`. Avec cette fonction, vous devriez calculer `b'` de telle sorte que `hash(a') ^ hash(b')` soit égal à une valeur connue (la prochaine branche sur le chemin vers la racine), ce qui est beaucoup plus difficile.
+Attention :
+La cryptographie est plus complexe qu'il n'y paraît.
+La version initiale de cet article avait la fonction de hachage `hash(a^b)`.
+C'était une **mauvaise** idée car cela signifiait que si vous connaissiez les valeurs légitimes de `a` et `b`, vous pouviez utiliser `b' = a^b^a'` pour prouver n'importe quelle valeur `a'` désirée.
+Avec cette fonction, vous devriez calculer `b'` de telle sorte que `hash(a') ^ hash(b')` soit égal à une valeur connue (la branche suivante sur le chemin de la racine), ce qui est beaucoup plus difficile.
 
 ```javascript
 // The value to denote that a certain branch is empty, doesn't
@@ -92,14 +95,14 @@ const empty = 0n
 
 Lorsque le nombre de valeurs n'est pas un nombre entier à deux chiffres, nous devons gérer les branches vides. Pour ce faire, le programme va mettre un zéro à la place.
 
-![Arbre de Merkle avec branches manquantes](merkle-empty-hash.png)
+![Arbre de Merkle avec des branches manquantes](merkle-empty-hash.png)
 
 ```javascript
-// Calculate one level up the tree of a hash array by taking the hash of
-// each pair in sequence
+// Calcule un niveau supérieur de l'arbre d'un tableau de hachage en prenant le hachage de
+// chaque paire en séquence
 const oneLevelUp = (inputArray) => {
   var result = []
-  var inp = [...inputArray] // To avoid over writing the input // Add an empty value if necessary (we need all the leaves to be // paired)
+  var inp = [...inputArray] // Pour éviter d'écraser l'entrée // Ajoute une valeur vide si nécessaire (nous avons besoin que toutes les feuilles soient // appariées)
 
   if (inp.length % 2 === 1) inp.push(empty)
 
@@ -110,13 +113,13 @@ const oneLevelUp = (inputArray) => {
 } // oneLevelUp
 ```
 
-Cette fonction « escalade » un niveau dans l'arbre de Merkle en hachant les paires de valeurs de la couche actuelle. Notez que ce n'est pas l'implémentation la plus efficace, nous aurions pu éviter de copier l'entrée et juste ajouter `hashEmpty` lorsque cela est approprié dans la boucle, mais ce code est optimisé pour être plus lisible.
+Cette fonction « escalade » un niveau dans l'arbre de Merkle en hachant les paires de valeurs de la couche actuelle. Notez que ce n'est pas l'implémentation la plus efficace, nous aurions pu éviter de copier l'entrée et juste ajouter `hashEmpty` lorsque cela est approprié dans la boucle, mais ce code est optimisé pour la lisibilité.
 
 ```javascript
 const getMerkleRoot = (inputArray) => {
   var result
 
-  result = [...inputArray] // Climb up the tree until there is only one value, that is the // root. // // If a layer has an odd number of entries the // code in oneLevelUp adds an empty value, so if we have, for example, // 10 leaves we'll have 5 branches in the second layer, 3 // branches in the third, 2 in the fourth and the root is the fifth
+  result = [...inputArray] // Remonte l'arbre jusqu'à ce qu'il n'y ait plus qu'une seule valeur, qui est la // racine. // // Si une couche a un nombre impair d'entrées, le // code dans oneLevelUp ajoute une valeur vide, donc si nous avons, par exemple, // 10 feuilles, nous aurons 5 branches dans la deuxième couche, 3 // branches dans la troisième, 2 dans la quatrième et la racine est la cinquième
 
   while (result.length > 1) result = oneLevelUp(result)
 
@@ -126,27 +129,27 @@ const getMerkleRoot = (inputArray) => {
 
 Pour obtenir la racine, escaladez jusqu'à ce qu'il ne reste qu'une seule valeur.
 
-#### Créer une preuve de Merkle {#creating-a-merkle-proof}
+#### Création d'une preuve de Merkle {#creating-a-merkle-proof}
 
 Une preuve de Merkle est l'ensemble des valeurs à hacher ensemble avec la valeur prouvée pour récupérer la racine de Merkle. La valeur à prouver est souvent disponible à partir d'autres données. Je préfère ainsi la fournir séparément plutôt que dans le cadre du code.
 
 ```javascript
-// A merkle proof consists of the value of the list of entries to
-// hash with. Because we use a symmetrical hash function, we don't
-// need the item's location to verify the proof, only to create it
+// Une preuve de Merkle consiste en la valeur de la liste des entrées à
+// hacher. Comme nous utilisons une fonction de hachage symétrique, nous n'avons pas
+// besoin de l'emplacement de l'élément pour vérifier la preuve, seulement pour la créer
 const getMerkleProof = (inputArray, n) => {
     var result = [], currentLayer = [...inputArray], currentN = n
 
-    // Until we reach the top
+    // Jusqu'à ce que nous atteignons le sommet
     while (currentLayer.length > 1) {
-        // No odd length layers
+        // Pas de couches de longueur impaire
         if (currentLayer.length % 2)
             currentLayer.push(empty)
 
         result.push(currentN % 2
-               // If currentN is odd, add with the value before it to the proof
+               // Si currentN est impair, l'ajouter à la preuve avec la valeur qui le précède
             ? currentLayer[currentN-1]
-               // If it is even, add the value after it
+               // S'il est pair, ajouter la valeur qui le suit
             : currentLayer[currentN+1])
 
 ```
@@ -154,16 +157,16 @@ const getMerkleProof = (inputArray, n) => {
 Nous hachons `(v[0],v[1])`, `(v[2],v[3])`, etc. Ainsi, pour les valeurs uniques, nous avons besoin de la suivante, pour les valeurs impaires de la précédente.
 
 ```javascript
-        // Move to the next layer up
+        // Passer à la couche supérieure
         currentN = Math.floor(currentN/2)
         currentLayer = oneLevelUp(currentLayer)
-    }   // while currentLayer.length > 1
+    }   // tant que currentLayer.length > 1
 
     return result
 }   // getMerkleProof
 ```
 
-### Code en chaîne {#on-chain-code}
+### Code en chaîne {#onchain-code}
 
 Enfin, nous avons le code qui vérifie la preuve. Le code en chaîne est écrit en [Solidity](https://docs.soliditylang.org/en/v0.8.11/). L'optimisation est beaucoup plus importante ici parce que les frais en gaz sont relativement élevés.
 
@@ -174,7 +177,7 @@ pragma solidity ^0.8.0;
 import "hardhat/console.sol";
 ```
 
-J'ai écrit ceci en utilisant l'environnement de développement [Hardhat](https://hardhat.org/) qui nous permet d'avoir [une sortie console de Solidity](https://hardhat.org/docs/cookbook/debug-logs) durant le développement.
+J'ai écrit ceci en utilisant l'[environnement de développement Hardhat](https://hardhat.org/), qui nous permet d'avoir une [sortie de console depuis Solidity](https://hardhat.org/docs/cookbook/debug-logs) pendant le développement.
 
 ```solidity
 
@@ -185,15 +188,15 @@ contract MerkleProof {
       return merkleRoot;
     }
 
-    // Extremely insecure, in production code access to
-    // this function MUST BE strictly limited, probably to an
-    // owner
+    // Extrêmement peu sûr, dans le code de production, l'accès à
+    // cette fonction DOIT ÊTRE strictement limité, probablement à un
+    // propriétaire
     function setRoot(uint _merkleRoot) external {
       merkleRoot = _merkleRoot;
     }   // setRoot
 ```
 
-Définissez et obtenez des fonctions pour la racine de Merkle. Laisser tout le monde mettre à jour la racine de Merkle est une _très mauvaise idée_ dans un système en production. Je le fais ici par souci de simplicité pour l'exemple de code. **Ne le faites pas sur un système où l'intégrité des données importe réellement**.
+Définissez et obtenez des fonctions pour la racine de Merkle. Laisser tout le monde mettre à jour la racine de Merkle est une _très mauvaise idée_ dans un système de production. Je le fais ici par souci de simplicité pour l'exemple de code. **Ne le faites pas sur un système où l'intégrité des données importe réellement**.
 
 ```solidity
     function hash(uint _a) internal pure returns(uint) {
@@ -205,12 +208,12 @@ Définissez et obtenez des fonctions pour la racine de Merkle. Laisser tout le m
     }
 ```
 
-Cette fonction génère un hachage de la paire. Il s'agit juste de la traduction en Solidity du code JavaScript pour `hash` et `pairHash`.
+Cette fonction génère un hachage de la paire. Il s'agit simplement de la traduction en Solidity du code JavaScript pour `hash` et `pairHash`.
 
-**Remarque :** Ceci est un autre exemple d'optimisation pour une meilleure lisibilité. Si l'on s'en tient à [la définition de la fonction](https://www.tutorialspoint.com/solidity/solidity_cryptographic_functions.htm), il est possible de stocker les données sous la forme d'une valeur [`bytes32`](https://docs.soliditylang.org/en/v0.5.3/types.html#fixed-size-byte-arrays) et d'éviter les conversions.
+**Remarque :** C'est un autre cas d'optimisation pour la lisibilité. D'après [la définition de la fonction](https://www.tutorialspoint.com/solidity/solidity_cryptographic_functions.htm), il pourrait être possible de stocker les données sous la forme d'une valeur [`bytes32`](https://docs.soliditylang.org/en/v0.5.3/types.html#fixed-size-byte-arrays) et d'éviter les conversions.
 
 ```solidity
-    // Verify a Merkle proof
+    // Vérifier une preuve de Merkle
     function verifyProof(uint _value, uint[] calldata _proof)
         public view returns (bool) {
       uint temp = _value;
@@ -223,19 +226,21 @@ Cette fonction génère un hachage de la paire. Il s'agit juste de la traduction
       return temp == merkleRoot;
     }
 
-}  // MarkleProof
+}  // MerkleProof
 ```
 
-En notation mathématique, la vérification par la preuve de Merkle ressemble à ceci : `H(proof_n, H(proof_n-1, H(proof_n-2, ... H(proof_1, H(proof_0, value))...)))`. Ce code l'implémente.
+En notation mathématique, la vérification de la preuve de Merkle ressemble à ceci : `H(proof_n, H(proof_n-1, H(proof_n-2, ...` `H(proof_1, H(proof_0, value))...)))`. Ce code l'implémente.
 
 ## Les preuves de Merkle et les rollups ne font pas bon ménage {#merkle-proofs-and-rollups}
 
 Les preuves de Merkle ne fonctionnent pas bien avec les [rollups](/developers/docs/scaling/#rollups). La raison en est que les rollups écrivent toutes les données de transaction sur L1, mais le processus sur L2. Le coût d'envoi d'une preuve Merkle avec une transaction est en moyenne de 638 gaz par couche (actuellement, un octet de données d'appel coûte 16 gaz s'il n'est pas nul, et 4 s'il est nul). Si nous avons 1 024 mots de données, une preuve de Merkle nécessite dix couches, soit un total de 6 380 gaz.
 
-En cherchant un exemple avec [Optimism](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m), écrire du gaz en L1 coûte environ 100 gwei et le gaz en L2 coûte 0,001 gwei (c'est le prix normal, il peut augmenter s'il y a congestion). Ainsi, pour le coût d'un gaz L1, nous pouvons dépenser cent mille gaz pour le traitement L2. En supposant que nous n'ayons pas écrasé le stockage, cela signifie que nous pouvons écrire environ cinq mots à stocker sur L2 pour le prix d'un gaz L1. Pour une seule preuve de Merkle, nous pouvons écrire l'intégralité des 1 024 mots sur le stockage (en supposant qu'ils peuvent être calculés sur la chaîne pour commencer, au lieu d'être fourni dans une transaction) et disposons toujours de la majeure partie du gaz restant.
+Si l'on prend l'exemple d'[Optimism](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m), l'écriture du gaz L1 coûte environ 100 gwei et le gaz L2 coûte 0,001 gwei (c'est le prix normal, il peut augmenter en cas de congestion). Ainsi, pour le coût d'un gaz L1, nous pouvons dépenser cent mille gaz pour le traitement L2. En supposant que nous n'ayons pas écrasé le stockage, cela signifie que nous pouvons écrire environ cinq mots à stocker sur L2 pour le prix d'un gaz L1. Pour une seule preuve de Merkle, nous pouvons écrire les 1024 mots entiers dans le stockage (en supposant qu'ils peuvent être calculés en chaîne pour commencer, plutôt que fournis dans une transaction) et il nous restera toujours la plus grande partie du gaz.
 
 ## Conclusion {#conclusion}
 
 Dans la vie réelle, il se peut que vous n'ayez jamais à implémenter d'arbres de Merkle par vous-même. Il existe des bibliothèques bien connues et auditées que vous pouvez utiliser et, en général, il est préférable de ne pas implémenter des primitives cryptographiques par vous-même. Cependant, j'espère que, maintenant, vous comprendrez mieux les preuves de Merkle et que vous pourrez décider quand elles valent la peine d'être utilisées.
 
-Notez que bien que les preuves de Merkle préservent _l'intégrité_, elles ne préservent pas _la disponibilité_. Savoir que personne d'autre ne peut se saisir de vos actifs est une petite consolation si le stockage de données décide d'en interdire l'accès et que vous ne pouvez pas non plus construire un arbre de Merkle pour y accéder. Ainsi, les arbres de Merkle sont mieux utilisés avec un type de stockage décentralisé, comme IPFS.
+Notez que si les preuves de Merkle préservent l'_intégrité_, elles ne préservent pas la _disponibilité_. Savoir que personne d'autre ne peut se saisir de vos actifs est une petite consolation si le stockage de données décide d'en interdire l'accès et que vous ne pouvez pas non plus construire un arbre de Merkle pour y accéder. Ainsi, les arbres de Merkle sont mieux utilisés avec un type de stockage décentralisé, comme IPFS.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md b/public/content/translations/fr/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
index 6ad31d6699b..23692a3aa82 100644
--- a/public/content/translations/fr/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
+++ b/public/content/translations/fr/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
@@ -1,29 +1,27 @@
 ---
 title: Surveillance de Geth avec InfluxDB et Grafana
-description:
+description: "Configurez la surveillance de votre nœud Geth avec InfluxDB et Grafana pour suivre les performances et identifier les problèmes."
 author: "Mario Havel"
-tags:
-  - "clients"
-  - "nœuds"
+tags: [ "clients", "nœuds" ]
 skill: intermediate
 lang: fr
 published: 2021-01-13
 ---
 
-Ce tutoriel vous aidera à mettre en place une surveillance de votre nœud Geth afin de mieux comprendre ses performances et identifier les problèmes potentiels.
+Ce tutoriel vous aidera à mettre en place une surveillance de votre nœud Geth afin de mieux comprendre ses performances et d'identifier les problèmes potentiels.
 
 ## Prérequis {#prerequisites}
 
-- Vous devriez déjà savoir exécuter une instance Geth.
-- La plupart des étapes et des exemples étant réalisés pour l'environnement linux, la connaissance des bases sur terminal sera utile.
-- Visionnez cette vidéo pour obtenir un aperçu de suite de métriques de Geth : [Surveillance d'une infrastructure Ethereum par Péter Szilágyi](https://www.youtube.com/watch?v=cOBab8IJMYI).
+- Vous devriez déjà avoir une instance de Geth en cours d'exécution.
+- La plupart des étapes et des exemples sont destinés à un environnement Linux ; des connaissances de base du terminal seront utiles.
+- Découvrez cet aperçu vidéo de la suite de métriques de Geth : [Surveillance d'une infrastructure Ethereum par Péter Szilágyi](https://www.youtube.com/watch?v=cOBab8IJMYI).
 
 ## Pile de surveillance {#monitoring-stack}
 
-Un client Ethereum collecte de nombreuses données qui peuvent être lues sous la forme d'une base de données chronologique. Pour faciliter la surveillance, vous pouvez l'intégrer dans le logiciel de visualisation des données. Plusieurs options sont disponibles :
+Un client Ethereum collecte de nombreuses données qui peuvent être lues sous la forme d'une base de données chronologique. Pour faciliter la surveillance, vous pouvez intégrer ces données dans un logiciel de visualisation. Plusieurs options sont disponibles :
 
-- [Prometheus](https://prometheus.io/) (modèle de retrait)
-- [InfluxDB](https://www.influxdata.com/get-influxdb/) (modèle d'ajout)
+- [Prometheus](https://prometheus.io/) (modèle pull)
+- [InfluxDB](https://www.influxdata.com/get-influxdb/) (modèle push)
 - [Telegraf](https://www.influxdata.com/get-influxdb/)
 - [Grafana](https://www.grafana.com/)
 - [Datadog](https://www.datadoghq.com/)
@@ -31,11 +29,12 @@ Un client Ethereum collecte de nombreuses données qui peuvent être lues sous l
 
 Il existe également [Geth Prometheus Exporter](https://github.com/hunterlong/gethexporter), une option préconfigurée avec InfluxDB et Grafana.
 
-Dans ce tutoriel, nous allons configurer votre client Geth pour pousser des données sur InfluxDB afin de créer une base de données, et Grafana pour créer une visualisation graphique des données. Réaliser cela manuellement vous aidera à mieux comprendre le processus, à le modifier et à le déployer dans différents environnements.
+Dans ce tutoriel, nous allons configurer votre client Geth pour pousser des données sur InfluxDB afin de créer une base de données, et sur Grafana pour créer une visualisation graphique des données. Le faire manuellement vous aidera à mieux comprendre le processus, à le modifier et à le déployer dans différents environnements.
 
-## Configuration de InfluxDB {#setting-up-influxdb}
+## Configuration d'InfluxDB {#setting-up-influxdb}
 
-Tout d'abord, téléchargeons et installons InfluxDB. Diverses options de téléchargement peuvent être trouvées sur la page des versions de [Influxdata](https://portal.influxdata.com/downloads/). Choisissez celles qui conviennent à votre environnement. Vous pouvez également l'installer depuis un [dépôt](https://repos.influxdata.com/). Par exemple dans la distribution basée sur Debian :
+Tout d'abord, téléchargeons et installons InfluxDB. Vous trouverez plusieurs options de téléchargement sur la [page des versions d'Influxdata](https://portal.influxdata.com/downloads/). Choisissez celle qui convient à votre environnement.
+Vous pouvez également l'installer depuis un [dépôt](https://repos.influxdata.com/). Par exemple, pour une distribution basée sur Debian :
 
 ```
 curl -tlsv1.3 --proto =https -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add
@@ -48,51 +47,53 @@ sudo systemctl start influxdb
 sudo apt install influxdb-client
 ```
 
-Après avoir installé InfluxDB avec succès, assurez-vous qu'il fonctionne en arrière-plan. Par défaut, il est accessible via `localhost:8086`. Avant d'utiliser le client `influx`, vous devez créer un nouvel utilisateur avec les privilèges d'administrateur. Cet utilisateur servira à la gestion de haut niveau, à la création de bases de données et d'utilisateurs.
+Après avoir installé InfluxDB avec succès, assurez-vous qu'il fonctionne en arrière-plan. Par défaut, il est accessible à l'adresse `localhost:8086`.
+Avant d'utiliser le client `influx`, vous devez créer un nouvel utilisateur avec des privilèges d'administrateur. Cet utilisateur servira à la gestion de haut niveau, à la création de bases de données et d'utilisateurs.
 
 ```
 curl -XPOST "http://localhost:8086/query" --data-urlencode "q=CREATE USER username WITH PASSWORD 'password' WITH ALL PRIVILEGES"
 ```
 
-Maintenant, vous pouvez utiliser le client influx pour entrer [InfluxDB shell](https://docs.influxdata.com/influxdb/v1.8/tools/shell/) avec cet utilisateur.
+Vous pouvez maintenant utiliser le client influx pour entrer dans le [shell InfluxDB](https://docs.influxdata.com/influxdb/v1.8/tools/shell/) avec cet utilisateur.
 
 ```
 influx -username 'username' -password 'password'
 ```
 
-En communiquant directement avec InfluxDB dans son invite de commande, vous pouvez créer une base de données et un utilisateur pour les métriques Geth.
+En communiquant directement avec InfluxDB dans son shell, vous pouvez créer une base de données et un utilisateur pour les métriques de Geth.
 
 ```
 create database geth
 create user geth with password choosepassword
 ```
 
-Vérifiez les entrées créées avec :
+Vérifiez les entrées créées avec :
 
 ```
 show databases
 show users
 ```
 
-Quitter l’invite de commande InfluxDB.
+Quittez le shell InfluxDB.
 
 ```
 exit
 ```
 
-InfluxDB est en cours d'exécution et configuré pour stocker les métriques Geth.
+InfluxDB est en cours d'exécution et configuré pour stocker les métriques de Geth.
 
 ## Préparation de Geth {#preparing-geth}
 
-Après avoir configuré la base de données, nous devons activer la collecte des métriques dans Geth. Faites attention aux `OPTIONS METRICS ET STATS` dans `geth --help`. Plusieurs options peuvent y être trouvées. Dans ce cas, nous voulons que Geth envoie des données dans InfluxDB. La configuration de base spécifie le point de terminaison où InfluxDB est accessible ainsi que l'authentification pour la base de données.
+Après avoir configuré la base de données, nous devons activer la collecte de métriques dans Geth. Faites attention aux `METRICS AND STATS OPTIONS` dans `geth --help`. Vous y trouverez plusieurs options ; dans notre cas, nous voulons que Geth pousse les données vers InfluxDB.
+La configuration de base spécifie le point de terminaison où InfluxDB est joignable et l'authentification pour la base de données.
 
 ```
 geth --metrics --metrics.influxdb --metrics.influxdb.endpoint "http://0.0.0.0:8086" --metrics.influxdb.username "geth" --metrics.influxdb.password "chosenpassword"
 ```
 
-Ces options peuvent être ajoutées à une commande démarrant le client ou enregistrées dans le fichier de configuration.
+Ces options peuvent être ajoutées à une commande qui lance le client ou être enregistrées dans le fichier de configuration.
 
-Vous pouvez vérifier que Geth envoie les données avec succès, par exemple en listant les paramètres dans la base de données. Dans l'invite de commande InfluxDB :
+Vous pouvez vérifier que Geth pousse bien les données, par exemple en listant les métriques dans la base de données. Dans le shell InfluxDB :
 
 ```
 use geth
@@ -101,7 +102,8 @@ show measurements
 
 ## Configuration de Grafana {#setting-up-grafana}
 
-L'étape suivante est l'installation de Grafana qui interprétera les données graphiquement. Suivez le processus d'installation au regard de votre environnement dans la documentation de Grafana. Assurez-vous d'installer la version OSS si vous ne voulez pas le contraire. Exemple d'étapes d'installation pour les distributions Debian en utilisant le dépôt :
+L'étape suivante consiste à installer Grafana, qui interprétera les données graphiquement. Suivez le processus d'installation pour votre environnement dans la documentation de Grafana. Assurez-vous d'installer la version OSS si vous n'avez pas besoin d'une autre version.
+Exemple d'étapes d'installation pour les distributions Debian à l'aide du dépôt :
 
 ```
 curl -tlsv1.3 --proto =https -sL https://packages.grafana.com/gpg.key | sudo apt-key add -
@@ -112,36 +114,38 @@ sudo systemctl enable grafana-server
 sudo systemctl start grafana-server
 ```
 
-Lorsque Grafana est en cours d'exécution, il devrait être accessible via `localhost:3000`. Utilisez votre navigateur préféré pour accéder à ce chemin, puis connectez-vous avec les identifiants par défaut (utilisateur : `admin` et mot de passe : `admin`). Lorsque vous y êtes invité, changez le mot de passe par défaut et enregistrez.
+Lorsque Grafana est en cours d'exécution, il devrait être accessible à l'adresse `localhost:3000`.
+Utilisez votre navigateur préféré pour accéder à ce chemin, puis connectez-vous avec les identifiants par défaut (utilisateur : `admin` et mot de passe : `admin`). Lorsque vous y êtes invité, changez le mot de passe par défaut et enregistrez.
 
 ![](./grafana1.png)
 
-Vous serez redirigé vers la page d'accueil de Grafana. Tout d'abord, configurez vos données sources. Cliquez sur l'icône de configuration dans la barre de gauche et sélectionnez « Data sources ».
+Vous serez redirigé vers la page d'accueil de Grafana. Tout d'abord, configurez vos données sources. Cliquez sur l'icône de configuration dans la barre de gauche et sélectionnez "Sources de données".
 
 ![](./grafana2.png)
 
-Il n'y a pas encore de sources de données créées, cliquez sur « Add data source » pour en définir.
+Aucune source de données n'a encore été créée, cliquez sur "Ajouter une source de données" pour en définir une.
 
 ![](./grafana3.png)
 
-Pour cette configuration, sélectionnez « InfluxDB » et continuez.
+Pour cette configuration, sélectionnez "InfluxDB" et continuez.
 
 ![](./grafana4.png)
 
-La configuration des données sources est assez directe si vous utilisez des outils sur la même machine. Vous devez définir l'adresse InfluxDB et les détails pour accéder à la base de données. Reportez-vous à l'image ci-dessous.
+La configuration de la source de données est assez simple si vous exécutez les outils sur la même machine. Vous devez définir l'adresse d'InfluxDB et les informations d'accès à la base de données. Reportez-vous à l'image ci-dessous.
 
 ![](./grafana5.png)
 
-Si la configuration est complète et que InfluxDB est joignable, cliquez sur « Save and test » et attendez que la confirmation apparaisse.
+Si tout est complet et qu'InfluxDB est accessible, cliquez sur "Enregistrer et tester" et attendez que la confirmation apparaisse.
 
 ![](./grafana6.png)
 
-Grafana est maintenant configuré pour lire les données depuis InfluxDB. Maintenant, vous devez créer un tableau de bord qui les interpréter et les affichera. Les propriétés des tableaux de bord sont encodées en fichiers JSON qui peuvent être créés par n'importe qui et facilement importés. Dans la barre de gauche, cliquez sur « Create and Import ».
+Grafana est maintenant configuré pour lire les données depuis InfluxDB. Vous devez maintenant créer un tableau de bord qui interprétera et affichera ces données. Les propriétés des tableaux de bord sont encodées dans des fichiers JSON qui peuvent être créés par n'importe qui et importés facilement. Dans la barre de gauche, cliquez sur "Créer et Importer".
 
 ![](./grafana7.png)
 
-Pour un tableau de bord de surveillance Geth, copiez l'ID de [ce tableau de bord](https://grafana.com/grafana/dashboards/13877/) et collez-le dans « Import page » sur Grafana. Après avoir enregistré le tableau de bord, il devrait ressembler à ceci :
+Pour un tableau de bord de surveillance Geth, copiez l'ID de [ce tableau de bord](https://grafana.com/grafana/dashboards/13877/) et collez-le dans la "Page d'importation" dans Grafana. Après avoir enregistré le tableau de bord, il devrait ressembler à ceci :
 
 ![](./grafana8.png)
 
-Vous pouvez modifier vos tableaux de bord. Chaque panneau peut être modifié, déplacé, supprimé ou ajouté. Vous pouvez modifier vos configurations. C'est à vous ! Pour en savoir plus sur le fonctionnement des tableaux de bord, reportez-vous à la documentation de [Grafana](https://grafana.com/docs/grafana/latest/dashboards/). Vous pourriez également être intéressé par [Alerte](https://grafana.com/docs/grafana/latest/alerting/). Cela vous permet de configurer des notifications d'alerte lorsque les paramètres atteignent certaines valeurs. Différents canaux de communication sont pris en charge.
+Vous pouvez modifier vos tableaux de bord. Chaque panneau peut être modifié, déplacé, supprimé ou ajouté. Vous pouvez modifier vos configurations. À vous de jouer ! Pour en savoir plus sur le fonctionnement des tableaux de bord, consultez la [documentation de Grafana](https://grafana.com/docs/grafana/latest/dashboards/).
+Les [alertes](https://grafana.com/docs/grafana/latest/alerting/) pourraient également vous intéresser. Cela vous permet de configurer des notifications d'alerte pour les cas où les métriques atteignent certaines valeurs. Divers canaux de communication sont pris en charge.
diff --git a/public/content/translations/fr/developers/tutorials/nft-minter/index.md b/public/content/translations/fr/developers/tutorials/nft-minter/index.md
index 3c99a06a073..7ac28721c0b 100644
--- a/public/content/translations/fr/developers/tutorials/nft-minter/index.md
+++ b/public/content/translations/fr/developers/tutorials/nft-minter/index.md
@@ -1,14 +1,16 @@
 ---
 title: Tutoriel pour frapper des NFT
-description: Dans ce tutoriel, vous allez créer un générateur de NFT et apprendre à créer une application décentralisée dApp full-stack en reliant votre contrat intelligent à une interface React, à l'aide de MetaMask et d'autres outils Web3.
+description: "Dans ce tutoriel, vous allez créer un générateur de NFT et apprendre à créer une application décentralisée dApp full-stack en reliant votre contrat intelligent à une interface React, à l'aide de MetaMask et d'autres outils Web3."
 author: "smudgil"
 tags:
-  - "solidity"
-  - "NFT"
-  - "alchemy"
-  - "contrats intelligents"
-  - "frontend"
-  - "Pinata"
+  [
+    "solidité",
+    "NFT",
+    "alchemy",
+    "contrats intelligents",
+    "frontend",
+    "Pinata"
+  ]
 skill: intermediate
 lang: fr
 published: 2021-10-06
@@ -18,19 +20,19 @@ L'un des plus grands défis pour les développeurs venus du Web2 est de comprend
 
 En construisant un générateur de NFT — une interface simple où vous pouvez saisir un lien vers votre ressource numérique, un titre et une description — vous apprendrez à :
 
-- Vous connecter à MetaMask via votre interface
+- Vous connecter à MetaMask via votre projet en frontend
 - Appeler les méthodes du contrat intelligent depuis votre interface
-- Signer les transactions à l'aide de MetaMask
+- Signer des transactions à l'aide de MetaMask
 
-Dans ce tutoriel, nous utiliserons [React](https://reactjs.org/) en tant que framework d'interface. Puisque ce tutoriel s'intéresse avant tout au développement Web3, nous ne nous attarderons pas à expliquer les bases de React. Au lieu de cela, nous nous concentrerons sur l'ajout de fonctionnalités à notre projet.
+Dans ce tutoriel, nous utiliserons [React](https://react.dev/) comme framework frontend. Puisque ce tutoriel s'intéresse avant tout au développement Web3, nous ne nous attarderons pas à expliquer les bases de React. Au lieu de cela, nous nous concentrerons sur l'ajout de fonctionnalités à notre projet.
 
-En prérequis, il vous faudra un niveau débutant en React — savoir comment fonctionnent les composants, les props, useState/useEffect, et les appels des fonctions de base. Si vous n'avez jamais entendu parler de ces termes auparavant, vous pouvez consulter ce [tutoriel d'introduction à React](https://reactjs.org/tutorial/tutorial.html). Pour les apprenants plus visuels, nous recommandons fortement cette excellente série vidéo [Full Modern React Tutorial](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gZD-Tvwfod2gaISzfRiP9d) par Net Ninja.
+En prérequis, il vous faudra un niveau débutant en React — savoir comment fonctionnent les composants, les props, useState/useEffect, et les appels des fonctions de base. Si vous n'avez jamais entendu parler de l'un de ces termes auparavant, vous pouvez consulter ce [tutoriel d'introduction à React](https://react.dev/learn/tutorial-tic-tac-toe). Pour les apprenants plus visuels, nous recommandons vivement cette excellente série de vidéos [Full Modern React Tutorial](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gZD-Tvwfod2gaISzfRiP9d) par Net Ninja.
 
 Et si vous ne l'avez pas déjà fait, vous aurez certainement besoin d'un compte Alchemy pour terminer ce tutoriel ainsi que pour construire quoi que ce soit sur la blockchain. Créez un compte gratuit [ici](https://alchemy.com/).
 
 Sans plus attendre, commençons !
 
-## Introduction à la fabrication de NFT {#making-nfts-101}
+## Création de NFT 101 {#making-nfts-101}
 
 Avant même de commencer à regarder du code, il est important de comprendre comment la fabrication d'un NFT fonctionne. Elle comporte deux étapes :
 
@@ -38,36 +40,36 @@ Avant même de commencer à regarder du code, il est important de comprendre com
 
 La plus grande différence entre les deux normes de contrat intelligent NFT est que l'ERC-1155 est un standard multijeton et inclut la fonctionnalité de lot. Alors que l'ERC-721 est un standard à jeton unique et supporte donc uniquement le transfert d'un jeton à la fois.
 
-### Appeler la fonction de « frappe » (mint) {#minting-function}
+### Appeler la fonction de frappe {#minting-function}
 
-Habituellement, cette fonction de frappe nécessite que vous passiez deux variables en paramètres. Tout d'abord le `recipient`, qui spécifie l'adresse qui recevra votre NFT fraîchement frappé. Et la seconde qui est le `tokenURI`du NFT : une chaîne de caractères qui pointe sur un document JSON décrivant les métadonnées du NFT.
+Généralement, cette fonction de frappe vous demande de transmettre deux variables en tant que paramètres, premièrement le `destinataire`, qui spécifie l'adresse qui recevra votre NFT fraîchement frappé, et deuxièmement le `tokenURI` du NFT, une chaîne qui renvoie à un document JSON décrivant les métadonnées du NFT.
 
-Les métadonnées d'un NFT sont ce qui lui donne vie, lui permettant d'avoir des propriétés configurables, comme un nom, une description, une image et d'autres attributs. Voici [un exemple de tokenURI](https://gateway.pinata.cloud/ipfs/QmSvBcb4tjdFpajGJhbFAWeK3JAxCdNQLQtr6ZdiSi42V2) qui contient les métadonnées d'un NFT.
+Les métadonnées d'un NFT sont ce qui lui donne vie, lui permettant d'avoir des propriétés configurables, comme un nom, une description, une image et d'autres attributs. Voici [un exemple de tokenURI](https://gateway.pinata.cloud/ipfs/QmSvBcb4tjdFpajGJhbFAWeK3JAxCdNQLQtr6ZdiSi42V2), qui contient les métadonnées d'un NFT.
 
 Dans ce tutoriel, nous allons nous concentrer sur la deuxième partie, en appelant la fonction existante de frappe d'un contrat intelligent de type NFT avec notre interface React.
 
-[Voici un lien](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE) vers le contrat intelligent ERC-721 NFT que nous allons appeler dans ce tutoriel. Si vous souhaitez apprendre comment nous l'avons fait, nous vous recommandons fortement de consulter notre autre tutoriel, ["Comment créer un NFT"](https://docs.alchemyapi.io/alchemy/tutorials/how-to-create-an-nft).
+[Voici un lien](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE) vers le contrat intelligent de NFT ERC-721 que nous appellerons dans ce tutoriel. Si vous souhaitez apprendre comment nous l'avons créé, nous vous recommandons vivement de consulter notre autre tutoriel, ["Comment créer un NFT"](https://www.alchemy.com/docs/how-to-create-an-nft).
 
 Bien, maintenant que nous comprenons comment la fabrication de NFT fonctionne, clonons nos fichiers et démarrons  !
 
 ## Cloner les fichiers de démarrage {#clone-the-starter-files}
 
-Tout d'abord, rendez-vous sur le dépôt GitHub [nft-minter-tutorial](https://github.com/alchemyplatform/nft-minter-tutorial) pour obtenir les fichiers de démarrage de ce projet. Clonez ce dépôt dans votre environnement local.=
+Tout d'abord, accédez au [dépôt GitHub nft-minter-tutorial](https://github.com/alchemyplatform/nft-minter-tutorial) pour obtenir les fichiers de démarrage de ce projet. Clonez ce dépôt dans votre environnement local.
 
-Lorsque vous ouvrez ce dépôt `nft-minter-tutorial` , vous remarquerez qu'il contient deux dossiers : `minter-starter-files` et `nft-minter`.
+Lorsque vous ouvrez ce dépôt `nft-minter-tutorial` cloné, vous remarquerez qu'il contient deux dossiers : `minter-starter-files` et `nft-minter`.
 
-- `minter-starter-files` contient les fichiers de démarrage (essentiellement l'interface utilisateur en React) pour ce projet. Dans ce tutoriel, **nous travaillerons dans ce répertoire**. Au fur et à mesure, vous apprendrez à donner vie à cette interface utilisateur en la connectant à votre portefeuille Ethereum et à un contrat intelligent NFT.
-- `nft-minter` contient l'intégralité du tutoriel et vous servira de **référence** **si vous êtes coincé.**
+- `minter-starter-files` contient les fichiers de démarrage (essentiellement l'interface utilisateur React) de ce projet. Dans ce tutoriel, **nous travaillerons dans ce répertoire**, où vous apprendrez à donner vie à cette interface utilisateur en la connectant à votre portefeuille Ethereum et à un contrat intelligent de NFT.
+- `nft-minter` contient le tutoriel entièrement terminé et est là pour vous servir de **référence** **si vous êtes bloqué.**
 
-Ensuite, ouvrez votre copie de `minter-starter-files` dans votre éditeur de code, puis naviguez dans votre dossier `src`.
+Ensuite, ouvrez votre copie de `minter-starter-files` dans votre éditeur de code, puis accédez à votre dossier `src`.
 
-Tout le code que nous allons écrire restera dans le dossier `src`. Nous allons modifier le composant `Minter.js` et écrire des fichiers javascript supplémentaires pour ajouter des fonctionnalités à notre projet Web3.
+Tout le code que nous allons écrire se trouvera dans le dossier `src`. Nous allons modifier le composant `Minter.js` et écrire des fichiers javascript supplémentaires pour donner à notre projet des fonctionnalités Web3.
 
-## Étape 2 : Vérifier nos fichiers de démarrage {#step-2-check-out-our-starter-files}
+## Étape 2 : consultez nos fichiers de démarrage {#step-2-check-out-our-starter-files}
 
 Avant de commencer à coder, il est important de connaître ce qui est déjà fourni dans les fichiers de base.
 
-### Faites tourner votre projet de React {#get-your-react-project-running}
+### Faire fonctionner votre projet React {#get-your-react-project-running}
 
 Commençons par exécuter le projet React dans notre navigateur. La beauté de React est qu'une fois que notre projet est en cours d'exécution dans notre navigateur, toutes les modifications que nous sauvegardons seront mises à jour en direct dans notre navigateur.
 
@@ -90,14 +92,14 @@ Si vous essayez de cliquer sur les boutons « Connect Wallet » (connecter le po
 
 ### Le composant Minter.js {#minter-js}
 
-**REMARQUE :** Assurez-vous d'être dans le dossier `minter-starter-files` et non le dossier `nft-minter` !
+**REMARQUE :** Assurez-vous d'être dans le dossier `minter-starter-files` et non dans le dossier `nft-minter` !
 
-Revenons dans le dossier `src` de notre éditeur et ouvrons le fichier `Minter.js`. Il est très important de comprendre tout ce qui se trouve dans ce fichier, car c'est le composant principal de React sur lequel nous allons travailler.
+Retournons dans le dossier `src` de notre éditeur et ouvrons le fichier `Minter.js`. Il est très important de comprendre tout ce qui se trouve dans ce fichier, car c'est le composant principal de React sur lequel nous allons travailler.
 
 En haut de ce fichier, nous avons nos variables d'état que nous mettrons à jour après des événements spécifiques.
 
 ```javascript
-//State variables
+//Variables d'état
 const [walletAddress, setWallet] = useState("")
 const [status, setStatus] = useState("")
 const [name, setName] = useState("")
@@ -105,135 +107,135 @@ const [description, setDescription] = useState("")
 const [url, setURL] = useState("")
 ```
 
-Vous n'avez jamais entendu parler de variables d'état React ou de hooks d'état ? Jetez un œil à cette [documentation](https://reactjs.org/docs/hooks-state.html).
+Vous n'avez jamais entendu parler de variables d'état React ou de hooks d'état ? Consultez [cette](https://legacy.reactjs.org/docs/hooks-state.html) documentation.
 
 Voici ce que chacune des variables représente :
 
-- `walletAddress` - une chaîne de caractère qui stocke l'adresse du portefeuille de l'utilisateur
-- `status` - une chaîne de caractère qui contient un message à afficher en bas de l'interface utilisateur
-- `name` - une chaîne de caractère qui stocke le nom du NFT
-- `description` - une chaîne de caractère qui stocke la description du NFT
-- `url` - une chaîne de caractères qui est un lien vers l'actif numérique du NFT
+- `walletAddress` : une chaîne qui stocke l'adresse du portefeuille de l'utilisateur
+- `status` : une chaîne qui contient un message à afficher en bas de l'interface utilisateur
+- `name` : une chaîne qui stocke le nom du NFT
+- `description` : une chaîne qui stocke la description du NFT
+- `url` : une chaîne qui est un lien vers l'actif numérique du NFT
 
-Après les variables d'état, vous verrez trois fonctions non implémentées : `useEffect`, `connectWalletPressed`, et `onMintPressed`. Vous remarquerez que toutes ces fonctions sont `async`, c'est parce que nous allons faire des appels d'API asynchrones ! Leurs noms correspondent à leurs fonctionnalités :
+Après les variables d'état, vous verrez trois fonctions non implémentées : `useEffect`, `connectWalletPressed` et `onMintPressed`. Vous remarquerez que toutes ces fonctions sont `async`, c'est parce que nous y effectuerons des appels d'API asynchrones ! Leurs noms correspondent à leurs fonctionnalités :
 
 ```javascript
 useEffect(async () => {
-  //TODO: implement
+  //TODO: à implémenter
 }, [])
 
 const connectWalletPressed = async () => {
-  //TODO: implement
+  //TODO: à implémenter
 }
 
 const onMintPressed = async () => {
-  //TODO: implement
+  //TODO: à implémenter
 }
 ```
 
-- [`useEffect`](https://reactjs.org/docs/hooks-effect.html) - Il s'agit d'un hook React qui est appelé après que votre composant est affiché. Parce qu'une prop tableau vide `[]` lui est passée (voir la ligne 3), elle ne sera appelée qu'au _premier_ affichage du composant. Ici, nous appellerons notre écouteur de portefeuille et une autre fonction de portefeuille pour mettre à jour notre interface utilisateur afin de déterminer si un portefeuille est déjà connecté.
-- `connectWalletPressed` - cette fonction sera appelée pour connecter le portefeuille MetaMask de l'utilisateur à notre dApp.
-- `onMintPressed` - cette fonction sera appelée pour frapper le NFT de l'utilisateur.
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) : il s'agit d'un hook React qui est appelé après le rendu de votre composant. Comme il reçoit une prop de tableau vide `[]` (voir ligne 3), il ne sera appelé que lors du _premier_ rendu du composant. Ici, nous appellerons notre écouteur de portefeuille et une autre fonction de portefeuille pour mettre à jour notre interface utilisateur afin de déterminer si un portefeuille est déjà connecté.
+- `connectWalletPressed` : cette fonction sera appelée pour connecter le portefeuille MetaMask de l'utilisateur à notre dapp.
+- `onMintPressed` : cette fonction sera appelée pour frapper le NFT de l'utilisateur.
 
-Vers la fin de ce fichier, nous avons l'interface utilisateur de notre composant. Si vous scannez ce code attentivement, vous remarquerez que nous mettons à jour nos variables d'état `url`, `name`, et `description` lorsque le contenu entré dans leurs champs de texte change.
+Vers la fin de ce fichier, nous avons l'interface utilisateur de notre composant. Si vous examinez attentivement ce code, vous remarquerez que nous mettons à jour nos variables d'état `url`, `name` et `description` lorsque l'entrée dans les champs de texte correspondants change.
 
-Vous verrez également que `connectWalletPressed` et `onMintPressed` sont appelées lorsque les boutons portant les IDs respectifs `mintButton` et `walletButton` sont cliqués.
+Vous verrez également que `connectWalletPressed` et `onMintPressed` sont appelées lorsque les boutons avec les ID `mintButton` et `walletButton` sont cliqués respectivement.
 
 ```javascript
-//the UI of our component
+//L'interface utilisateur de notre composant
 return (
   <div className="Minter">
     <button id="walletButton" onClick={connectWalletPressed}>
       {walletAddress.length > 0 ? (
-        "Connected: " +
+        "Connecté : " +
         String(walletAddress).substring(0, 6) +
         "..." +
         String(walletAddress).substring(38)
       ) : (
-        <span>Connect Wallet</span>
+        <span>Connecter le portefeuille</span>
       )}
     </button>
 
     <br></br>
-    <h1 id="title">🧙‍♂️ Alchemy NFT Minter</h1>
+    <h1 id="title">🧙‍♂️ Outil de frappe de NFT Alchemy</h1>
     <p>
-      Simply add your asset's link, name, and description, then press "Mint."
+      Ajoutez simplement le lien, le nom et la description de votre actif, puis appuyez sur "Frapper le NFT".
     </p>
     <form>
-      <h2>🖼 Link to asset: </h2>
+      <h2>🖼 Lien vers l'actif : </h2>
       <input
         type="text"
-        placeholder="e.g., https://gateway.pinata.cloud/ipfs/<hash>"
+        placeholder="par ex., https://gateway.pinata.cloud/ipfs/<hash>"
         onChange={(event) => setURL(event.target.value)}
       />
-      <h2>🤔 Name: </h2>
+      <h2>🤔 Nom : </h2>
       <input
         type="text"
-        placeholder="e.g., My first NFT!"
+        placeholder="par ex., Mon premier NFT !"
         onChange={(event) => setName(event.target.value)}
       />
-      <h2>✍️ Description: </h2>
+      <h2>✍️ Description : </h2>
       <input
         type="text"
-        placeholder="e.g., Even cooler than cryptokitties ;)"
+        placeholder="par ex., Encore plus cool que les cryptokitties ;)"
         onChange={(event) => setDescription(event.target.value)}
       />
     </form>
     <button id="mintButton" onClick={onMintPressed}>
-      Mint NFT
+      Frapper le NFT
     </button>
     <p id="status">{status}</p>
-  </div>
+</div>
 )
 ```
 
 Enfin, occupons-nous de l'endroit où ajouter ce composant Minter.
 
-Si vous ouvrez le fichier `App.js`, qui est le composant principal en React agissant comme un conteneur pour tous les autres composants, vous verrez que notre composant Minter est injecté à la ligne 7.
+Si vous allez dans le fichier `App.js`, qui est le composant principal de React et qui sert de conteneur pour tous les autres composants, vous verrez que notre composant Minter est injecté à la ligne 7.
 
-**Dans ce tutoriel, nous allons seulement modifier le fichier `Minter.js` et ajouter des fichiers dans notre dossier `src`.**
+**Dans ce tutoriel, nous ne modifierons que le fichier `Minter.js` et ajouterons des fichiers dans notre dossier `src`.**
 
 Maintenant que nous comprenons ce avec quoi nous travaillons, mettons en place notre portefeuille Ethereum !
 
-## Configurez votre portefeuille Ethereum {#set-up-your-ethereum-wallet}
+## Configurer votre portefeuille Ethereum {#set-up-your-ethereum-wallet}
 
 Pour que les utilisateurs puissent interagir avec votre contrat intelligent, ils devront connecter leur portefeuille Ethereum à votre dApp.
 
-### Téléchargez MetaMask {#download-metamask}
+### Télécharger MetaMask {#download-metamask}
 
-Pour ce tutoriel, nous utiliserons MetaMask, un portefeuille virtuel utilisable dans le navigateur servant à gérer les adresses Ethereum. Si vous voulez en savoir plus sur le fonctionnement des transactions sur Ethereum, consultez [cette page](/developers/docs/transactions/).
+Pour ce tutoriel, nous allons utiliser MetaMask, un portefeuille virtuel intégré au navigateur, servant à gérer les adresses de votre compte Ethereum. Si vous voulez en savoir plus sur le fonctionnement des transactions sur Ethereum, consultez [cette page](/developers/docs/transactions/).
 
 Vous pouvez télécharger et créer un compte MetaMask gratuitement [ici](https://metamask.io/download). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer sur « Réseau de test Ropsten » en haut à droite \(afin de ne pas utiliser d'argent réel\).
 
-### Ajoutez de l'ether depuis un Robinet {#add-ether-from-faucet}
+### Ajouter de l'ether depuis un robinet {#add-ether-from-faucet}
 
-Afin de frapper nos NFT (ou de signer des transactions sur la blockchain Ethereum), nous aurons besoin de faux Eth. Pour obtenir des ETH, vous pouvez vous rendre sur le [robinet Ropsten](https://faucet.ropsten.be/) et entrer votre adresse Ropsten, puis cliquer sur « Send Ropsten ETH. » Vous devriez voir les ETH dans votre compte MetaMask peu de temps après !
+Afin de frapper nos NFT (ou de signer des transactions sur la blockchain Ethereum), nous aurons besoin de faux Eth. Pour obtenir de l'ETH, vous pouvez vous rendre sur le [robinet Ropsten](https://faucet.ropsten.be/), saisir l'adresse de votre compte Ropsten, puis cliquer sur « Send Ropsten Eth ». Vous devriez voir les ETH dans votre compte MetaMask peu de temps après !
 
-### Vérifiez votre solde {#check-your-balance}
+### Vérifier votre solde {#check-your-balance}
 
-Pour revérifier que votre solde est correct, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant [l'outil Alchemy Composer](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va retourner la quantité d'ETH que contient votre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
+Pour vérifier que notre solde est bien là, faisons une requête [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) en utilisant l'[outil de composition d'Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Cela va retourner la quantité d'ETH que contient votre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :
 
 ```text
 {"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
 ```
 
-**REMARQUE :** Ce résultat est en wei et non pas en ETH. Le wei est utilisé comme la plus petite unité d'ether. La conversion de wei vers eth est : 1 eth = 10¹⁸ wei. Donc si on convertit 0xde0b6b3a7640000 en nombre décimal, nous obtenons 1\*10¹⁸ ce qui correspond à 1 eth.
+**REMARQUE :** ce résultat est en wei et non en eth. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion de wei vers eth est : 1 eth = 10¹⁸ wei. Donc si on convertit 0xde0b6b3a7640000 en nombre décimal, nous obtenons 1\*10¹⁸ ce qui correspond à 1 eth.
 
-Ouf ! Notre faux argent est bien là ! <Emoji text=":money_mouth_face:" size={1} />
+Ouf ! Notre faux argent est bien là ! <Emoji text=":money_mouth_face:" size={1} />
 
 ## Connecter MetaMask à votre interface utilisateur {#connect-metamask-to-your-UI}
 
 Maintenant que notre portefeuille MetaMask est configuré, connectons-y notre dApp !
 
-Pour respecter le paradigme [MVC](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) , nous allons créer un fichier séparé qui contient nos fonctions pour gérer la logique, les données, et les règles de notre dApp, puis passer ces fonctions à notre interface (notre composant Minter.js).
+Parce que nous voulons adhérer au paradigme [MVC](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller), nous allons créer un fichier séparé qui contient nos fonctions pour gérer la logique, les données et les règles de notre dapp, puis transmettre ces fonctions à notre frontend (notre composant Minter.js).
 
 ### La fonction `connectWallet` {#connect-wallet-function}
 
-Pour cela, créons un nouveau dossier appelé `utils` dans votre dossier `src` et ajoutons-y un fichier appelé `interact.js`, qui contiendra toutes les fonctions de notre portefeuille et les interactions avec le contrat intelligent.
+Pour ce faire, créons un nouveau dossier appelé `utils` dans votre répertoire `src` et ajoutons-y un fichier appelé `interact.js`, qui contiendra toutes nos fonctions d'interaction avec le portefeuille et le contrat intelligent.
 
-Dans notre fichier `interact.js`, nous écrirons une fonction `connectWallet`, que nous importerons et appellerons dans notre composant `Minter.js`.
+Dans notre fichier `interact.js`, nous allons écrire une fonction `connectWallet`, que nous importerons et appellerons ensuite dans notre composant `Minter.js`.
 
-Ajoutez ce qui suit dans le fichier `interact.js`
+Dans votre fichier `interact.js`, ajoutez ce qui suit
 
 ```javascript
 export const connectWallet = async () => {
@@ -243,7 +245,7 @@ export const connectWallet = async () => {
         method: "eth_requestAccounts",
       })
       const obj = {
-        status: "👆🏽 Write a message in the text-field above.",
+        status: "👆🏽 Écrivez un message dans le champ de texte ci-dessus.",
         address: addressArray[0],
       }
       return obj
@@ -261,8 +263,8 @@ export const connectWallet = async () => {
           <p>
             {" "}
             🦊 <a target="_blank" href={`https://metamask.io/download`}>
-              You must install MetaMask, a virtual Ethereum wallet, in your
-              browser.
+              Vous devez installer MetaMask, un portefeuille Ethereum virtuel, dans votre
+              navigateur.
             </a>
           </p>
         </span>
@@ -274,26 +276,26 @@ export const connectWallet = async () => {
 
 Décomposons ce que fait ce code :
 
-Premièrement, notre fonction vérifie si `window.ethereum` est activé dans votre navigateur.
+Tout d'abord, notre fonction vérifie si `window.ethereum` est activé dans votre navigateur.
 
-`window.ethereum` est une API globale injectée par MetaMask et d'autres fournisseurs de portefeuille qui permet aux sites web de faire des requêtes vers les comptes Ethereum des utilisateurs. S'il est approuvé, un site peut lire les données des blockchains auxquels l'utilisateur est connecté et proposer à l'utilisateur de signer des messages et des transactions. Consultez la [documentation MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) pour plus d'infos !
+`window.ethereum` est une API globale injectée par MetaMask et d'autres fournisseurs de portefeuilles qui permet aux sites Web de demander les comptes Ethereum des utilisateurs. S'il est approuvé, un site peut lire les données des blockchains auxquels l'utilisateur est connecté et proposer à l'utilisateur de signer des messages et des transactions. Consultez la [documentation de MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) pour plus d'informations !
 
-Si `window.ethereum` _n'est pas_ présent, alors cela signifie que Metamask n'est pas installé. Cela se traduit par un objet JSON retourné, où l'attribut `adresse` retourné est une chaîne vide, et le `status` de l'objet JSX indique que l'utilisateur doit installer MetaMask.
+Si `window.ethereum` n'_est pas_ présent, cela signifie que MetaMask n'est pas installé. Cela se traduit par le renvoi d'un objet JSON, où l'`address` renvoyée est une chaîne vide, et où l'objet `status` JSX relaie que l'utilisateur doit installer MetaMask.
 
-**La plupart des fonctions que nous écrivons retourneront des objets JSON que nous pouvons utiliser pour mettre à jour nos variables d'état et notre interface utilisateur.**
+**La plupart des fonctions que nous écrivons renverront des objets JSON que nous pourrons utiliser pour mettre à jour nos variables d'état et notre interface utilisateur.**
 
-Maintenant, si `window.ethereum` _est présent_, alors c'est là que les choses deviennent intéressantes.
+Maintenant, si `window.ethereum` _est_ présent, c'est là que les choses deviennent intéressantes.
 
-En utilisant une boucle try/catch, nous allons essayer de nous connecter à MetaMask en appelant`[window.ethereum.request({ method: "eth_requestAccounts" });](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts)`. L'appel de cette fonction ouvrira MetaMask dans le navigateur, où l'utilisateur sera invité à connecter son portefeuille à votre dApp.
+À l'aide d'une boucle try/catch, nous allons essayer de nous connecter à MetaMask en appelant [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts). L'appel de cette fonction ouvrira MetaMask dans le navigateur, où l'utilisateur sera invité à connecter son portefeuille à votre dApp.
 
-- Si l'utilisateur choisit de se connecter, `method : "eth_requestAccounts"` retournera une table qui contient toutes les adresses du compte de l'utilisateur qui sont connectées à la dApp. Au final, notre fonction `connectWallet` retourne un objet JSON qui contient la _première_ `address` dans cette table \(voir ligne 9\\) et un message `status` qui invite l'utilisateur à écrire un message sur le contrat intelligent.
-- Si l'utilisateur rejette la connexion, alors l'objet JSON contiendra une chaîne vide pour l'`address` retournée et un message `status` qui indique que l'utilisateur a rejeté la connexion.
+- Si l'utilisateur choisit de se connecter, `method: "eth_requestAccounts"` renverra un tableau contenant toutes les adresses de compte de l'utilisateur qui sont connectées à la dapp. Au total, notre fonction `connectWallet` renverra un objet JSON qui contient la _première_ `adresse` de ce tableau (voir ligne 9) et un message `d'état` qui invite l'utilisateur à écrire un message au contrat intelligent.
+- Si l'utilisateur rejette la connexion, l'objet JSON contiendra une chaîne vide pour l'`address` renvoyée et un message `d'état` indiquant que l'utilisateur a rejeté la connexion.
 
-### Ajouter une fonction connectWallet à votre composant Minter.js {#add-connect-wallet}
+### Ajouter la fonction connectWallet à votre composant d'interface utilisateur Minter.js {#add-connect-wallet}
 
-Maintenant que nous avons écrit cette fonction `connectWallet`, connectons-la à notre composant `Minter.js.`.
+Maintenant que nous avons écrit cette fonction `connectWallet`, connectons-la à notre composant `Minter.js`.
 
-Tout d'abord, nous allons devoir importer notre fonction dans notre fichier `Minter.js` en ajoutant `import { connectWallet } from "./utils/interact.js";` en haut du fichier `Minter.js`. Les 11 premières lignes de votre `Minter.js` devraient maintenant ressembler à ceci :
+Tout d'abord, nous devrons importer notre fonction dans notre fichier `Minter.js` en ajoutant `import { connectWallet } from "./utils/interact.js";` au début du fichier `Minter.js`. Vos 11 premières lignes de `Minter.js` devraient maintenant ressembler à ceci :
 
 ```javascript
 import { useEffect, useState } from "react";
@@ -301,7 +303,7 @@ import { connectWallet } from "./utils/interact.js";
 
 const Minter = (props) => {
 
-  //State variables
+  //Variables d'état
   const [walletAddress, setWallet] = useState("");
   const [status, setStatus] = useState("");
   const [name, setName] = useState("");
@@ -309,7 +311,7 @@ const Minter = (props) => {
   const [url, setURL] = useState("");
 ```
 
-Puis, dans notre fonction `connectWalletPressed`, nous appellerons notre fonction importée `connectWallet`, comme suit :
+Ensuite, à l'intérieur de notre fonction `connectWalletPressed`, nous appellerons notre fonction `connectWallet` importée, comme ceci :
 
 ```javascript
 const connectWalletPressed = async () => {
@@ -319,11 +321,11 @@ const connectWalletPressed = async () => {
 }
 ```
 
-Vous avez remarqué comment la plupart de nos fonctionnalités sont sorties de notre composant `Minter.js` depuis le fichier `interact.js` ? C'est ainsi que nous respectons le paradigme M-V-C !
+Remarquez-vous que la plupart de nos fonctionnalités sont extraites de notre composant `Minter.js` à partir du fichier `interact.js` ? C'est ainsi que nous respectons le paradigme M-V-C !
 
-Dans `connectWalletPressed`, nous faisons simplement un appel await à notre fonction importée `connectWallet`, et en utilisant sa réponse, nous mettons à jour nos variables `status` et `walletAddress` via leurs hooks d'états.
+Dans `connectWalletPressed`, nous effectuons simplement un appel en attente vers notre fonction importée `connectWallet` et, à l'aide de sa réponse, nous mettons à jour nos variables `status` et `walletAddress` via leurs hooks d'état.
 
-Maintenant, enregistrons à la fois les fichiers `Minter.js` et `interact.js` et testons notre interface utilisateur.
+Maintenant, enregistrons les deux fichiers `Minter.js` et `interact.js` et testons notre interface utilisateur jusqu'à présent.
 
 Ouvrez votre navigateur sur localhost:3000, et cliquez sur le bouton « Connect Wallet » en haut à droite de la page.
 
@@ -333,11 +335,11 @@ Vous devriez voir que le bouton du portefeuille précise maintenant que votre ad
 
 Ensuite, essayez de rafraîchir la page... c'est étrange. Notre bouton de portefeuille nous invite à connecter MetaMask bien qu'il soit déjà connecté...
 
-Mais ne vous inquiétez pas ! Nous pouvons facilement corriger cela en implémentant une fonction appelée `getCurrentWalletConnected`, qui vérifiera si une adresse est déjà connectée à notre dApp, et mettra à jour notre interface en conséquence !
+Mais ne vous inquiétez pas ! Nous pouvons facilement résoudre ce problème en implémentant une fonction appelée `getCurrentWalletConnected`, qui vérifiera si une adresse est déjà connectée à notre dapp et mettra à jour notre interface utilisateur en conséquence !
 
-### La fonction `getCurrentWalletConnected` {#get-current-wallet}
+### La fonction getCurrentWalletConnected {#get-current-wallet}
 
-Dans votre fichier `interact.js`, ajoutez la fonction suivante `getCurrentWalletted` :
+Dans votre fichier `interact.js`, ajoutez la fonction `getCurrentWalletConnected` suivante :
 
 ```javascript
 export const getCurrentWalletConnected = async () => {
@@ -349,12 +351,12 @@ export const getCurrentWalletConnected = async () => {
       if (addressArray.length > 0) {
         return {
           address: addressArray[0],
-          status: "👆🏽 Write a message in the text-field above.",
+          status: "👆🏽 Écrivez un message dans le champ de texte ci-dessus.",
         }
       } else {
         return {
           address: "",
-          status: "🦊 Connect to MetaMask using the top right button.",
+          status: "🦊 Connectez-vous à MetaMask en utilisant le bouton en haut à droite.",
         }
       }
     } catch (err) {
@@ -371,8 +373,8 @@ export const getCurrentWalletConnected = async () => {
           <p>
             {" "}
             🦊 <a target="_blank" href={`https://metamask.io/download`}>
-              You must install MetaMask, a virtual Ethereum wallet, in your
-              browser.
+              Vous devez installer MetaMask, un portefeuille Ethereum virtuel, dans votre
+              navigateur.
             </a>
           </p>
         </span>
@@ -382,9 +384,9 @@ export const getCurrentWalletConnected = async () => {
 }
 ```
 
-Ce code est _très_ similaire à la fonction `connectWallet` que nous venons d'écrire plus tôt.
+Ce code est _très_ similaire à la fonction `connectWallet` que nous venons d'écrire.
 
-La différence principale est qu'au lieu d'appeler la méthode `eth_requestAccounts`, qui ouvre MetaMask pour que l'utilisateur puisse connecter son portefeuille, ici nous appelons la méthode `eth_accounts`, qui renvoie simplement un tableau contenant les adresses MetaMask actuellement connectées à notre dApp.
+La principale différence est qu'au lieu d'appeler la méthode `eth_requestAccounts`, qui ouvre MetaMask pour que l'utilisateur connecte son portefeuille, nous appelons ici la méthode `eth_accounts`, qui renvoie simplement un tableau contenant les adresses MetaMask actuellement connectées à notre dapp.
 
 Pour voir cette fonction en action, appelons-la dans la fonction `useEffect` de notre composant `Minter.js`.
 
@@ -394,7 +396,7 @@ Comme nous l'avons fait pour `connectWallet`, nous devons importer cette fonctio
 import { useEffect, useState } from "react"
 import {
   connectWallet,
-  getCurrentWalletConnected, //import here
+  getCurrentWalletConnected, //importer ici
 } from "./utils/interact.js"
 ```
 
@@ -408,11 +410,11 @@ useEffect(async () => {
 }, [])
 ```
 
-Remarquez que nous utilisons la réponse de notre appel à `getCurrentWalletConnected` pour mettre à jour nos variables d'état `walletAddress` et `status`.
+Notez que nous utilisons la réponse de notre appel à `getCurrentWalletConnected` pour mettre à jour nos variables d'état `walletAddress` et `status`.
 
 Une fois que vous avez ajouté ce code, essayez de rafraîchir votre fenêtre de navigateur. Le bouton devrait indiquer que vous êtes connecté et afficher un aperçu de l'adresse de votre portefeuille connecté, même après avoir été actualisé !
 
-### Implémenter `addWalletListener` {#implement-add-wallet-listener}
+### Implémenter addWalletListener {#implement-add-wallet-listener}
 
 La dernière étape de la configuration de notre dApp de portefeuille consiste à mettre en place le listener de portefeuille afin que notre interface utilisateur soit mise à jour lorsque l'état de notre portefeuille change, par exemple lorsque l'utilisateur se déconnecte ou change de compte.
 
@@ -424,10 +426,10 @@ function addWalletListener() {
     window.ethereum.on("accountsChanged", (accounts) => {
       if (accounts.length > 0) {
         setWallet(accounts[0])
-        setStatus("👆🏽 Write a message in the text-field above.")
+        setStatus("👆🏽 Écrivez un message dans le champ de texte ci-dessus.")
       } else {
         setWallet("")
-        setStatus("🦊 Connect to MetaMask using the top right button.")
+        setStatus("🦊 Connectez-vous à MetaMask en utilisant le bouton en haut à droite.")
       }
     })
   } else {
@@ -435,7 +437,7 @@ function addWalletListener() {
       <p>
         {" "}
         🦊 <a target="_blank" href={`https://metamask.io/download`}>
-          You must install MetaMask, a virtual Ethereum wallet, in your browser.
+          Vous devez installer MetaMask, un portefeuille Ethereum virtuel, dans votre navigateur.
         </a>
       </p>
     )
@@ -445,9 +447,9 @@ function addWalletListener() {
 
 Décomposons rapidement ce qui se passe ici :
 
-- Premièrement, notre fonction vérifie si `window.ethereum` est activé \(ex. : MetaMask est installé\).
-  - Si ce n'est pas le cas, nous fixons simplement notre variable d'état `status` à une chaîne de caractères JSX qui invite l'utilisateur à installer MetaMask.
-  - S'il est activé, nous configurons le listener `window.ethereum.on("accountsChanged")` à la ligne 3 qui écoute les changements d'état dans le portefeuille MetaMask, qui les incluent lorsque l'utilisateur connecte un compte additionnel à la dApp, change de compte ou déconnecte un compte. S'il existe au moins un compte connecté, la variable d'état `walletAddress` est mise à jour comme premier compte dans le tableau des comptes `accounts` retourné par l'écouteur. Sinon, `walletAdresse` est défini comme une chaîne de caractères vide.
+- Tout d'abord, notre fonction vérifie si `window.ethereum` est activé (c'est-à-dire si MetaMask est installé).
+  - Si ce n'est pas le cas, nous définissons simplement notre variable d'état `status` sur une chaîne JSX qui invite l'utilisateur à installer MetaMask.
+  - S'il est activé, nous configurons l'écouteur `window.ethereum.on("accountsChanged")` à la ligne 3 qui écoute les changements d'état dans le portefeuille MetaMask, qui incluent le moment où l'utilisateur connecte un compte supplémentaire à la dapp, change de compte ou déconnecte un compte. S'il y a au moins un compte connecté, la variable d'état `walletAddress` est mise à jour en tant que premier compte dans le tableau `accounts` renvoyé par l'écouteur. Sinon, `walletAddress` est défini comme une chaîne vide.
 
 Enfin, nous devons l'appeler dans notre fonction `useEffect` :
 
@@ -463,11 +465,11 @@ useEffect(async () => {
 
 Et voilà ! Nous avons terminé la programmation de toutes les fonctionnalités de notre portefeuille ! Maintenant que notre portefeuille est configuré, regardons comment créer notre NFT !
 
-## Métadonnées NFT 101 {#nft-metadata-101}
+## NFT Metadonnées 101 {#nft-metadata-101}
 
 Rappelez-vous que les métadonnées NFT dont nous venons de parler à l'étape 0 de ce tutoriel, donnent vie à un NFT, lui permettant d'avoir des propriétés, comme un actif numérique, un nom, une description et d'autres attributs.
 
-Nous allons devoir configurer ces métadonnées sous forme d'objet JSON et les stocker, afin de pouvoir les transmettre en tant que paramètre `tokenURI` lors de l'appel de la fonction `mintNFT` de notre contrat intelligent.
+Nous allons devoir configurer ces métadonnées en tant qu'objet JSON et les stocker, afin de pouvoir les transmettre en tant que paramètre `tokenURI` lors de l'appel de la fonction `mintNFT` de notre contrat intelligent.
 
 Le texte des champs « Lien vers l'actif », « Nom » et « Description » comprendra les différentes propriétés des métadonnées de notre NFT. Nous allons formater ces métadonnées sous la forme d'un objet JSON, mais il existe plusieurs options pour le stockage de cet objet JSON :
 
@@ -475,39 +477,39 @@ Le texte des champs « Lien vers l'actif », « Nom » et « Description » comp
 - Nous pourrions le stocker sur un serveur centralisé, comme AWS ou Firebase. Mais cela irait à l'encontre de notre philosophie de décentralisation.
 - Nous pourrions utiliser IPFS, un protocole décentralisé et un réseau peer-to-peer pour stocker et partager des données dans un système de fichiers distribué. Comme ce protocole est décentralisé et gratuit, c'est notre meilleure option !
 
-Pour stocker nos métadonnées sur IPFS, nous allons utiliser [Pinata](https://pinata.cloud/), une API et une boîte à outils IPFS très pratique. Dans l'étape suivante, nous vous expliquerons exactement comment faire !
+Pour stocker nos métadonnées sur IPFS, nous utiliserons [Pinata](https://pinata.cloud/), une API et une boîte à outils IPFS pratiques. Dans l'étape suivante, nous vous expliquerons exactement comment faire !
 
 ## Utiliser Pinata pour épingler vos métadonnées sur IPFS {#use-pinata-to-pin-your-metadata-to-IPFS}
 
-Si vous n'avez pas de compte [Pinata](https://pinata.cloud/), créez-vous un compte gratuit [ici](https://app.pinata.cloud/auth/signup) et suivez les étapes pour vérifier votre mail et votre compte.
+Si vous n'avez pas de compte [Pinata](https://pinata.cloud/), créez un compte gratuit [ici](https://app.pinata.cloud/auth/signup) et suivez les étapes pour vérifier votre e-mail et votre compte.
 
-### Créer votre clé API Pinata {#create-pinata-api-key}
+### Créez votre clé API Pinata {#create-pinata-api-key}
 
-Naviguez vers la page [https://pinata.cloud/keys](https://pinata.cloud/keys), puis sélectionnez le bouton « New Key » en haut, activez le widget Admin et nommez votre clé.
+Accédez à la page [https://pinata.cloud/keys](https://pinata.cloud/keys), puis sélectionnez le bouton « Nouvelle clé » en haut, activez le widget Admin et nommez votre clé.
 
 Vous verrez ensuite une popup avec vos infos d'API. Assurez-vous de mettre cela dans un endroit sûr.
 
 Maintenant que notre clé est configurée, ajoutons-la à notre projet pour que nous puissions l'utiliser.
 
-### Créer un fichier `.env` {#create-a-env}
+### Créer un fichier .env {#create-a-env}
 
-Nous pouvons stocker en toute sécurité notre clé et notre secret Pinata dans un fichier d'environnement. Installons le paquet [dotenv](https://www.npmjs.com/package/dotenv) dans le répertoire de votre projet.
+Nous pouvons stocker en toute sécurité notre clé et notre secret Pinata dans un fichier d'environnement. Installons le [paquetage dotenv](https://www.npmjs.com/package/dotenv) dans le répertoire de votre projet.
 
-Ouvrez un nouvel onglet dans votre terminal \(distinct de celui qui exécute l'hôte local\) et assurez-vous que vous êtes dans le dossier `starter`, puis exécutez la commande suivante dans votre terminal :
+Ouvrez un nouvel onglet dans votre terminal (distinct de celui qui exécute l'hôte local) et assurez-vous que vous êtes dans le dossier `minter-starter-files`, puis exécutez la commande suivante dans votre terminal :
 
 ```text
 npm install dotenv --save
 ```
 
-Ensuite, créez un fichier `.env` dans le répertoire racine de vos `minter-starter-files` en entrant ce qui suit sur votre ligne de commande :
+Ensuite, créez un fichier `.env` dans le répertoire racine de votre `minter-starter-files` en saisissant ce qui suit sur votre ligne de commande :
 
 ```javascript
 vim.env
 ```
 
-Ceci ouvrira votre fichier `.env` dans vim (un éditeur de texte). Pour l'enregistrer, appuyez sur « esc » + « : » + « q » sur votre clavier et dans cet ordre.
+Cela ouvrira votre fichier `.env` dans vim (un éditeur de texte). Pour l'enregistrer, appuyez sur « esc » + « : » + « q » sur votre clavier et dans cet ordre.
 
-Ensuite, dans VSCode, accédez à votre fichier `.env` et ajoutez votre clé API Pinata et votre secret API Secret, comme ceci :
+Ensuite, dans VSCode, accédez à votre fichier `.env` et ajoutez-y votre clé API et votre secret API Pinata, comme ceci :
 
 ```text
 REACT_APP_PINATA_KEY = <pinata-api-key>
@@ -518,9 +520,9 @@ Enregistrez le fichier et vous êtes prêt à commencer à écrire la fonction p
 
 ### Implémenter pinJSONToIPFS {#pin-json-to-ipfs}
 
-Heureusement pour nous, Pinata a une [API spécifique pour télécharger des données JSON sur IPFS](https://docs.pinata.cloud/api-reference/endpoint/ipfs/pin-json-to-ipfs#pin-json) et un JavaScript pratique avec un exemple d'axios que nous pouvons utiliser en opérant juste quelques petites modifications.
+Heureusement pour nous, Pinata dispose d'une [API spécialement conçue pour téléverser des données JSON vers IPFS](https://docs.pinata.cloud/api-reference/endpoint/ipfs/pin-json-to-ipfs#pin-json) et d'un exemple pratique JavaScript avec axios que nous pouvons utiliser, avec quelques légères modifications.
 
-Dans votre dossier `utils`, créons un autre fichier appelé `pinata.js` puis importez notre clé secrète Pinata à partir du fichier `.env` comme suit :
+Dans votre dossier `utils`, créons un autre fichier appelé `pinata.js`, puis importons notre secret et notre clé Pinata depuis le fichier .env comme ceci :
 
 ```javascript
 require("dotenv").config()
@@ -539,7 +541,7 @@ const axios = require("axios")
 
 export const pinJSONToIPFS = async (JSONBody) => {
   const url = `https://api.pinata.cloud/pinning/pinJSONToIPFS`
-  //making axios POST request to Pinata ⬇️
+  //faire une requête POST axios à Pinata ⬇️
   return axios
     .post(url, JSONBody, {
       headers: {
@@ -566,32 +568,32 @@ export const pinJSONToIPFS = async (JSONBody) => {
 
 Alors, que fait ce code exactement ?
 
-Tout d'abord, il importe [axios](https://www.npmjs.com/package/axios), un client basé HTTP en devenir pour le navigateur et le `node.js`, que nous utiliserons pour réaliser une requête à Pinata.
+Tout d'abord, il importe [axios](https://www.npmjs.com/package/axios), un client HTTP basé sur les promesses pour le navigateur et node.js, que nous utiliserons pour faire une requête à Pinata.
 
-Ensuite, nous avons notre fonction asynchrone `pinJSONToIPFS`, qui prend un `JSONBody` en entrée et la clé API Pinata et secret dans son en-tête, pour faire une requête POST à leur API `pinJSONToIPFS`.
+Ensuite, nous avons notre fonction asynchrone `pinJSONToIPFS`, qui prend un `JSONBody` en entrée et la clé et le secret de l'API Pinata dans son en-tête, le tout pour effectuer une requête POST à leur API `pinJSONToIPFS`.
 
-- Si cette requête POST réussie, alors notre fonction retourne un objet JSON avec le booléen `success` comme `true` et la `pinataUrl` où nos métadonnées ont été épinglées. Nous utiliserons cette `pinataUrl` retournée comme entrée `tokenURI` de la fonction de `mint` de notre contrat intelligent.
-- Si cette requête POST échoue, alors notre fonction retourne un objet JSON avec le booléen `success` comme `false` et une chaîne de caractères `message` qui relaie notre erreur.
+- Si cette requête POST réussit, notre fonction renvoie un objet JSON avec le booléen `success` à « true » et l'`pinataUrl` où nos métadonnées ont été épinglées. Nous utiliserons cette `pinataUrl` renvoyée comme entrée `tokenURI` pour la fonction de frappe de notre contrat intelligent.
+- Si cette requête POST échoue, notre fonction renvoie un objet JSON avec le booléen `success` à « false » et une chaîne `message` qui relaie notre erreur.
 
-Comme avec notre fonction de types retournés `connectWallet`, nous retournons des objets JSON afin que nous puissions utiliser leurs paramètres pour mettre à jour nos variables d'état et notre interface utilisateur.
+Comme pour les types de retour de notre fonction `connectWallet`, nous renvoyons des objets JSON afin de pouvoir utiliser leurs paramètres pour mettre à jour nos variables d'état et notre interface utilisateur.
 
 ## Charger votre contrat intelligent {#load-your-smart-contract}
 
-Maintenant que nous avons un moyen d'envoyer nos métadonnées NFT vers IPFS via notre fonction `pinJSONToIPFS`, nous allons avoir besoin d'un moyen de charger une instance de notre contrat intelligent afin que nous puissions appeler sa fonction `mintNFT`.
+Maintenant que nous avons un moyen de téléverser nos métadonnées NFT sur IPFS via notre fonction `pinJSONToIPFS`, nous allons avoir besoin d'un moyen de charger une instance de notre contrat intelligent afin de pouvoir appeler sa fonction `mintNFT`.
 
-Comme nous l'avons mentionné précédemment dans ce tutoriel, nous utiliserons [ce contrat intelligent NFT existant](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE). Cependant, si vous souhaitez apprendre comment nous avons fait, en faire un par vous-même, nous vous recommandons vivement de consulter notre autre tutoriel, ["Comment créer un NFT](https://docs.alchemyapi.io/alchemy/tutorials/how-to-create-an-nft).
+Comme nous l'avons mentionné précédemment, dans ce tutoriel, nous utiliserons [ce contrat intelligent de NFT existant](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE) ; cependant, si vous souhaitez apprendre comment nous l'avons créé, ou en créer un vous-même, nous vous recommandons vivement de consulter notre autre tutoriel, ["Comment créer un NFT."](https://www.alchemy.com/docs/how-to-create-an-nft).
 
-### Le contrat ABI {#contract-abi}
+### L'ABI du contrat {#contract-abi}
 
-Si vous avez examiné en détail nos fichiers, vous aurez remarqué que dans notre répertoire `src`, il existe un fichier `contract-abi.json`. Une ABI est nécessaire pour spécifier quelle fonction un contrat invoquera en s'assurant également que la fonction retournera des données dans le format que vous attendez.
+Si vous avez examiné attentivement nos fichiers, vous aurez remarqué que dans notre répertoire `src`, il y a un fichier `contract-abi.json`. Une ABI est nécessaire pour spécifier quelle fonction un contrat invoquera en s'assurant également que la fonction retournera des données dans le format que vous attendez.
 
 Nous allons également avoir besoin d'une clé API Alchemy et de l'API Alchemy Web3 pour nous connecter à la blockchain Ethereum et charger notre contrat intelligent.
 
-### Créer votre clé API Alchemy {#create-alchemy-api}
+### Créez votre clé API Alchemy {#create-alchemy-api}
 
-Si vous n'avez pas déjà un compte Alchemy, vous pouvez [vous inscrire gratuitement ici](https://alchemy.com/?a=eth-org-nft-minter).
+Si vous n'avez pas encore de compte Alchemy, [inscrivez-vous gratuitement ici.](https://alchemy.com/?a=eth-org-nft-minter)
 
-Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela nous permettra de réaliser des requêtes sur le réseau de test Ropsten.
+Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela va nous permettre d'émettre des requêtes sur le réseau de test Ropsten.
 
 Accédez à la page "Create App" dans votre Tableau de bord Alchemy, en survolant "Apps" dans la barre de navigation et en cliquant sur "Create App".
 
@@ -601,7 +603,7 @@ Cliquez sur « Create app », et voilà ! Votre application devrait apparaître
 
 Génial ! Maintenant que nous avons créé notre URL pour l'API HTTP Alchemy, copiez-la dans votre presse-papiers...
 
-…puis ajoutons-la à notre fichier `.env`. Dans l'ensemble, votre fichier `.env` devrait ressembler à ceci :
+…et ensuite ajoutons-la à notre fichier `.env`. Dans l'ensemble, votre fichier <code>.env</code> devrait ressembler à ceci :
 
 ```text
 REACT_APP_PINATA_KEY = <pinata-key>
@@ -609,18 +611,18 @@ REACT_APP_PINATA_SECRET = <pinata-secret>
 REACT_APP_ALCHEMY_KEY = https://eth-ropsten.alchemyapi.io/v2/<alchemy-key>
 ```
 
-Maintenant que nous avons notre contrat ABI et notre clé API Alchemy, nous sommes prêts à charger notre contrat intelligent en utilisant [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3).
+Maintenant que nous avons notre ABI de contrat et notre clé d'API Alchemy, nous sommes prêts à charger notre contrat intelligent en utilisant [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3).
 
-### Configurer votre point de terminaison Alchemy Web3 et votre contrat {#setup-alchemy-endpoint}
+### Configurer votre point de terminaison et votre contrat Alchemy Web3 {#setup-alchemy-endpoint}
 
-Tout d'abord, si vous ne l'avez pas déjà fait, vous devrez installer [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) en naviguant dans le répertoire principal : `nft-minter-tutorial` dans le terminal :
+Tout d'abord, si vous ne l'avez pas déjà, vous devrez installer [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) en naviguant vers le répertoire de base : `nft-minter-tutorial` dans le terminal :
 
 ```text
 cd ..
 npm install @alch/alchemy-web3
 ```
 
-Ensuite, revenons à notre fichier `interact.js`. En haut du fichier, ajoutez le code suivant pour importer votre clé Alchemy à partir de votre fichier `.env` et configurez votre point de terminaison Alchemy Web3 :
+Revenons maintenant à notre fichier `interact.js`. En haut du fichier, ajoutez le code suivant pour importer votre clé Alchemy à partir de votre fichier <code>.env</code> et configurez votre point de terminaison Alchemy Web3 :
 
 ```javascript
 require("dotenv").config()
@@ -629,7 +631,7 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
 const web3 = createAlchemyWeb3(alchemyKey)
 ```
 
-[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) est un wrapper autour de [Web3.js](https://docs.web3js.org/), fournissant des méthodes API améliorées et d'autres avantages pour faciliter votre vie en tant que développeur Web3. Il est conçu pour nécessiter une configuration minimale afin que vous puissiez commencer à l'utiliser immédiatement dans votre application !
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) est un wrapper autour de [Web3.js](https://docs.web3js.org/), qui fournit des méthodes API améliorées et d'autres avantages cruciaux pour vous faciliter la vie en tant que développeur web3. Il est conçu pour nécessiter une configuration minimale afin que vous puissiez commencer à l'utiliser immédiatement dans votre application !
 
 Ensuite, ajoutons notre contrat ABI et l'adresse de notre contrat à notre fichier.
 
@@ -647,99 +649,99 @@ Une fois que nous avons les deux, nous sommes prêts à commencer à coder notre
 
 ## Implémenter la fonction mintNFT {#implement-the-mintnft-function}
 
-Dans votre fichier `interact.js`, définissons notre fonction, `mintNFT`, qui comme son nom l'indique va frapper notre NFT.
+À l'intérieur de votre fichier `interact.js`, définissons notre fonction, `mintNFT`, qui, comme son nom l'indique, frappera notre NFT.
 
 Parce que nous allons réaliser de nombreux appels asynchrones (à Pinata pour épingler nos métadonnées à IPFS, Alchemy Web3 pour charger notre contrat intelligent, et MetaMask pour signer nos transactions), notre fonction sera également asynchrone.
 
-Les trois entrées de notre fonction seront l'`url` de notre actif numérique, `name`, et `description`. Ajoutez la signature de fonction suivante sous la fonction `connectWallet` :
+Les trois entrées de notre fonction seront l'`url` de notre actif numérique, le `name` et la `description`. Ajoutez la signature de fonction suivante sous la fonction `connectWallet` :
 
 ```javascript
 export const mintNFT = async (url, name, description) => {}
 ```
 
-### Gestion des erreurs d'entrée {#input-error-handling}
+### Gestion des erreurs de saisie {#input-error-handling}
 
 Naturellement, il est logique d'avoir une sorte de gestion des erreurs d'entrée au début de la fonction et ainsi, nous quitterons cette fonction si nos paramètres d'entrée ne sont pas corrects. Dans notre fonction, ajoutons le code suivant :
 
 ```javascript
 export const mintNFT = async (url, name, description) => {
-  //error handling
+  //gestion des erreurs
   if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
     return {
       success: false,
-      status: "❗Please make sure all fields are completed before minting.",
+      status: "❗Veuillez vous assurer que tous les champs sont remplis avant la frappe.",
     }
   }
 }
 ```
 
-Si l'un des paramètres d'entrée est une chaîne de caractères vide, alors nous retournons un objet JSON où le booléen `succes` est `false`, et les relais de chaîne de caractère `status` signalent que tous les champs de notre interface utilisateur doivent être complétés.
+Essentiellement, si l'un des paramètres d'entrée est une chaîne vide, nous renvoyons un objet JSON où le booléen `success` est à « false », et la chaîne `status` relaie que tous les champs de notre interface utilisateur doivent être remplis.
 
-### Télécharger les métadonnées sur IPFS {#upload-metadata-to-ipfs}
+### Téléverser les métadonnées sur IPFS {#upload-metadata-to-ipfs}
 
-Une fois que nous savons que nos métadonnées sont correctement formatées, la prochaine étape est de l'envelopper dans un objet JSON et de le charger sur IPFS via le `pinJSONToIPFS` que nous avons écrit !
+Une fois que nous savons que nos métadonnées sont formatées correctement, l'étape suivante consiste à les envelopper dans un objet JSON et à les téléverser sur IPFS via le `pinJSONToIPFS` que nous avons écrit !
 
-Pour ce faire, nous devons d'abord importer la fonction `pinJSONToIPFS` dans notre fichier `interact.js`. Tout en haut de `interact.js`, ajoutons :
+Pour ce faire, nous devons d'abord importer la fonction `pinJSONToIPFS` dans notre fichier `interact.js`. Tout en haut du fichier `interact.js`, ajoutons :
 
 ```javascript
 import { pinJSONToIPFS } from "./pinata.js"
 ```
 
-Rappelez-vous que `pinJSONToIPFS` prend dans un corps JSON. Ainsi, avant de passer un appel, nous allons devoir formater nos paramètres `url`, `name`, et `description` dans un objet JSON.
+Rappelez-vous que `pinJSONToIPFS` prend un corps JSON. Ainsi, avant de l'appeler, nous allons devoir formater nos paramètres `url`, `name` et `description` dans un objet JSON.
 
-Mettons à jour notre code pour créer un objet JSON appelé `metadata` puis appelons `pinJSONToIPFS` avec ce paramètre `metadata` :
+Mettons à jour notre code pour créer un objet JSON appelé `metadata`, puis appelons `pinJSONToIPFS` avec ce paramètre `metadata` :
 
 ```javascript
 export const mintNFT = async (url, name, description) => {
-  //error handling
+  //gestion des erreurs
   if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
     return {
       success: false,
-      status: "❗Please make sure all fields are completed before minting.",
+      status: "❗Veuillez vous assurer que tous les champs sont remplis avant la frappe.",
     }
   }
 
-  //make metadata
+  //créer les métadonnées
   const metadata = new Object()
   metadata.name = name
   metadata.image = url
   metadata.description = description
 
-  //make pinata call
+  //faire un appel pinata
   const pinataResponse = await pinJSONToIPFS(metadata)
   if (!pinataResponse.success) {
     return {
       success: false,
-      status: "😢 Something went wrong while uploading your tokenURI.",
+      status: "😢 Une erreur s'est produite lors du téléversement de votre tokenURI.",
     }
   }
   const tokenURI = pinataResponse.pinataUrl
 }
 ```
 
-Attention, nous stockons la réponse de notre appel à `pinJSONToIPFS(metadata)` dans l'objet `pinataResponse`. Ensuite, nous analysons cet objet pour vérifier les erreurs.
+Notez que nous stockons la réponse de notre appel à `pinJSONToIPFS(metadata)` dans l'objet `pinataResponse`. Ensuite, nous analysons cet objet pour vérifier les erreurs.
 
-S'il existe une erreur, nous retournons un objet JSON où le booléen `success` est `false` et que notre chaîne de caractères `status` nous signale que notre appel a échoué. Sinon, nous extrayons `pinataURL` de `pinataResponse` et la stockons comme notre variable `tokenURI`.
+En cas d'erreur, nous renvoyons un objet JSON où le booléen `success` est à « false » et notre chaîne `status` relaie que notre appel a échoué. Sinon, nous extrayons la `pinataURL` de la `pinataResponse` et la stockons en tant que notre variable `tokenURI`.
 
-Maintenant, il est temps de charger notre contrat intelligent en utilisant l'API Alchemy Web3 que nous avons initialisée en haut de notre fichier. Ajoutez la ligne de code suivante au bas de la fonction `mintNFT` pour définir le contrat sur la variable globale `window.contract` :
+Maintenant, il est temps de charger notre contrat intelligent en utilisant l'API Alchemy Web3 que nous avons initialisée en haut de notre fichier. Ajoutez la ligne de code suivante au bas de la fonction `mintNFT` pour définir le contrat dans la variable globale `window.contract` :
 
 ```javascript
 window.contract = await new web3.eth.Contract(contractABI, contractAddress)
 ```
 
-La dernière chose à ajouter à notre fonction `mintNFT` est notre transaction Ethereum :
+La dernière chose à ajouter dans notre fonction `mintNFT` est notre transaction Ethereum :
 
 ```javascript
-//set up your Ethereum transaction
+//configurer votre transaction Ethereum
 const transactionParameters = {
-  to: contractAddress, // Required except during contract publications.
-  from: window.ethereum.selectedAddress, // must match user's active address.
+  to: contractAddress, // Requis sauf lors des publications de contrats.
+  from: window.ethereum.selectedAddress, // doit correspondre à l'adresse active de l'utilisateur.
   data: window.contract.methods
     .mintNFT(window.ethereum.selectedAddress, tokenURI)
-    .encodeABI(), //make call to NFT smart contract
+    .encodeABI(), //faire appel au contrat intelligent NFT
 }
 
-//sign the transaction via MetaMask
+//signer la transaction via MetaMask
 try {
   const txHash = await window.ethereum.request({
     method: "eth_sendTransaction",
@@ -748,13 +750,13 @@ try {
   return {
     success: true,
     status:
-      "✅ Check out your transaction on Etherscan: https://ropsten.etherscan.io/tx/" +
+      "✅ Consultez votre transaction sur Etherscan : https://ropsten.etherscan.io/tx/" +
       txHash,
   }
 } catch (error) {
   return {
     success: false,
-    status: "😥 Something went wrong: " + error.message,
+    status: "😥 Quelque chose s'est mal passé : " + error.message,
   }
 }
 ```
@@ -762,54 +764,54 @@ try {
 Si vous êtes déjà familier avec les transactions Ethereum, vous remarquerez que la structure est assez similaire à ce que vous avez déjà vu.
 
 - Tout d'abord, nous configurons nos paramètres de transactions.
-  - `to` spécifie l'adresse du destinataire \(notre contrat intelligent)
-  - `from` spécifie le signataire de la transaction (l'adresse de l'utilisateur connectée à MetaMask : `window.ethereum.selectedAddress`)
-  - `data` contient l'appel à la méthode `mintNFT` de notre contrat intelligent , qui reçoit notre `tokenURI` et l'adresse du portefeuille de l'utilisateur, `window.ethereum.selectedAddress`, comme des entrées.
-- Ensuite, nous faisons un appel en attente, `window.ethereum.request,` où nous demandons à MetaMask de signer la transaction. Remarquez que dans cette requête, nous spécifions notre méthode ETH \(`eth_SentTransaction`) et en la passant dans nos `transactionParameters`. À ce stade, MetaMask s'ouvrira dans le navigateur, et demandera à l'utilisateur de signer ou rejeter la transaction.
-  - Si la transaction est réussie, la fonction retournera un objet JSON où le booléen `success` sera défini comme vrai et la chaîne `status` invitera l'utilisateur à consulter Etherscan pour plus d'informations sur sa transaction.
-  - Si la transaction échoue, la fonction retournera un objet JSON où le booléen `success` sera défini comme faux, et la chaîne de caractères `status` renverra un message d'erreur.
+  - `to` spécifie l'adresse du destinataire (notre contrat intelligent)
+  - `from` spécifie le signataire de la transaction (l'adresse connectée de l'utilisateur à MetaMask : `window.ethereum.selectedAddress`)
+  - `data` contient l'appel à la méthode `mintNFT` de notre contrat intelligent, qui reçoit notre `tokenURI` et l'adresse du portefeuille de l'utilisateur, `window.ethereum.selectedAddress`, comme entrées
+- Ensuite, nous effectuons un appel en attente, `window.ethereum.request`, où nous demandons à MetaMask de signer la transaction. Notez que, dans cette requête, nous spécifions notre méthode eth (`eth_SentTransaction`) et nous transmettons nos `transactionParameters`. À ce stade, MetaMask s'ouvrira dans le navigateur, et demandera à l'utilisateur de signer ou rejeter la transaction.
+  - Si la transaction réussit, la fonction renverra un objet JSON où le booléen `success` est à « true » et la chaîne `status` invite l'utilisateur à consulter Etherscan pour plus d'informations sur sa transaction.
+  - Si la transaction échoue, la fonction renverra un objet JSON où le booléen `success` est à « false », et la chaîne `status` relaie le message d'erreur.
 
-Dans l'ensemble, notre fonction `mintNFT` devrait ressembler à ceci :
+Au total, notre fonction `mintNFT` devrait ressembler à ceci :
 
 ```javascript
 export const mintNFT = async (url, name, description) => {
-  //error handling
+  //gestion des erreurs
   if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
     return {
       success: false,
-      status: "❗Please make sure all fields are completed before minting.",
+      status: "❗Veuillez vous assurer que tous les champs sont remplis avant la frappe.",
     }
   }
 
-  //make metadata
+  //créer les métadonnées
   const metadata = new Object()
   metadata.name = name
   metadata.image = url
   metadata.description = description
 
-  //pinata pin request
+  //requête d'épinglage pinata
   const pinataResponse = await pinJSONToIPFS(metadata)
   if (!pinataResponse.success) {
     return {
       success: false,
-      status: "😢 Something went wrong while uploading your tokenURI.",
+      status: "😢 Une erreur s'est produite lors du téléversement de votre tokenURI.",
     }
   }
   const tokenURI = pinataResponse.pinataUrl
 
-  //load smart contract
+  //charger le contrat intelligent
   window.contract = await new web3.eth.Contract(contractABI, contractAddress) //loadContract();
 
-  //set up your Ethereum transaction
+  //configurer votre transaction Ethereum
   const transactionParameters = {
-    to: contractAddress, // Required except during contract publications.
-    from: window.ethereum.selectedAddress, // must match user's active address.
+    to: contractAddress, // Requis sauf lors des publications de contrats.
+    from: window.ethereum.selectedAddress, // doit correspondre à l'adresse active de l'utilisateur.
     data: window.contract.methods
       .mintNFT(window.ethereum.selectedAddress, tokenURI)
-      .encodeABI(), //make call to NFT smart contract
+      .encodeABI(), //faire appel au contrat intelligent NFT
   }
 
-  //sign transaction via MetaMask
+  //signer la transaction via MetaMask
   try {
     const txHash = await window.ethereum.request({
       method: "eth_sendTransaction",
@@ -818,23 +820,23 @@ export const mintNFT = async (url, name, description) => {
     return {
       success: true,
       status:
-        "✅ Check out your transaction on Etherscan: https://ropsten.etherscan.io/tx/" +
+        "✅ Consultez votre transaction sur Etherscan : https://ropsten.etherscan.io/tx/" +
         txHash,
     }
   } catch (error) {
     return {
       success: false,
-      status: "😥 Something went wrong: " + error.message,
+      status: "😥 Quelque chose s'est mal passé : " + error.message,
     }
   }
 }
 ```
 
-C'est une fonction géante ! Maintenant, nous avons juste besoin de connecter notre fonction `mintNFT` à notre composant `Minter.js`...
+C'est une fonction géante ! Maintenant, nous devons simplement connecter notre fonction `mintNFT` à notre composant `Minter.js`...
 
 ## Connecter mintNFT à notre frontend Minter.js {#connect-our-frontend}
 
-Ouvrez votre fichier `Minter.js` et mettez à jour la ligne du haut `import{ connectWallet, getCurrentWalletConnected } from "./utils/interact.js";` pour devenir :
+Ouvrez votre fichier `Minter.js` et mettez à jour la ligne `import { connectWallet, getCurrentWalletConnected } from "./utils/interact.js";` en haut pour :
 
 ```javascript
 import {
@@ -844,7 +846,7 @@ import {
 } from "./utils/interact.js"
 ```
 
-Enfin, implémentez la fonction `onMintPressed` pour faire attendre l'appel à votre fonction importée `mintNFT` et mettez à jour la variable d'état `status` pour refléter si notre transaction a réussi ou a échoué :
+Enfin, implémentez la fonction `onMintPressed` pour faire un appel en attente vers votre fonction `mintNFT` importée et mettre à jour la variable d'état `status` pour refléter si notre transaction a réussi ou a échoué :
 
 ```javascript
 const onMintPressed = async () => {
@@ -853,22 +855,22 @@ const onMintPressed = async () => {
 }
 ```
 
-## Déployer votre NFT sur un site Web en ligne {#deploy-your-NFT}
+## Déployez votre NFT sur un site web en direct {#deploy-your-NFT}
 
-Prêt à mettre en ligne votre projet pour que les utilisateurs puissent interagir avec ? Consultez [ce tutoriel](https://docs.alchemy.com/alchemy/tutorials/nft-minter/how-do-i-deploy-nfts-online) pour déployer votre Minter sur un site Web directement.
+Prêt à mettre en ligne votre projet pour que les utilisateurs puissent interagir avec ? Consultez [ce tutoriel](https://docs.alchemy.com/alchemy/tutorials/nft-minter/how-do-i-deploy-nfts-online) pour déployer votre Minter sur un site web en direct.
 
 Encore une dernière étape...
 
-## Prendre d'assaut le monde de la blockchain {#take-the-blockchain-world-by-storm}
+## Prenez d'assaut le monde de la blockchain {#take-the-blockchain-world-by-storm}
 
 Je plaisante, vous êtes arrivé à la fin du tutoriel !
 
 Pour récapituler, en construisant un Minter de NFT, vous avez appris avec succès à :
 
 - Vous connecter à MetaMask via votre projet en frontend
-- Appeler les méthodes du contrat intelligent depuis votre interface en frontend
+- Appeler les méthodes du contrat intelligent depuis votre interface
 - Signer des transactions à l'aide de MetaMask
 
-Sans doute vous aimeriez pouvoir montrer les NFT mis à jour via votre dApp dans votre portefeuille — alors n'oubliez pas de consulter notre bref tutoriel : [Comment consulter votre NFT dans votre portefeuille](https://docs.alchemyapi.io/alchemy/tutorials/how-to-write-and-deploy-a-nft-smart-contract/how-to-view-your-nft-in-your-wallet) !
+Vraisemblablement, vous aimeriez pouvoir montrer les NFT frappés via votre dapp dans votre portefeuille — alors n'oubliez pas de consulter notre tutoriel rapide [Comment voir votre NFT dans votre portefeuille](https://www.alchemy.com/docs/how-to-view-your-nft-in-your-mobile-wallet) !
 
-Et, comme toujours, si vous avez des questions, nous sommes là pour vous aider dans le [Discord Alchemy](https://discord.gg/gWuC7zB). Nous avons hâte de voir comment vous appliquez les concepts de ce tutoriel à vos futurs projets !
+Et, comme toujours, si vous avez des questions, nous sommes là pour vous aider dans le [Discord d'Alchemy](https://discord.gg/gWuC7zB). Nous avons hâte de voir comment vous appliquez les concepts de ce tutoriel à vos futurs projets !
diff --git a/public/content/translations/fr/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/fr/developers/tutorials/optimism-std-bridge-annotated-code/index.md
index 62c03df2159..6f8799a03b4 100644
--- a/public/content/translations/fr/developers/tutorials/optimism-std-bridge-annotated-code/index.md
+++ b/public/content/translations/fr/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -1,84 +1,89 @@
 ---
-title: "Introduction au contrat de passerelle standard Optimism"
-description: Comment fonctionne la passerelle standard d'Optimism ? Pourquoi fonctionne-t-elle de cette façon ?
+title: "Présentation du contrat de pont standard d'Optimism"
+description: "Comment fonctionne le pont standard d'Optimism ? Pourquoi fonctionne-t-il de cette manière ?"
 author: Ori Pomerantz
-tags:
-  - "solidity"
-  - "bridge"
-  - "Couche 2"
+tags: [ "Solidity", "pont", "couche 2" ]
 skill: intermediate
 published: 2022-03-30
 lang: fr
 ---
 
-[Optimism](https://www.optimism.io/) est un [rollup optimiste](/developers/docs/scaling/optimistic-rollups/). Les rollups Optimistics peuvent traiter les transactions à un prix beaucoup plus bas que le réseau principal Ethereum (également connu sous le nom de couche 1 ou L1), car les transactions sont traitées uniquement par quelques nœuds en lieu et place de tous les nœuds du réseau. En même temps, les données sont toutes écrites sur L1 afin que tout puisse être prouvé et reconstruit avec toutes les garanties d'intégrité et de disponibilité du réseau principal.
+[Optimism](https://www.optimism.io/) est un [rollup optimiste](/developers/docs/scaling/optimistic-rollups/).
+Les rollups optimistes peuvent traiter les transactions à un prix beaucoup plus bas que le réseau principal Ethereum (également connu sous le nom de couche 1 ou L1), car les transactions sont traitées uniquement par quelques nœuds, au lieu de chaque nœud sur le réseau.
+En même temps, toutes les données sont écrites sur la L1 afin que tout puisse être prouvé et reconstruit avec toutes les garanties d'intégrité et de disponibilité du réseau principal.
 
-Pour utiliser les actifs L1 sur Optimism (ou n'importe quel autre L2), les actifs doivent être [connectés](/bridges/#prerequisites). Une façon d'y arriver est pour les utilisateurs de verrouiller les actifs (ETH et les [jetons ERC-20](/developers/docs/standards/tokens/erc-20/) sont les plus communs) sur L1 et de recevoir des actifs équivalents à utiliser sur L2. Finalement, celui qui se retrouve avec souhaitera peut-être les ramener en L1. En faisant cela, les actifs sont brûlés sur L2 puis redistribués à l'utilisateur sur L1.
+Pour utiliser les actifs de L1 sur Optimism (ou toute autre L2), les actifs doivent être [pontés](/bridges/#prerequisites).
+Une façon d'y parvenir est pour les utilisateurs de verrouiller des actifs (l'ETH et les [jetons ERC-20](/developers/docs/standards/tokens/erc-20/) sont les plus courants) sur la L1, et de recevoir des actifs équivalents à utiliser sur la L2.
+Finalement, quiconque se retrouve avec ces actifs pourrait vouloir les ponter à nouveau vers la L1.
+Ce faisant, les actifs sont brûlés sur la L2, puis restitués à l'utilisateur sur la L1.
 
-C'est ainsi que fonctionne la [passerelle standard Optimism](https://docs.optimism.io/app-developers/bridging/standard-bridge). Dans cet article, nous passerons en revue le code source de cette passerelle pour comprendre comment elle fonctionne et l'étudier comme un exemple de code Solidity parfaitement écrit.
+C'est ainsi que fonctionne le [pont standard d'Optimism](https://docs.optimism.io/app-developers/bridging/standard-bridge).
+Dans cet article, nous passons en revue le code source de ce pont pour voir comment il fonctionne et l'étudier comme un exemple de code Solidity bien écrit.
 
 ## Flux de contrôle {#control-flows}
 
-La passerelle dispose de deux flux principaux :
+Le pont a deux flux principaux :
 
-- Dépôt (de L1 vers L2)
-- Retrait (de L2 vers L1)
+- Dépôt (de L1 à L2)
+- Retrait (de L2 à L1)
 
 ### Flux de dépôt {#deposit-flow}
 
 #### Couche 1 {#deposit-flow-layer-1}
 
-1. En cas de dépôt d'un ERC-20, le déposant affecte à la passerelle une provision pour dépenser le montant déposé
-2. Le déposant appelle la passerelle L1 (`depositERC20`, `depositERC20To`, `depositETH`, ou `depositETHTo`)
-3. La passerelle L1 prend possession de l'actif connecté
-   - ETH : l'actif est transféré par le déposant dans le cadre de l'appel
-   - ERC-20 : l'actif est transféré par la passerelle à elle-même en utilisant la provision fournie par le déposant
-4. La passerelle de connexion L1 utilise le mécanisme de message inter-domaine pour appeler `finalizeDeposit` sur la passerelle de connexion L2
+1. En cas de dépôt d'un ERC-20, le déposant donne au pont une autorisation de dépenser le montant déposé
+2. Le déposant appelle le pont L1 (`depositERC20`, `depositERC20To`, `depositETH` ou `depositETHTo`)
+3. Le pont L1 prend possession de l'actif ponté
+   - ETH : L'actif est transféré par le déposant dans le cadre de l'appel
+   - ERC-20 : L'actif est transféré par le pont à lui-même en utilisant l'autorisation fournie par le déposant
+4. Le pont L1 utilise le mécanisme de message inter-domaines pour appeler `finalizeDeposit` sur le pont L2
 
 #### Couche 2 {#deposit-flow-layer-2}
 
-5. La passerelle de connexion L2 vérifie que l'appel `finalizeDeposit` est légitime :
-   - Provient du contrat de message inter-domaine
-   - Était à l'origine en provenance de la passerelle de connexion sur L1
-6. La passerelle de connexion L2 vérifie si le contrat de jeton ERC-20 sur L2 est le bon :
-   - Le contrat L2 signale que son homologue L1 est identique à celui dont les jetons provenaient sur L1
-   - Le contrat L2 signale qu'il prend en charge l'interface correcte ([en utilisant ERC-165](https://eips.ethereum.org/EIPS/eip-165)).
-7. Si le contrat L2 est le bon, appelez-le pour frapper le nombre approprié de jetons à l'adresse appropriée. Sinon, commencez un processus de retrait pour permettre à l'utilisateur de réclamer les jetons sur L1.
+5. Le pont L2 vérifie que l'appel à `finalizeDeposit` est légitime :
+   - Provenant du contrat de message inter-domaines
+   - Était initialement du pont sur la L1
+6. Le pont L2 vérifie si le contrat de jeton ERC-20 sur la L2 est le bon :
+   - Le contrat L2 signale que son homologue L1 est le même que celui d'où provenaient les jetons sur la L1
+   - Le contrat L2 signale qu'il prend en charge l'interface correcte ([en utilisant l'ERC-165](https://eips.ethereum.org/EIPS/eip-165)).
+7. Si le contrat L2 est le bon, appelez-le pour frapper le nombre de jetons approprié à l'adresse appropriée. Sinon, démarrez un processus de retrait pour permettre à l'utilisateur de réclamer les jetons sur la L1.
 
 ### Flux de retrait {#withdrawal-flow}
 
 #### Couche 2 {#withdrawal-flow-layer-2}
 
-1. Le retirant appelle la passerelle de connexion L2 (`withdraw` ou `withdrawTo`)
-2. La passerelle de connexion L2 brûle le nombre approprié de jetons appartenant à `msg.sender`
-3. La passerelle de connexion L2 utilise le mécanisme de message inter-domaine pour appeler `finalizeETHWithdrawal` ou `finalizeERC20Withdrawal` de la passerelle L1
+1. Le retireur appelle le pont L2 (`withdraw` ou `withdrawTo`)
+2. Le pont L2 brûle le nombre approprié de jetons appartenant à `msg.sender`
+3. Le pont L2 utilise le mécanisme de message inter-domaines pour appeler `finalizeETHWithdrawal` ou `finalizeERC20Withdrawal` sur le pont L1
 
 #### Couche 1 {#withdrawal-flow-layer-1}
 
-4. La passerelle de connexion L1 vérifie que l'appel à `finalizeETHWithal` ou à `finalizeERC20Withal` est légitime :
-   - Provient du mécanisme de message inter-domaine
-   - Était à l'origine en provenance de la passerelle de connexion sur L2
-5. La passerelle L1 transfère l'actif approprié (ETH ou ERC-20) à l'adresse appropriée
+4. Le pont L1 vérifie que l'appel à `finalizeETHWithdrawal` ou `finalizeERC20Withdrawal` est légitime :
+   - Provenant du mécanisme de message inter-domaines
+   - Était initialement du pont sur la L2
+5. Le pont L1 transfère l'actif approprié (ETH ou ERC-20) à l'adresse appropriée
 
 ## Code de la couche 1 {#layer-1-code}
 
-C'est le code qui s'exécute sur L1, le réseau principal Ethereum.
+C'est le code qui s'exécute sur la L1, le réseau principal Ethereum.
 
 ### IL1ERC20Bridge {#IL1ERC20Bridge}
 
-[Cette interface est définie ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1ERC20Bridge.sol). Elle comprend les fonctions et les définitions requises pour la connexion en passerelle des jetons ERC-20.
+[Cette interface est définie ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1ERC20Bridge.sol).
+Elle inclut les fonctions et les définitions nécessaires au pontage des jetons ERC-20.
 
 ```solidity
 // SPDX-License-Identifier: MIT
 ```
 
-[La plupart du code Optimism est publié sous la licence MIT](https://help.optimism.io/hc/en-us/articles/4411908707995-What-software-license-does-Optimism-use-).
+[La plupart du code d'Optimism est publié sous la licence MIT](https://help.optimism.io/hc/en-us/articles/4411908707995-What-software-license-does-Optimism-use-).
 
 ```solidity
 pragma solidity >0.5.0 <0.9.0;
 ```
 
-Lors de l'écriture de cet article, la dernière version de Solidity était 0.8.12. Jusqu'à la publication de la version 0.9.0, nous ne saurons pas si ce code est compatible ou non.
+Au moment de la rédaction, la dernière version de Solidity est la 0.8.12.
+Tant que la version 0.9.0 n'est pas sortie, nous ne savons pas si ce code est compatible avec elle ou non.
 
 ```solidity
 /**
@@ -86,20 +91,23 @@ Lors de l'écriture de cet article, la dernière version de Solidity était 0.8.
  */
 interface IL1ERC20Bridge {
     /**********
-     * Events *
+     * Événements *
      **********/
 
     event ERC20DepositInitiated(
 ```
 
-Dans le terminologique des passerelles pour Optimism _deposit_ signifie transférer de L1 vers L2, et _withdrawal_ signifie un transfert de L2 vers L1.
+Dans la terminologie des ponts Optimism, _deposit_ (dépôt) signifie un transfert de la L1 vers la L2, et _withdrawal_ (retrait) signifie un transfert de la L2 vers la L1.
 
 ```solidity
         address indexed _l1Token,
         address indexed _l2Token,
 ```
 
-Dans la plupart des cas, l'adresse d'un ERC-20 sur L1 n'est pas la même que celle de l'équivalent ERC-20 sur L2. [Vous pouvez consulter la liste des adresses de jetons ici](https://static.optimism.io/optimism.tokenlist.json). L'adresse avec `chainId` 1 est sur L1 (le réseau principal) et l'adresse avec `chainId` 10 est sur L2 (Optimism). Les deux autres valeurs `chainId` sont pour le réseau de test Kovan (42) et le réseau de test Optimistic Kovan (69).
+Dans la plupart des cas, l'adresse d'un ERC-20 sur la L1 n'est pas la même que l'adresse de l'ERC-20 équivalent sur la L2.
+[Vous pouvez voir la liste des adresses de jetons ici](https://static.optimism.io/optimism.tokenlist.json).
+L'adresse avec `chainId` 1 est sur la L1 (réseau principal) et l'adresse avec `chainId` 10 est sur la L2 (Optimism).
+Les deux autres valeurs de `chainId` sont pour le réseau de test Kovan (42) et le réseau de test Optimistic Kovan (69).
 
 ```solidity
         address indexed _from,
@@ -122,33 +130,35 @@ Il est possible d'ajouter des notes aux transferts, auquel cas elles sont ajout
     );
 ```
 
-Le même contrat passerelle gère les transferts dans les deux sens. Dans le cas de la passerelle L1, cela signifie l'initialisation des dépôts et la finalisation des retraits.
+Le même contrat de pont gère les transferts dans les deux sens.
+Dans le cas du pont L1, cela signifie l'initialisation des dépôts et la finalisation des retraits.
 
 ```solidity
 
     /********************
-     * Public Functions *
+     * Fonctions publiques *
      ********************/
 
     /**
-     * @dev get the address of the corresponding L2 bridge contract.
-     * @return Address of the corresponding L2 bridge contract.
+     * @dev obtient l'adresse du contrat de pont L2 correspondant.
+     * @return Adresse du contrat de pont L2 correspondant.
      */
     function l2TokenBridge() external returns (address);
 ```
 
-Cette fonction n'est pas vraiment nécessaire, car sur L2 c'est un contrat prédéployé, donc il sera toujours à l'adresse `0x420000000000000000000000000000000000000000000010`. Il est ici pour la symétrie avec la passerelle L2, car l'adresse de la passerelle de connexion L1 n'est _pas_ à connaître.
+Cette fonction n'est pas vraiment nécessaire, car sur la L2, c'est un contrat prédéployé, donc il est toujours à l'adresse `0x4200000000000000000000000000000000000010`.
+Elle est là pour la symétrie avec le pont L2, car l'adresse du pont L1 n'est _pas_ triviale à connaître.
 
 ```solidity
     /**
-     * @dev deposit an amount of the ERC20 to the caller's balance on L2.
-     * @param _l1Token Address of the L1 ERC20 we are depositing
-     * @param _l2Token Address of the L1 respective L2 ERC20
-     * @param _amount Amount of the ERC20 to deposit
-     * @param _l2Gas Gas limit required to complete the deposit on L2.
-     * @param _data Optional data to forward to L2. This data is provided
-     *        solely as a convenience for external contracts. Aside from enforcing a maximum
-     *        length, these contracts provide no guarantees about its content.
+     * @dev dépose un montant d'ERC20 sur le solde de l'appelant sur la L2.
+     * @param _l1Token Adresse de l'ERC20 de L1 que nous déposons
+     * @param _l2Token Adresse de l'ERC20 respectif de L2
+     * @param _amount Montant de l'ERC20 à déposer
+     * @param _l2Gas Limite de gaz requise pour finaliser le dépôt sur la L2.
+     * @param _data Données facultatives à transmettre à la L2. Ces données sont fournies
+     *        uniquement pour la commodité des contrats externes. En dehors de l'application d'une longueur
+     *        maximale, ces contrats ne fournissent aucune garantie sur leur contenu.
      */
     function depositERC20(
         address _l1Token,
@@ -159,19 +169,21 @@ Cette fonction n'est pas vraiment nécessaire, car sur L2 c'est un contrat préd
     ) external;
 ```
 
-Le paramètre `_l2Gas` est le montant de gaz L2 que la transaction est autorisée à dépenser. [Jusqu'à une certaine limite (haute), c'est gratuit](https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions-2), donc à moins que le contrat ERC-20 ne fasse quelque chose de vraiment étrange lors de la frappe, il ne devrait pas y avoir de problème. Cette fonction prend en charge le scénario commun où un utilisateur relie les actifs à la même adresse sur une blockchain différente.
+Le paramètre `_l2Gas` est la quantité de gaz L2 que la transaction est autorisée à dépenser.
+[Jusqu'à une certaine limite (élevée), c'est gratuit](https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions-2), donc à moins que le contrat ERC-20 ne fasse quelque chose de vraiment étrange lors de la frappe, cela ne devrait pas être un problème.
+Cette fonction prend en charge le scénario courant, où un utilisateur ponte des actifs vers la même adresse sur une autre blockchain.
 
 ```solidity
     /**
-     * @dev deposit an amount of ERC20 to a recipient's balance on L2.
-     * @param _l1Token Address of the L1 ERC20 we are depositing
-     * @param _l2Token Address of the L1 respective L2 ERC20
-     * @param _to L2 address to credit the withdrawal to.
-     * @param _amount Amount of the ERC20 to deposit.
-     * @param _l2Gas Gas limit required to complete the deposit on L2.
-     * @param _data Optional data to forward to L2. This data is provided
-     *        solely as a convenience for external contracts. Aside from enforcing a maximum
-     *        length, these contracts provide no guarantees about its content.
+     * @dev dépose un montant d'ERC20 sur le solde d'un destinataire sur la L2.
+     * @param _l1Token Adresse de l'ERC20 de L1 que nous déposons
+     * @param _l2Token Adresse de l'ERC20 respectif de L2
+     * @param _to Adresse L2 sur laquelle créditer le retrait.
+     * @param _amount Montant de l'ERC20 à déposer.
+     * @param _l2Gas Limite de gaz requise pour finaliser le dépôt sur la L2.
+     * @param _data Données facultatives à transmettre à la L2. Ces données sont fournies
+     *        uniquement pour la commodité des contrats externes. En dehors de l'application d'une longueur
+     *        maximale, ces contrats ne fournissent aucune garantie sur leur contenu.
      */
     function depositERC20To(
         address _l1Token,
@@ -187,22 +199,22 @@ Cette fonction est presque identique à `depositERC20`, mais elle vous permet d'
 
 ```solidity
     /*************************
-     * Cross-chain Functions *
+     * Fonctions inter-chaînes *
      *************************/
 
     /**
-     * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the
-     * L1 ERC20 token.
-     * This call will fail if the initialized withdrawal from L2 has not been finalized.
+     * @dev Finalise un retrait de la L2 vers la L1, et crédite les fonds sur le solde du destinataire du
+     * jeton ERC20 de L1.
+     * Cet appel échouera si le retrait initialisé depuis la L2 n'a pas été finalisé.
      *
-     * @param _l1Token Address of L1 token to finalizeWithdrawal for.
-     * @param _l2Token Address of L2 token where withdrawal was initiated.
-     * @param _from L2 address initiating the transfer.
-     * @param _to L1 address to credit the withdrawal to.
-     * @param _amount Amount of the ERC20 to deposit.
-     * @param _data Data provided by the sender on L2. This data is provided
-     *   solely as a convenience for external contracts. Aside from enforcing a maximum
-     *   length, these contracts provide no guarantees about its content.
+     * @param _l1Token Adresse du jeton L1 pour lequel finaliser le retrait.
+     * @param _l2Token Adresse du jeton L2 où le retrait a été initié.
+     * @param _from Adresse L2 initiant le transfert.
+     * @param _to Adresse L1 sur laquelle créditer le retrait.
+     * @param _amount Montant de l'ERC20 à déposer.
+     * @param _data Données fournies par l'expéditeur sur la L2. Ces données sont fournies
+     *   uniquement pour la commodité des contrats externes. En dehors de l'application d'une longueur
+     *   maximale, ces contrats ne fournissent aucune garantie sur leur contenu.
      */
     function finalizeERC20Withdrawal(
         address _l1Token,
@@ -215,16 +227,20 @@ Cette fonction est presque identique à `depositERC20`, mais elle vous permet d'
 }
 ```
 
-Les retraits (et autres messages de L2 vers L1) dans Optimism sont des processus en deux étapes :
+Les retraits (et autres messages de la L2 à la L1) dans Optimism sont un processus en deux étapes :
 
-1. Une transaction d'initialisation sur L2.
-2. Une transaction de finalisation ou de réclamation sur L1. Cette transaction doit être réalisée après la [période de contestation des défauts](https://community.optimism.io/docs/how-optimism-works/#fault-proofs) pour que la transaction L2 se termine.
+1. Une transaction d'initiation sur la L2.
+2. Une transaction de finalisation ou de réclamation sur la L1.
+   Cette transaction doit avoir lieu après la fin de la [période de contestation des erreurs](https://community.optimism.io/docs/how-optimism-works/#fault-proofs) pour la transaction L2.
 
 ### IL1StandardBridge {#il1standardbridge}
 
-[Cette interface est définie ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1StandardBridge.sol). Ce fichier contient des définitions d'événements et de fonctions pour ETH. Ces définitions sont très similaires à celles définies ci-dessus dans `IL1ERC20Bridge` pour ERC-20.
+[Cette interface est définie ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1StandardBridge.sol).
+Ce fichier contient les définitions d'événements et de fonctions pour l'ETH.
+Ces définitions sont très similaires à celles définies dans `IL1ERC20Bridge` ci-dessus pour l'ERC-20.
 
-L'interface de passerelle est divisée entre deux fichiers puisque certains jetons ERC-20 nécessitent un traitement personnalisé et ne peuvent pas être traités par la passerelle de connexion standard. De cette façon, la passerelle personnalisée de connexion qui gère un tel jeton peut implémenter `IL1ERC20Bridge` et ne pas nécessiter une passerelle pour ETH.
+L'interface du pont est divisée en deux fichiers car certains jetons ERC-20 nécessitent un traitement personnalisé et ne peuvent pas être gérés par le pont standard.
+De cette façon, le pont personnalisé qui gère un tel jeton peut implémenter `IL1ERC20Bridge` et ne pas avoir à ponter également l'ETH.
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -237,7 +253,7 @@ import "./IL1ERC20Bridge.sol";
  */
 interface IL1StandardBridge is IL1ERC20Bridge {
     /**********
-     * Events *
+     * Événements *
      **********/
     event ETHDepositInitiated(
         address indexed _from,
@@ -247,7 +263,8 @@ interface IL1StandardBridge is IL1ERC20Bridge {
     );
 ```
 
-Cet événement est presque identique à la version ERC-20 (`ERC20DepositInitiated`), mais sans les adresses de jeton L1 et L2. Il en va de même pour les autres événements et les fonctions.
+Cet événement est presque identique à la version ERC-20 (`ERC20DepositInitiated`), mais sans les adresses de jeton L1 et L2.
+Il en va de même pour les autres événements et les fonctions.
 
 ```solidity
     event ETHWithdrawalFinalized(
@@ -257,11 +274,11 @@ Cet événement est presque identique à la version ERC-20 (`ERC20DepositInitiat
     );
 
     /********************
-     * Public Functions *
+     * Fonctions publiques *
      ********************/
 
     /**
-     * @dev Deposit an amount of the ETH to the caller's balance on L2.
+     * @dev Dépose un montant d'ETH sur le solde de l'appelant sur la L2.
             .
             .
             .
@@ -269,7 +286,7 @@ Cet événement est presque identique à la version ERC-20 (`ERC20DepositInitiat
     function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
 
     /**
-     * @dev Deposit an amount of ETH to a recipient's balance on L2.
+     * @dev Dépose un montant d'ETH sur le solde d'un destinataire sur la L2.
             .
             .
             .
@@ -281,13 +298,13 @@ Cet événement est presque identique à la version ERC-20 (`ERC20DepositInitiat
     ) external payable;
 
     /*************************
-     * Cross-chain Functions *
+     * Fonctions inter-chaînes *
      *************************/
 
     /**
-     * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the
-     * L1 ETH token. Since only the xDomainMessenger can call this function, it will never be called
-     * before the withdrawal is finalized.
+     * @dev Finalise un retrait de la L2 vers la L1, et crédite les fonds sur le solde du destinataire du
+     * jeton ETH de L1. Étant donné que seul le xDomainMessenger peut appeler cette fonction, elle ne sera jamais appelée
+     * avant que le retrait soit finalisé.
                 .
                 .
                 .
@@ -303,7 +320,7 @@ Cet événement est presque identique à la version ERC-20 (`ERC20DepositInitiat
 
 ### CrossDomainEnabled {#crossdomainenabled}
 
-[Ce contrat](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/CrossDomainEnabled.sol) a hérité des deux passerelles ([L1](#the-l1-bridge-contract) et [L2](#the-l2-bridge-contract)) pour envoyer des messages à l'autre couche.
+[Ce contrat](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/CrossDomainEnabled.sol) est hérité par les deux ponts ([L1](#the-l1-bridge-contract) et [L2](#the-l2-bridge-contract)) pour envoyer des messages à l'autre couche.
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -313,52 +330,55 @@ pragma solidity >0.5.0 <0.9.0;
 import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
 ```
 
-[Cette interface](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/ICrossDomainMessenger.sol) indique au contrat comment envoyer des messages à l'autre couche, en utilisant le messager inter-domaine. Cette messagerie transversale de domaine est un autre système à part entière et mériterait son propre article que j'espère écrire à l'avenir.
+[Cette interface](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/ICrossDomainMessenger.sol) indique au contrat comment envoyer des messages à l'autre couche, en utilisant le messager inter-domaines.
+Ce messager inter-domaines est un tout autre système, et mérite son propre article, que j'espère écrire à l'avenir.
 
 ```solidity
 /**
  * @title CrossDomainEnabled
- * @dev Helper contract for contracts performing cross-domain communications
+ * @dev Contrat d'aide pour les contrats effectuant des communications inter-domaines
  *
- * Compiler used: defined by inheriting contract
+ * Compilateur utilisé : défini par le contrat héritier
  */
 contract CrossDomainEnabled {
     /*************
      * Variables *
      *************/
 
-    // Messenger contract used to send and receive messages from the other domain.
+    // Contrat de messagerie utilisé pour envoyer et recevoir des messages de l'autre domaine.
     address public messenger;
 
     /***************
-     * Constructor *
+     * Constructeur *
      ***************/
 
     /**
-     * @param _messenger Address of the CrossDomainMessenger on the current layer.
+     * @param _messenger Adresse du CrossDomainMessenger sur la couche actuelle.
      */
     constructor(address _messenger) {
         messenger = _messenger;
     }
 ```
 
-Le seul paramètre que le contrat a besoin de connaître est l'adresse du messager de domaines croisés sur cette couche. Ce paramètre est défini une seule fois, dans le constructeur, et ne change jamais.
+Le seul paramètre que le contrat doit connaître, l'adresse du messager inter-domaines sur cette couche.
+Ce paramètre est défini une fois, dans le constructeur, et ne change jamais.
 
 ```solidity
 
     /**********************
-     * Function Modifiers *
+     * Modificateurs de fonction *
      **********************/
 
     /**
-     * Enforces that the modified function is only callable by a specific cross-domain account.
-     * @param _sourceDomainAccount The only account on the originating domain which is
-     *  authenticated to call this function.
+     * Impose que la fonction modifiée ne puisse être appelée que par un compte inter-domaine spécifique.
+     * @param _sourceDomainAccount Le seul compte sur le domaine d'origine qui est
+     *  authentifié pour appeler cette fonction.
      */
     modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
 ```
 
-La messagerie inter-domaine est accessible par n'importe quel contrat sur la blockchain où elle est exécutée (soit le réseau principal Ethereum, soit Optimism). Mais nous avons besoin du pont de chaque côté pour faire confiance _uniquement_ à certains messages qui viennent de la passerelle de l'autre côté.
+La messagerie inter-domaines est accessible par n'importe quel contrat sur la blockchain où elle est exécutée (soit le réseau principal Ethereum, soit Optimism).
+Mais nous avons besoin que le pont de chaque côté ne fasse confiance à certains messages que s'ils proviennent du pont de l'autre côté.
 
 ```solidity
         require(
@@ -367,7 +387,7 @@ La messagerie inter-domaine est accessible par n'importe quel contrat sur la blo
         );
 ```
 
-Seuls les messages du messager inter-domaine approprié (`messenger`, comme indiqué ci-dessous) peuvent être fiables.
+Seuls les messages provenant du messager inter-domaines approprié (`messenger`, comme vous le verrez ci-dessous) peuvent être fiables.
 
 ```solidity
 
@@ -377,9 +397,10 @@ Seuls les messages du messager inter-domaine approprié (`messenger`, comme indi
         );
 ```
 
-La façon dont la messagerie inter-domaine fournit l'adresse qui a envoyé un message avec l'autre couche est [la fonction `.xDomainMessageSender()`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1CrossDomainMessenger.sol#L122-L128). Tant qu'elle est appelée dans la transaction qui a été initiée par le message, elle peut fournir ces informations.
+La façon dont le messager inter-domaines fournit l'adresse qui a envoyé un message avec l'autre couche est [la fonction `.xDomainMessageSender()`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1CrossDomainMessenger.sol#L122-L128).
+Tant qu'elle est appelée dans la transaction qui a été initiée par le message, elle peut fournir cette information.
 
-Nous devons nous assurer que le message que nous avons reçu provient bien de l'autre passerelle.
+Nous devons nous assurer que le message que nous avons reçu provient de l'autre pont.
 
 ```solidity
 
@@ -387,29 +408,30 @@ Nous devons nous assurer que le message que nous avons reçu provient bien de l'
     }
 
     /**********************
-     * Internal Functions *
+     * Fonctions internes *
      **********************/
 
     /**
-     * Gets the messenger, usually from storage. This function is exposed in case a child contract
-     * needs to override.
-     * @return The address of the cross-domain messenger contract which should be used.
+     * Obtient le messager, généralement à partir du stockage. Cette fonction est exposée au cas où un contrat enfant
+     * aurait besoin de la remplacer.
+     * @return L'adresse du contrat de messager inter-domaines qui doit être utilisé.
      */
     function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
         return ICrossDomainMessenger(messenger);
     }
 ```
 
-Cette fonction retourne le messager inter-domaine. Nous utilisons une fonction plutôt que la variable `messenger` pour permettre aux contrats qui héritent de celui-ci d'utiliser un algorithme pour spécifier quel messager de domaine croisé utiliser.
+Cette fonction renvoie le messager inter-domaines.
+Nous utilisons une fonction plutôt que la variable `messenger` pour permettre aux contrats qui en héritent d'utiliser un algorithme pour spécifier quel messager inter-domaines utiliser.
 
 ```solidity
 
     /**
-     * Sends a message to an account on another domain
-     * @param _crossDomainTarget The intended recipient on the destination domain
-     * @param _message The data to send to the target (usually calldata to a function with
+     * Envoie un message à un compte sur un autre domaine
+     * @param _crossDomainTarget Le destinataire prévu sur le domaine de destination
+     * @param _message Les données à envoyer à la cible (généralement des calldata vers une fonction avec
      *  `onlyFromCrossDomainAccount()`)
-     * @param _gasLimit The gasLimit for the receipt of the message on the target domain.
+     * @param _gasLimit La limite de gaz pour la réception du message sur le domaine cible.
      */
     function sendCrossDomainMessage(
         address _crossDomainTarget,
@@ -424,10 +446,11 @@ Enfin, la fonction qui envoie un message à l'autre couche.
         // slither-disable-next-line reentrancy-events, reentrancy-benign
 ```
 
-[Slither](https://github.com/crytic/slither) est un analyseur statique Optimism qui fonctionne sur chaque contrat pour rechercher des vulnérabilités et d'autres problèmes potentiels. Dans notre cas, la ligne suivante déclenche deux vulnérabilités :
+[Slither](https://github.com/crytic/slither) est un analyseur statique qu'Optimism exécute sur chaque contrat pour rechercher des vulnérabilités et d'autres problèmes potentiels.
+Dans ce cas, la ligne suivante déclenche deux vulnérabilités :
 
 1. [Événements de réentrance](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3)
-2. [Réentrance Benign](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2)
+2. [Réentrance bénigne](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2)
 
 ```solidity
         getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
@@ -435,18 +458,19 @@ Enfin, la fonction qui envoie un message à l'autre couche.
 }
 ```
 
-Dans notre cas, nous ne devons pas nous inquiéter de la réentrance, nous savons que `getCrossDomainMessenger()` retourne une adresse digne de confiance, même si Slither n'a aucun moyen de le savoir.
+Dans ce cas, nous ne nous inquiétons pas de la réentrance car nous savons que `getCrossDomainMessenger()` renvoie une adresse fiable, même si Slither n'a aucun moyen de le savoir.
 
-### Le contrat de passerelle L1 {#the-l1-bridge-contract}
+### Le contrat de pont L1 {#the-l1-bridge-contract}
 
-[Le code source de ce contrat se trouve ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1StandardBridge.sol).
+[Le code source de ce contrat est ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1StandardBridge.sol).
 
 ```solidity
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.9;
 ```
 
-Les interfaces peuvent faire partie d'autres contrats, elles doivent donc supporter un large éventail de versions Solidity. Mais la passerelle en elle-même est notre contrat, et nous pouvons être stricts quant à la version de Solidity utilisée.
+Les interfaces peuvent faire partie d'autres contrats, elles doivent donc prendre en charge une large gamme de versions de Solidity.
+Mais le pont lui-même est notre contrat, et nous pouvons être stricts sur la version de Solidity qu'il utilise.
 
 ```solidity
 /* Interface Imports */
@@ -460,34 +484,35 @@ import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
 import { IL2ERC20Bridge } from "../../L2/messaging/IL2ERC20Bridge.sol";
 ```
 
-[Cette interface](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) nous permet de créer des messages pour contrôler la passerelle de connexion standard sur L2.
+[Cette interface](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) nous permet de créer des messages pour contrôler le pont standard sur la L2.
 
 ```solidity
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 ```
 
-[Cette interface](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) nous permet de piloter les contrats ERC-20. [Vous pouvez en savoir plus sur ce sujet ici](/developers/tutorials/erc20-annotated-code/#the-interface).
+[Cette interface](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) nous permet de contrôler les contrats ERC-20.
+[Vous pouvez en savoir plus à ce sujet ici](/developers/tutorials/erc20-annotated-code/#the-interface).
 
 ```solidity
 /* Library Imports */
 import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
 ```
 
-[Comme expliqué ci-dessus](#crossdomainenabled), ce contrat est utilisé pour la messagerie intercouche.
+[Comme expliqué ci-dessus](#crossdomainenabled), ce contrat est utilisé pour la messagerie inter-couches.
 
 ```solidity
 import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
 ```
 
-[`Lib_PredeployAdresses`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/constants/Lib_PredeployAddresses.sol)dispose des adresses pour les contrats L2 qui ont toujours la même adresse. Cela inclut la passerelle standard sur la L2.
+`Lib_PredeployAddresses` (https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/constants/Lib_PredeployAddresses.sol) contient les adresses des contrats L2 qui ont toujours la même adresse. Cela inclut le pont standard sur la L2.
 
 ```solidity
 import { Address } from "@openzeppelin/contracts/utils/Address.sol";
 ```
 
-[Utilitaires d'adresses OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol). Ils servent à distinguer les adresses contractuelles de celles appartenant à des comptes propriétaires externes (EOA).
+[Utilitaires d'adresse d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol). Il est utilisé pour distinguer les adresses de contrat de celles appartenant à des comptes externes (EOA).
 
-Notez que ce n'est pas une solution parfaite, car il n'y a aucun moyen de distinguer les appels directs de ceux réalisés par le constructeur d'un contrat, mais au moins cela nous permet d'identifier et de prévenir certaines erreurs utilisateurs courantes.
+Notez que ce n'est pas une solution parfaite, car il n'y a aucun moyen de distinguer les appels directs des appels effectués depuis le constructeur d'un contrat, mais au moins cela nous permet d'identifier et d'éviter certaines erreurs d'utilisateur courantes.
 
 ```solidity
 import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -495,29 +520,29 @@ import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.s
 
 [La norme ERC-20](https://eips.ethereum.org/EIPS/eip-20) prend en charge deux manières pour un contrat de signaler un échec :
 
-1. Rétablir
+1. Annuler
 2. Renvoyer `false`
 
-La gestion des deux cas rendrait notre code plus compliqué donc à la place nous utilisons [le `SafeERC20` d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol), qui s'assure que [tous les échecs aboutissent à un rétablissement](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol#L96).
+Gérer les deux cas rendrait notre code plus compliqué, nous utilisons donc [`SafeERC20` d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol), qui s'assure que [tous les échecs entraînent une annulation](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol#L96).
 
 ```solidity
 /**
  * @title L1StandardBridge
- * @dev The L1 ETH and ERC20 Bridge is a contract which stores deposited L1 funds and standard
- * tokens that are in use on L2. It synchronizes a corresponding L2 Bridge, informing it of deposits
- * and listening to it for newly finalized withdrawals.
+ * @dev Le pont L1 pour ETH et ERC20 est un contrat qui stocke les fonds L1 déposés et les jetons
+ * standard qui sont utilisés sur la L2. Il synchronise un pont L2 correspondant, l'informant des dépôts
+ * et l'écoutant pour les nouveaux retraits finalisés.
  *
  */
 contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
     using SafeERC20 for IERC20;
 ```
 
-Cette ligne montre comment nous spécifions d'utiliser le wrapper `SafeERC20` chaque fois que nous utilisons l'interface `IERC20`.
+Cette ligne est la façon dont nous spécifions d'utiliser le wrapper `SafeERC20` chaque fois que nous utilisons l'interface `IERC20`.
 
 ```solidity
 
     /********************************
-     * External Contract References *
+     * Références de contrats externes *
      ********************************/
 
     address public l2TokenBridge;
@@ -527,51 +552,66 @@ L'adresse de [L2StandardBridge](#the-l2-bridge-contract).
 
 ```solidity
 
-    // Maps L1 token to L2 token to balance of the L1 token deposited
+    // Mappe le jeton L1 au jeton L2 au solde du jeton L1 déposé
     mapping(address => mapping(address => uint256)) public deposits;
 ```
 
-Un double [mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) comme celui-ci est la façon dont vous définissez un [rare tableau bidimensionnel](https://en.wikipedia.org/wiki/Sparse_matrix). Les valeurs dans cette structure de données sont identifiées comme `deposit[L1 token addr][L2 token addr]`. La valeur par défaut est zéro. Seules les cellules qui sont définies à une valeur différente sont écrites pour le stockage.
+Un double [mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) comme celui-ci est la manière de définir un [tableau creux à deux dimensions](https://en.wikipedia.org/wiki/Sparse_matrix).
+Les valeurs dans cette structure de données sont identifiées comme `deposit[adresse jeton L1][adresse jeton L2]`.
+La valeur par défaut est zéro.
+Seules les cellules qui sont définies à une valeur différente sont écrites dans le stockage.
 
 ```solidity
 
     /***************
-     * Constructor *
+     * Constructeur *
      ***************/
 
-    // This contract lives behind a proxy, so the constructor parameters will go unused.
+    // Ce contrat vit derrière un proxy, donc les paramètres du constructeur ne seront pas utilisés.
     constructor() CrossDomainEnabled(address(0)) {}
 ```
 
-Pour pouvoir mettre à jour ce contrat sans avoir à copier toutes les variables dans le stockage. Pour cela, nous utilisons un [`Proxy`](https://docs.openzeppelin.com/contracts/3.x/api/proxy), un contrat qui utilise [`delegatecall`](https://solidity-by-example.org/delegatecall/) pour transférer des appels à un contact distinct dont l'adresse est stockée par le contrat de proxy (lorsque vous mettez à jour, vous ordonnez au proxy de changer cette adresse). Lorsque vous utilisez `delegatecall` le stockage reste le stockage du contrat _appelant_, donc les valeurs de toutes les variables d'état du contrat ne sont pas affectées.
+Pour pouvoir mettre à jour ce contrat sans avoir à copier toutes les variables dans le stockage.
+Pour ce faire, nous utilisons un [`Proxy`](https://docs.openzeppelin.com/contracts/3.x/api/proxy), un contrat qui utilise [`delegatecall`](https://solidity-by-example.org/delegatecall/) pour transférer les appels vers un contrat distinct dont l'adresse est stockée par le contrat proxy (lorsque vous mettez à jour, vous dites au proxy de changer cette adresse).
+Lorsque vous utilisez `delegatecall`, le stockage reste celui du contrat _appelant_, de sorte que les valeurs de toutes les variables d'état du contrat ne sont pas affectées.
 
-Un effet de cette pratique est que le stockage du contrat qui est _appelé_ de `delegatecall` n'est pas utilisé et donc les valeurs du constructeur qui lui sont passées n'ont pas d'importance. C'est la raison pour laquelle nous pouvons fournir une valeur absurde au constructeur `CrossDomainEnabled`. C'est aussi la raison pour laquelle l'initialisation ci-dessous est séparée du constructeur.
+Un effet de ce modèle est que le stockage du contrat qui est l'_appelé_ de `delegatecall` n'est pas utilisé et donc les valeurs du constructeur qui lui sont passées n'ont pas d'importance.
+C'est la raison pour laquelle nous pouvons fournir une valeur absurde au constructeur `CrossDomainEnabled`.
+C'est aussi la raison pour laquelle l'initialisation ci-dessous est séparée du constructeur.
 
 ```solidity
     /******************
-     * Initialization *
+     * Initialisation *
      ******************/
 
     /**
-     * @param _l1messenger L1 Messenger address being used for cross-chain communications.
-     * @param _l2TokenBridge L2 standard bridge address.
+     * @param _l1messenger Adresse du messager L1 utilisé pour les communications inter-chaînes.
+     * @param _l2TokenBridge Adresse du pont de jetons L2.
      */
     // slither-disable-next-line external-function
 ```
 
-Ce [test Slither](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external) identifie les fonctions qui ne sont pas appelées à partir du code du contrat et pourrait donc être déclarées `external` au lieu de `public`. Le coût en gaz des fonctions `external` peut être diminué, car elles peuvent être fournies avec des paramètres dans le calldata. Les fonctions déclarées `public` doivent être accessibles depuis le contrat. Les contrats ne peuvent pas modifier leurs propres calldata ainsi, les paramètres doivent être en mémoire. Lorsqu'une telle fonction est appelée en externe, il est nécessaire de copier le calldata dans la mémoire, ce qui coûte du gaz. Dans ce cas, la fonction n'est appelée qu'une seule fois, donc son inefficacité n'a pas d'importance pour nous.
+Ce [test Slither](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external) identifie les fonctions qui ne sont pas appelées depuis le code du contrat et qui pourraient donc être déclarées `external` au lieu de `public`.
+Le coût en gaz des fonctions `external` peut être inférieur, car elles peuvent être fournies avec des paramètres dans les calldata.
+Les fonctions déclarées `public` doivent être accessibles depuis l'intérieur du contrat.
+Les contrats ne peuvent pas modifier leurs propres calldata, donc les paramètres doivent être en mémoire.
+Lorsqu'une telle fonction est appelée de l'extérieur, il est nécessaire de copier les calldata en mémoire, ce qui coûte du gaz.
+Dans ce cas, la fonction n'est appelée qu'une seule fois, donc l'inefficacité n'a pas d'importance pour nous.
 
 ```solidity
     function initialize(address _l1messenger, address _l2TokenBridge) public {
-        require(messenger == address(0), "Contract has already been initialized.");
+        require(messenger == address(0), "Le contrat a déjà été initialisé.");
 ```
 
-La fonction `initialize` ne doit être appelée qu'une seule fois. Si l'adresse du messager inter-domaine L1 ou du jeton de connexion L2 changent, nous créons un nouveau proxy et une nouvelle passerelle qui l'appellera. Il est peu probable que cela se produise sauf lorsque le système dans son entier est mis à jour, ce qui est très rare.
+La fonction `initialize` ne doit être appelée qu'une seule fois.
+Si l'adresse du messager inter-domaines L1 ou du pont de jetons L2 change, nous créons un nouveau proxy et un nouveau pont qui l'appelle.
+Il est peu probable que cela se produise, sauf lorsque l'ensemble du système est mis à niveau, un événement très rare.
 
-Notez que cette fonction ne dispose d'aucun mécanisme qui délimite _qui_ peut l'appeler. Cela signifie qu'en théorie, un attaquant pourrait attendre que nous déployions le proxy et la première version de la passerelle de connexion et donc [front-run](https://solidity-by-example.org/hacks/front-running/) pour accéder à la fonction `initialize` avant que l'utilisateur légitime ne le fasse. Il existe deux méthodes pour éviter cela :
+Notez que cette fonction ne dispose d'aucun mécanisme qui restreint _qui_ peut l'appeler.
+Cela signifie qu'en théorie, un attaquant pourrait attendre que nous déployions le proxy et la première version du pont, puis [exécuter une attaque par front-running](https://solidity-by-example.org/hacks/front-running/) pour atteindre la fonction `initialize` avant l'utilisateur légitime. Mais il existe deux méthodes pour empêcher cela :
 
-1. Si les contrats ne sont pas déployés directement par un EOA, mais [dans une transaction qui contient un autre contrat les créant](https://medium.com/upstate-interactive/creating-a-contract-with-a-smart-contract-bdb67c5c8595) l'ensemble du processus peut être atomique, et se terminer avant que toute autre transaction soit exécutée.
-2. Si l'appel légitime à `initialize` échoue, il est toujours possible d'ignorer le proxy et la passerelle de connexion nouvellement créé et d'en créer de nouveaux.
+1. Si les contrats ne sont pas déployés directement par un EOA mais [dans une transaction qui fait qu'un autre contrat les crée](https://medium.com/upstate-interactive/creating-a-contract-with-a-smart-contract-bdb67c5c8595), l'ensemble du processus peut être atomique et se terminer avant l'exécution de toute autre transaction.
+2. Si l'appel légitime à `initialize` échoue, il est toujours possible d'ignorer le proxy et le pont nouvellement créés et d'en créer de nouveaux.
 
 ```solidity
         messenger = _l1messenger;
@@ -579,39 +619,40 @@ Notez que cette fonction ne dispose d'aucun mécanisme qui délimite _qui_ peut
     }
 ```
 
-Ce sont les deux paramètres que la passerelle a besoin de connaître.
+Ce sont les deux paramètres que le pont doit connaître.
 
 ```solidity
 
     /**************
-     * Depositing *
+     * Dépôt *
      **************/
 
-    /** @dev Modifier requiring sender to be EOA.  This check could be bypassed by a malicious
-     *  contract via initcode, but it takes care of the user error we want to avoid.
+    /** @dev Modificateur exigeant que l'expéditeur soit un EOA. Cette vérification pourrait être contournée par un contrat
+     * malveillant via initcode, mais elle prend en charge l'erreur utilisateur que nous voulons éviter.
      */
     modifier onlyEOA() {
-        // Used to stop deposits from contracts (avoid accidentally lost tokens)
-        require(!Address.isContract(msg.sender), "Account not EOA");
+        // Utilisé pour arrêter les dépôts depuis des contrats (éviter la perte accidentelle de jetons)
+        require(!Address.isContract(msg.sender), "Compte non EOA");
         _;
     }
 ```
 
-C'est la raison pour laquelle nous avions besoin des utilitaires d'`Address` d'OpenZeppelin.
+C'est la raison pour laquelle nous avions besoin des utilitaires `Address` d'OpenZeppelin.
 
 ```solidity
     /**
-     * @dev This function can be called with no data
-     * to deposit an amount of ETH to the caller's balance on L2.
-     * Since the receive function doesn't take data, a conservative
-     * default amount is forwarded to L2.
+     * @dev Cette fonction peut être appelée sans données
+     * pour déposer un montant d'ETH sur le solde de l'appelant sur la L2.
+     * Comme la fonction de réception ne prend pas de données, un montant
+     * par défaut conservateur est transmis à la L2.
      */
     receive() external payable onlyEOA {
         _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
     }
 ```
 
-Cette fonction existe à des fins de test. Notez qu'il n'apparaît pas dans les définitions d'interface - elle n'est pas prévue pour une utilisation normale.
+Cette fonction existe à des fins de test.
+Notez qu'elle n'apparaît pas dans les définitions d'interface - elle n'est pas destinée à un usage normal.
 
 ```solidity
     /**
@@ -633,18 +674,18 @@ Cette fonction existe à des fins de test. Notez qu'il n'apparaît pas dans les
     }
 ```
 
-Ces deux fonctions sont enveloppées autour de `_initiateETHDeposit`, la fonction qui gère le dépôt réel ETH.
+Ces deux fonctions sont des wrappers autour de `_initiateETHDeposit`, la fonction qui gère le dépôt réel d'ETH.
 
 ```solidity
     /**
-     * @dev Performs the logic for deposits by storing the ETH and informing the L2 ETH Gateway of
-     * the deposit.
-     * @param _from Account to pull the deposit from on L1.
-     * @param _to Account to give the deposit to on L2.
-     * @param _l2Gas Gas limit required to complete the deposit on L2.
-     * @param _data Optional data to forward to L2. This data is provided
-     *        solely as a convenience for external contracts. Aside from enforcing a maximum
-     *        length, these contracts provide no guarantees about its content.
+     * @dev Exécute la logique pour les dépôts en stockant l'ETH et en informant la passerelle ETH L2
+     * du dépôt.
+     * @param _from Compte à partir duquel retirer le dépôt sur la L1.
+     * @param _to Compte auquel donner le dépôt sur la L2.
+     * @param _l2Gas Limite de gaz requise pour finaliser le dépôt sur la L2.
+     * @param _data Données facultatives à transmettre à la L2. Ces données sont fournies
+     *        uniquement pour la commodité des contrats externes. En dehors de l'application d'une longueur
+     *        maximale, ces contrats ne fournissent aucune garantie sur leur contenu.
      */
     function _initiateETHDeposit(
         address _from,
@@ -652,11 +693,14 @@ Ces deux fonctions sont enveloppées autour de `_initiateETHDeposit`, la fonctio
         uint32 _l2Gas,
         bytes memory _data
     ) internal {
-        // Construct calldata for finalizeDeposit call
+        // Construire les calldata pour l'appel finalizeDeposit
         bytes memory message = abi.encodeWithSelector(
 ```
 
-La façon dont les messages transversaux fonctionnent est que le contrat de destination est appelé avec le message comme ses calldata. Les contrats Solidity interprètent toujours si leurs calldata sont conformes aux [spécifications de l'ABI](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html). La fonction Solidity [`abi.encodeWithSelector`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#abi-encoding-and-decoding-functions) crée ces calldata.
+La manière dont les messages inter-domaines fonctionnent est que le contrat de destination est appelé avec le message comme calldata.
+Les contrats Solidity interprètent toujours leurs calldata conformément
+[aux spécifications de l'ABI](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html).
+La fonction Solidity [`abi.encodeWithSelector`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#abi-encoding-and-decoding-functions) crée ces calldata.
 
 ```solidity
             IL2ERC20Bridge.finalizeDeposit.selector,
@@ -669,24 +713,24 @@ La façon dont les messages transversaux fonctionnent est que le contrat de dest
         );
 ```
 
-Le message ici est destiné à appeler [la fonction `finalizeDeposit`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol#L141-L148) avec ces paramètres :
+Le message ici est d'appeler [la fonction `finalizeDeposit`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol#L141-L148) avec ces paramètres :
 
-| Paramètre | Valeur                         | Signification                                                                                                                                         |
-| --------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
-| \_l1Token | address(0)                     | Valeur spéciale pour représenter ETH (qui n'est pas un jeton ERC-20) sur L1                                                                           |
-| \_l2Token | Lib_PredeployAddresses.OVM_ETH | Le contrat L2 qui gère ETH sur Optimism, `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000` (ce contrat est destiné à un usage Optimism uniquement interne) |
-| \_from    | \_from                         | L'adresse sur L1 qui envoie l'ETH                                                                                                                     |
-| \_to      | \_to                           | L'adresse sur L2 qui reçoit l'ETH                                                                                                                     |
-| amount    | msg.value                      | Montant de Wei envoyé (qui a déjà été envoyé sur la passerelle)                                                                                       |
-| \_data    | \_data                         | Date supplémentaire à joindre au dépôt                                                                                                                |
+| Paramètre                       | Valeur                                                                                   | Signification                                                                                                                                                                |
+| ------------------------------- | ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| \_l1Token | adresse(0)                                                            | Valeur spéciale pour représenter l'ETH (qui n'est pas un jeton ERC-20) sur la L1                                                                          |
+| \_l2Token | Lib_PredeployAddresses.OVM_ETH | Le contrat L2 qui gère l'ETH sur Optimism, `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000` (ce contrat est destiné à un usage interne à Optimism uniquement) |
+| \_from    | \_from                                                             | L'adresse sur la L1 qui envoie l'ETH                                                                                                                                         |
+| \_to      | \_to                                                               | L'adresse sur la L2 qui reçoit l'ETH                                                                                                                                         |
+| montant                         | msg.value                                                                | Montant de wei envoyé (qui a déjà été envoyé au pont)                                                                                                     |
+| \_data    | \_data                                                             | Données supplémentaires à joindre au dépôt                                                                                                                                   |
 
 ```solidity
-        // Send calldata into L2
+        // Envoyer les calldata vers la L2
         // slither-disable-next-line reentrancy-events
         sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
 ```
 
-Envoyez le message à travers le messager inter-domaine.
+Envoyer le message via le messager inter-domaines.
 
 ```solidity
         // slither-disable-next-line reentrancy-events
@@ -694,16 +738,16 @@ Envoyez le message à travers le messager inter-domaine.
     }
 ```
 
-Émettre un événement pour informer toute application décentralisée qui écoute ce transfert.
+Émettre un événement pour informer de ce transfert toute application décentralisée qui écoute.
 
 ```solidity
     /**
      * @inheritdoc IL1ERC20Bridge
      */
     function depositERC20(
-        .
-        .
-        .
+		.
+		.
+		.
     ) external virtual onlyEOA {
         _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
     }
@@ -712,30 +756,30 @@ Envoyez le message à travers le messager inter-domaine.
      * @inheritdoc IL1ERC20Bridge
      */
     function depositERC20To(
-        .
-        .
-        .
+		.
+		.
+		.
     ) external virtual {
         _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
     }
 ```
 
-Ces deux fonctions sont enveloppées autour de `_initiateERC20Deposit`, la fonction qui gère le dépôt réel ETH.
+Ces deux fonctions sont des wrappers autour de `_initiateERC20Deposit`, la fonction qui gère le dépôt réel d'ERC-20.
 
 ```solidity
     /**
-     * @dev Performs the logic for deposits by informing the L2 Deposited Token
-     * contract of the deposit and calling a handler to lock the L1 funds. (e.g., transferFrom)
+     * @dev Exécute la logique des dépôts en informant le contrat du jeton déposé L2
+     * du dépôt et en appelant un gestionnaire pour verrouiller les fonds L1. (par exemple, transferFrom)
      *
-     * @param _l1Token Address of the L1 ERC20 we are depositing
-     * @param _l2Token Address of the L1 respective L2 ERC20
-     * @param _from Account to pull the deposit from on L1
-     * @param _to Account to give the deposit to on L2
-     * @param _amount Amount of the ERC20 to deposit.
-     * @param _l2Gas Gas limit required to complete the deposit on L2.
-     * @param _data Optional data to forward to L2. This data is provided
-     *        solely as a convenience for external contracts. Aside from enforcing a maximum
-     *        length, these contracts provide no guarantees about its content.
+     * @param _l1Token Adresse de l'ERC20 de L1 que nous déposons
+     * @param _l2Token Adresse de l'ERC20 respectif de L2
+     * @param _from Compte à partir duquel retirer le dépôt sur la L1
+     * @param _to Compte auquel donner le dépôt sur la L2
+     * @param _amount Montant de l'ERC20 à déposer.
+     * @param _l2Gas Limite de gaz requise pour finaliser le dépôt sur la L2.
+     * @param _data Données facultatives à transmettre à la L2. Ces données sont fournies
+     *        uniquement pour la commodité des contrats externes. En dehors de l'application d'une longueur
+     *        maximale, ces contrats ne fournissent aucune garantie sur leur contenu.
      */
     function _initiateERC20Deposit(
         address _l1Token,
@@ -748,26 +792,29 @@ Ces deux fonctions sont enveloppées autour de `_initiateERC20Deposit`, la fonct
     ) internal {
 ```
 
-Cette fonction est similaire à `_initiateETHDeposit` ci-dessus, avec quelques différences importantes. La première différence est que cette fonction reçoit les adresses de jetons et le montant à transférer en tant que paramètres. Dans le cas d'ETH, l'appel à la passerelle comprend déjà le transfert de l'actif à la passerelle de connexion (`msg.value`).
+Cette fonction est similaire à `_initiateETHDeposit` ci-dessus, avec quelques différences importantes.
+La première différence est que cette fonction reçoit les adresses de jeton et le montant à transférer comme paramètres.
+Dans le cas de l'ETH, l'appel au pont inclut déjà le transfert de l'actif au compte du pont (`msg.value`).
 
 ```solidity
-        // When a deposit is initiated on L1, the L1 Bridge transfers the funds to itself for future
-        // withdrawals. safeTransferFrom also checks if the contract has code, so this will fail if
-        // _from is an EOA or address(0).
+        // Lorsqu'un dépôt est initié sur la L1, le pont L1 transfère les fonds à lui-même pour de futurs
+        // retraits. safeTransferFrom vérifie également si le contrat a du code, donc cela échouera si
+        // _from est un EOA ou address(0).
         // slither-disable-next-line reentrancy-events, reentrancy-benign
         IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
 ```
 
-Les transferts de jetons ERC-20 suivent un processus différent de celui pour ETH :
+Les transferts de jetons ERC-20 suivent un processus différent de celui de l'ETH :
 
-1. L'utilisateur (`_from`) apporte une provision à la passerelle de connexion pour transférer les jetons appropriés.
-2. L'utilisateur appelle la passerelle de connexion avec l'adresse du contrat de jeton, le montant, etc.
-3. La passerelle transfère les jetons (à elle-même) dans le cadre du processus de dépôt.
+1. L'utilisateur (`_from`) donne une autorisation au pont pour transférer les jetons appropriés.
+2. L'utilisateur appelle le pont avec l'adresse du contrat de jeton, le montant, etc.
+3. Le pont transfère les jetons (à lui-même) dans le cadre du processus de dépôt.
 
-La première étape peut se produire dans une transaction séparée des deux dernières. Cependant, front-running n'est pas un problème car les deux fonctions qui appellent `_initiateERC20Deposit` (`depositERC20` et `depositERC20To`) n'appellent cette fonction qu'avec `msg.sender` en tant que paramètre `_from`.
+La première étape peut se produire dans une transaction distincte des deux dernières.
+Cependant, le front-running n'est pas un problème car les deux fonctions qui appellent `_initiateERC20Deposit` (`depositERC20` et `depositERC20To`) n'appellent cette fonction qu'avec `msg.sender` comme paramètre `_from`.
 
 ```solidity
-        // Construct calldata for _l2Token.finalizeDeposit(_to, _amount)
+        // Construire les calldata pour _l2Token.finalizeDeposit(_to, _amount)
         bytes memory message = abi.encodeWithSelector(
             IL2ERC20Bridge.finalizeDeposit.selector,
             _l1Token,
@@ -778,7 +825,7 @@ La première étape peut se produire dans une transaction séparée des deux der
             _data
         );
 
-        // Send calldata into L2
+        // Envoyer les calldata vers la L2
         // slither-disable-next-line reentrancy-events, reentrancy-benign
         sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
 
@@ -786,7 +833,8 @@ La première étape peut se produire dans une transaction séparée des deux der
         deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;
 ```
 
-Ajoute le nombre de jetons déposés à la structure de données `deposits`. Il pourrait y avoir plusieurs adresses sur L2 qui correspondent au même jeton L1 ERC-20, donc il n'est pas suffisant d'utiliser le solde sur la passerelle de jetons L1 ERC-20 pour garder une trace des dépôts.
+Ajouter le montant de jetons déposé à la structure de données `deposits`.
+Il pourrait y avoir plusieurs adresses sur la L2 qui correspondent au même jeton ERC-20 de L1, il n'est donc pas suffisant d'utiliser le solde du pont du jeton ERC-20 de L1 pour suivre les dépôts.
 
 ```solidity
 
@@ -795,7 +843,7 @@ Ajoute le nombre de jetons déposés à la structure de données `deposits`. Il
     }
 
     /*************************
-     * Cross-chain Functions *
+     * Fonctions inter-chaînes *
      *************************/
 
     /**
@@ -808,29 +856,30 @@ Ajoute le nombre de jetons déposés à la structure de données `deposits`. Il
         bytes calldata _data
 ```
 
-La passerelle de connexion L2 envoie un message au messager du domaine transversal L2 qui fait que le messager du domaine transversal L1 appelle cette fonction (lorsque la transaction [qui finalise le message](https://community.optimism.io/docs/developers/bridge/messaging/#fees-for-l2-%E2%87%92-l1-transactions) est soumise sur L1, bien sûr).
+Le pont L2 envoie un message au messager inter-domaines L2, ce qui amène le messager inter-domaines L1 à appeler cette fonction (une fois que la [transaction qui finalise le message](https://community.optimism.io/docs/developers/bridge/messaging/#fees-for-l2-%E2%87%92-l1-transactions) est soumise sur la L1, bien sûr).
 
 ```solidity
     ) external onlyFromCrossDomainAccount(l2TokenBridge) {
 ```
 
-Assurez-vous qu'il s'agit d'un message _légitime_ provenant de la messagerie inter-domaine et originaire de la passerelle de jeton L2. Cette fonction est utilisée pour retirer l'ETH de la passerelle de connexion ainsi, nous devons nous assurer qu'elle n'est appelée que par l'appelant autorisé.
+Assurez-vous qu'il s'agit d'un message _légitime_, provenant du messager inter-domaines et émanant du pont de jetons L2.
+Cette fonction est utilisée pour retirer de l'ETH du pont, nous devons donc nous assurer qu'elle n'est appelée que par l'appelant autorisé.
 
 ```solidity
         // slither-disable-next-line reentrancy-events
         (bool success, ) = _to.call{ value: _amount }(new bytes(0));
 ```
 
-Le moyen de transférer de l'ETH est d'appeler le destinataire avec le montant de wei dans le `msg.value`.
+La manière de transférer de l'ETH est d'appeler le destinataire avec le montant de wei dans `msg.value`.
 
 ```solidity
-        require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
+        require(success, "TransferHelper::safeTransferETH: le transfert d'ETH a échoué");
 
         // slither-disable-next-line reentrancy-events
         emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
 ```
 
-Émettre un événement à propos du retrait.
+Émettre un événement concernant le retrait.
 
 ```solidity
     }
@@ -848,7 +897,7 @@ Le moyen de transférer de l'ETH est d'appeler le destinataire avec le montant d
     ) external onlyFromCrossDomainAccount(l2TokenBridge) {
 ```
 
-Cette fonction est similaire à `finalizeETHWithal` ci-dessus, avec les changements nécessaires pour les jetons ERC-20.
+Cette fonction est similaire à `finalizeETHWithdrawal` ci-dessus, avec les changements nécessaires pour les jetons ERC-20.
 
 ```solidity
         deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
@@ -858,7 +907,7 @@ Mettre à jour la structure de données `deposits`.
 
 ```solidity
 
-        // When a withdrawal is finalized on L1, the L1 Bridge transfers the funds to the withdrawer
+        // Lorsqu'un retrait est finalisé sur la L1, le pont L1 transfère les fonds au retireur
         // slither-disable-next-line reentrancy-events
         IERC20(_l1Token).safeTransfer(_to, _amount);
 
@@ -868,28 +917,35 @@ Mettre à jour la structure de données `deposits`.
 
 
     /*****************************
-     * Temporary - Migrating ETH *
+     * Temporaire - Migration d'ETH *
      *****************************/
 
     /**
-     * @dev Adds ETH balance to the account. This is meant to allow for ETH
-     * to be migrated from an old gateway to a new gateway.
-     * NOTE: This is left for one upgrade only so we are able to receive the migrated ETH from the
-     * old contract
+     * @dev Ajoute un solde d'ETH au compte. Cela vise à permettre à l'ETH
+     * d'être migré d'une ancienne passerelle vers une nouvelle passerelle.
+     * NOTE : Ceci est laissé pour une seule mise à jour afin que nous puissions recevoir l'ETH migré de l'ancien
+     * contrat
      */
     function donateETH() external payable {}
 }
 ```
 
-Il y a eu une implémentation antérieure de la passerelle. Lorsque nous sommes passés de l'implémentation à celle-ci, nous avons dû déplacer tous les actifs. Les jetons ERC-20 peuvent juste être déplacés. Cependant, pour transférer l'ETH à un contrat, vous avez besoin de l'approbation de ce contrat, ce que `donateETH` nous fournit.
+Il y a eu une implémentation antérieure du pont.
+Lorsque nous sommes passés de l'ancienne implémentation à celle-ci, nous avons dû déplacer tous les actifs.
+Les jetons ERC-20 peuvent simplement être déplacés.
+Cependant, pour transférer de l'ETH à un contrat, vous avez besoin de l'approbation de ce contrat, ce que `donateETH` nous fournit.
 
-## Jetons ERC-20 sur L2 {#erc-20-tokens-on-l2}
+## Jetons ERC-20 sur la L2 {#erc-20-tokens-on-l2}
 
-Pour qu'un jeton ERC-20 s'intègre dans la passerelle standard, il doit permettre à la passerelle de connexion standard, et _uniquement_ la passerelle standard, de frapper des jetons. Ceci est nécessaire, car les passerelles doivent s'assurer que le nombre de jetons circulant sur Optimism est égal au nombre de jetons verrouillés à l'intérieur du contrat passerelle L1. S'il existe trop de jetons sur L2, certains utilisateurs seraient incapables de récupérer leurs actifs sur L1. Au lieu d'une passerelle de confiance, nous recréerions en fait une [banque de réserve fractionnaire](https://www.investopedia.com/terms/f/fractionalreservebanking.asp). S'il y a trop de jetons sur L1, certains de ces jetons resteraient bloqués à l'intérieur du contrat passerelle pour toujours puisqu'il n'y a aucun moyen de les libérer sans brûler les jetons L2.
+Pour qu'un jeton ERC-20 s'intègre dans le pont standard, il doit permettre au pont standard, et _uniquement_ au pont standard, de frapper des jetons.
+Ceci est nécessaire car les ponts doivent s'assurer que le nombre de jetons circulant sur Optimism est égal au nombre de jetons verrouillés dans le contrat du pont L1.
+S'il y a trop de jetons sur la L2, certains utilisateurs ne pourraient pas ponter leurs actifs pour les ramener sur la L1.
+Au lieu d'un pont de confiance, nous recréerions essentiellement un [système bancaire à réserves fractionnaires](https://www.investopedia.com/terms/f/fractionalreservebanking.asp).
+S'il y a trop de jetons sur la L1, certains de ces jetons resteraient verrouillés à l'intérieur du contrat du pont pour toujours, car il n'y a aucun moyen de les libérer sans brûler des jetons L2.
 
 ### IL2StandardERC20 {#il2standarderc20}
 
-Chaque jeton ERC-20 sur L2 qui utilise la passerelle standard doit fournir [cette interface](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/IL2StandardERC20.sol), qui possède les fonctions et les événements dont la passerelle standard a besoin.
+Chaque jeton ERC-20 sur la L2 qui utilise le pont standard doit fournir [cette interface](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/IL2StandardERC20.sol), qui contient les fonctions et les événements dont le pont standard a besoin.
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -898,20 +954,24 @@ pragma solidity ^0.8.9;
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 ```
 
-[L'interface standard ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) ne dispose ni des fonctions `mint` ni `burn`. Ces méthodes ne sont pas requises par [le standard ERC-20](https://eips.ethereum.org/EIPS/eip-20), qui laisse les mécanismes non spécifiés pour créer et détruire des jetons.
+[L'interface standard ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) n'inclut pas les fonctions `mint` et `burn`.
+Ces méthodes ne sont pas requises par [la norme ERC-20](https://eips.ethereum.org/EIPS/eip-20), qui ne spécifie pas les mécanismes de création et de destruction des jetons.
 
 ```solidity
 import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 ```
 
-[L'interface ERC-165](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol) est utilisée pour spécifier quelles fonctions sont proposées par un contrat. [Vous pouvez lire le standard ici](https://eips.ethereum.org/EIPS/eip-165).
+[L'interface ERC-165](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol) est utilisée pour spécifier les fonctions qu'un contrat fournit.
+[Vous pouvez lire la norme ici](https://eips.ethereum.org/EIPS/eip-165).
 
 ```solidity
 interface IL2StandardERC20 is IERC20, IERC165 {
     function l1Token() external returns (address);
 ```
 
-Cette fonction fournit l'adresse du jeton L1 qui est relié à ce contrat. Notez que nous n'avons pas de fonction similaire dans la direction opposée. Nous devons être en mesure de relier tout jeton L1, que la prise en charge L2 ait été planifiée ou non lorsqu'il a été implémenté.
+Cette fonction fournit l'adresse du jeton L1 qui est ponté vers ce contrat.
+Notez que nous n'avons pas de fonction similaire dans la direction opposée.
+Nous devons être en mesure de ponter n'importe quel jeton L1, que la prise en charge de la L2 ait été prévue ou non lors de son implémentation.
 
 ```solidity
 
@@ -924,11 +984,13 @@ Cette fonction fournit l'adresse du jeton L1 qui est relié à ce contrat. Notez
 }
 ```
 
-Les fonctions et événements à frapper (créer) et brûler (détruire) des jetons. La passerelle de connexion devrait être la seule entité qui puisse exécuter ces fonctions pour s'assurer que le nombre de jetons est correct (égal au nombre de jetons verrouillés sur L1).
+Fonctions et événements pour frapper (créer) et brûler (détruire) des jetons.
+Le pont doit être la seule entité pouvant exécuter ces fonctions pour garantir que le nombre de jetons est correct (égal au nombre de jetons verrouillés sur la L1).
 
 ### L2StandardERC20 {#L2StandardERC20}
 
-[Ceci est notre implémentation de l'interface `IL2StandardERC20`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/L2StandardERC20.sol). À moins que vous n'ayez besoin d'une sorte de logique personnalisée, vous devriez utiliser celle-ci.
+[Ceci est notre implémentation de l'interface `IL2StandardERC20`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/L2StandardERC20.sol).
+À moins que vous n'ayez besoin d'une logique personnalisée, vous devriez utiliser celle-ci.
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -937,7 +999,8 @@ pragma solidity ^0.8.9;
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 ```
 
-[Le contrat OpenZeppelin ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol). Optimism ne souhaite pas réinventer de la roue, surtout lorsque la roue est bien contrôlée et a besoin d'être suffisamment digne de confiance pour détenir des actifs.
+[Le contrat ERC-20 d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol).
+Optimism ne croit pas à la réinvention de la roue, surtout lorsque la roue est bien auditée et doit être suffisamment fiable pour détenir des actifs.
 
 ```solidity
 import "./IL2StandardERC20.sol";
@@ -947,15 +1010,15 @@ contract L2StandardERC20 is IL2StandardERC20, ERC20 {
     address public l2Bridge;
 ```
 
-Ce sont les deux paramètres de configuration supplémentaires dont nous avons besoin et que ERC-20 ne réalise normalement pas.
+Ce sont les deux paramètres de configuration supplémentaires que nous exigeons et qu'un ERC-20 ne requiert normalement pas.
 
 ```solidity
 
     /**
-     * @param _l2Bridge Address of the L2 standard bridge.
-     * @param _l1Token Address of the corresponding L1 token.
-     * @param _name ERC20 name.
-     * @param _symbol ERC20 symbol.
+     * @param _l2Bridge Adresse du pont standard L2.
+     * @param _l1Token Adresse du jeton L1 correspondant.
+     * @param _name Nom ERC20.
+     * @param _symbol Symbole ERC20.
      */
     constructor(
         address _l2Bridge,
@@ -968,12 +1031,12 @@ Ce sont les deux paramètres de configuration supplémentaires dont nous avons b
     }
 ```
 
-En premier lieu, appelez le constructeur pour le contrat dont nous héritons de (`ERC20(_name, _symbol)`) et définissez ensuite vos propres variables.
+Appelez d'abord le constructeur pour le contrat dont nous héritons (`ERC20(_name, _symbol)`) puis définissez nos propres variables.
 
 ```solidity
 
     modifier onlyL2Bridge() {
-        require(msg.sender == l2Bridge, "Only L2 Bridge can mint and burn");
+        require(msg.sender == l2Bridge, "Seul le pont L2 peut frapper et brûler");
         _;
     }
 
@@ -988,11 +1051,12 @@ En premier lieu, appelez le constructeur pour le contrat dont nous héritons de
     }
 ```
 
-C'est ainsi que fonctionne [ERC-165](https://eips.ethereum.org/EIPS/eip-165). Chaque interface est un certain nombre de fonctions supportées, et est identifiée comme ABI[exclusive ou](https://en.wikipedia.org/wiki/Exclusive_or) des [sélecteurs de fonctions ABI](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html#function-selector) pour ces fonctions.
+C'est ainsi que [l'ERC-165](https://eips.ethereum.org/EIPS/eip-165) fonctionne.
+Chaque interface est un certain nombre de fonctions prises en charge, et est identifiée comme le [ou exclusif](https://en.wikipedia.org/wiki/Exclusive_or) des [sélecteurs de fonction ABI](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html#function-selector) de ces fonctions.
 
-La passerelle de connexion L2 utilise ERC-165 comme vérification garantissant que le contrat ERC-20 auquel des actifs sont envoyés est un `IL2StandardERC20`.
+Le pont L2 utilise l'ERC-165 comme une vérification de bon sens pour s'assurer que le contrat ERC-20 auquel il envoie des actifs est un `IL2StandardERC20`.
 
-**Remarque :** Il n'existe rien pour empêcher le contrat dévoyé de fournir de fausses réponses à `supportsInterface` ainsi, il s'agit donc d'un mécanisme de vérification et non _pas_ un mécanisme de sécurité.
+**Note :** Rien n'empêche un contrat malveillant de fournir de fausses réponses à `supportsInterface`, il s'agit donc d'un mécanisme de vérification de bon sens, _pas_ d'un mécanisme de sécurité.
 
 ```solidity
     // slither-disable-next-line external-function
@@ -1011,13 +1075,15 @@ La passerelle de connexion L2 utilise ERC-165 comme vérification garantissant q
 }
 ```
 
-Seul la passerelle L2 est autorisée à frapper et à brûler des actifs.
+Seul le pont L2 est autorisé à frapper et brûler des actifs.
 
-`_mint` et `_burn` sont définis dans le contrat [OpenZeppelin ERC-20](/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn). Ce contrat ne les expose pas en externe, parce que les conditions de frappe et de brûlage des jetons sont aussi variées que le nombre de façons d'utiliser ERC-20.
+`_mint` et `_burn` sont en fait définis dans le [contrat ERC-20 d'OpenZeppelin](/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn).
+Ce contrat ne les expose tout simplement pas à l'extérieur, car les conditions pour frapper et brûler des jetons sont aussi variées que le nombre de façons d'utiliser l'ERC-20.
 
-## Code de passerelle L2 {#l2-bridge-code}
+## Code du pont L2 {#l2-bridge-code}
 
-Il s'agit du code qui exécute la passerelle de connexion sur Optimism. [La source de ce contrat se trouve ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol).
+C'est le code qui exécute le pont sur Optimism.
+[La source de ce contrat est ici](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol).
 
 ```solidity
 // SPDX-License-Identifier: MIT
@@ -1029,10 +1095,13 @@ import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
 import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
 ```
 
-L'interface [IL2ERC20Bridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) est très similaire à [l'équivalent L1](#IL1ERC20Bridge) que nous avons vu ci-dessus. Il existe deux différences significatives :
+L'interface [IL2ERC20Bridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) est très similaire à l'[équivalent L1](#IL1ERC20Bridge) que nous avons vu plus haut.
+Il y a deux différences significatives :
 
-1. Sur L1, vous initiez des dépôts et finalisez des retraits. Ici, vous initiez des retraits et finalisez les dépôts.
-2. Sur L1, il est nécessaire de faire une distinction entre les jetons ETH et ERC-20. Sur L2, nous pouvons utiliser les mêmes fonctions pour les deux, parce que les soldes ETH en interne sur Optimism sont traités comme un jeton ERC-20 avec l'adresse [0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000](https://optimistic.etherscan.io/address/0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000).
+1. Sur la L1, vous initiez les dépôts et finalisez les retraits.
+   Ici, vous initiez les retraits et finalisez les dépôts.
+2. Sur la L1, il est nécessaire de distinguer l'ETH des jetons ERC-20.
+   Sur la L2, nous pouvons utiliser les mêmes fonctions pour les deux car, en interne, les soldes d'ETH sur Optimism sont gérés comme un jeton ERC-20 avec l'adresse [0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000](https://explorer.optimism.io/address/0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000).
 
 ```solidity
 /* Library Imports */
@@ -1045,32 +1114,33 @@ import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
 
 /**
  * @title L2StandardBridge
- * @dev The L2 Standard bridge is a contract which works together with the L1 Standard bridge to
- * enable ETH and ERC20 transitions between L1 and L2.
- * This contract acts as a minter for new tokens when it hears about deposits into the L1 Standard
- * bridge.
- * This contract also acts as a burner of the tokens intended for withdrawal, informing the L1
- * bridge to release L1 funds.
+ * @dev Le pont standard L2 est un contrat qui fonctionne en collaboration avec le pont standard L1 pour
+ * permettre les transitions d'ETH et d'ERC20 entre la L1 et la L2.
+ * Ce contrat agit comme un frappeur de nouveaux jetons lorsqu'il est informé de dépôts dans le pont standard L1.
+ * Ce contrat agit également comme un brûleur de jetons destinés au retrait, informant le pont L1
+ * de libérer les fonds L1.
  */
 contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
     /********************************
-     * External Contract References *
+     * Références de contrats externes *
      ********************************/
 
     address public l1TokenBridge;
 ```
 
-Conserver la trace de l'adresse de la passerelle de connexion L1. Notez que contrairement à l'équivalent pour L1, ici nous \_ avons besoin \_de cette variable. L'adresse de la passerelle L1 n'est pas connue à l'avance.
+Garder une trace de l'adresse du pont L1.
+Notez que contrairement à l'équivalent L1, ici nous _avons besoin_ de cette variable.
+L'adresse du pont L1 n'est pas connue à l'avance.
 
 ```solidity
 
     /***************
-     * Constructor *
+     * Constructeur *
      ***************/
 
     /**
-     * @param _l2CrossDomainMessenger Cross-domain messenger used by this contract.
-     * @param _l1TokenBridge Address of the L1 bridge deployed to the main chain.
+     * @param _l2CrossDomainMessenger Messager inter-domaines utilisé par ce contrat.
+     * @param _l1TokenBridge Adresse du pont L1 déployé sur la chaîne principale.
      */
     constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
         CrossDomainEnabled(_l2CrossDomainMessenger)
@@ -1079,7 +1149,7 @@ Conserver la trace de l'adresse de la passerelle de connexion L1. Notez que cont
     }
 
     /***************
-     * Withdrawing *
+     * Retrait *
      ***************/
 
     /**
@@ -1108,21 +1178,23 @@ Conserver la trace de l'adresse de la passerelle de connexion L1. Notez que cont
     }
 ```
 
-Ces deux fonctions initient les retraits. Notez qu'il n'y a pas besoin de spécifier l'adresse de jeton L1. Les jetons L2 doivent nous indiquer l'adresse de l'équivalent L1.
+Ces deux fonctions initient les retraits.
+Notez qu'il n'est pas nécessaire de spécifier l'adresse du jeton L1.
+Les jetons L2 sont censés nous indiquer l'adresse de l'équivalent L1.
 
 ```solidity
 
     /**
-     * @dev Performs the logic for withdrawals by burning the token and informing
-     *      the L1 token Gateway of the withdrawal.
-     * @param _l2Token Address of L2 token where withdrawal is initiated.
-     * @param _from Account to pull the withdrawal from on L2.
-     * @param _to Account to give the withdrawal to on L1.
-     * @param _amount Amount of the token to withdraw.
-     * @param _l1Gas Unused, but included for potential forward compatibility considerations.
-     * @param _data Optional data to forward to L1. This data is provided
-     *        solely as a convenience for external contracts. Aside from enforcing a maximum
-     *        length, these contracts provide no guarantees about its content.
+     * @dev Exécute la logique des retraits en brûlant le jeton et en informant
+     * la passerelle de jetons L1 du retrait.
+     * @param _l2Token Adresse du jeton L2 où le retrait est initié.
+     * @param _from Compte à partir duquel retirer le retrait sur la L2.
+     * @param _to Compte auquel donner le retrait sur la L1.
+     * @param _amount Montant du jeton à retirer.
+     * @param _l1Gas Inutilisé, mais inclus pour des considérations de compatibilité ascendante potentielles.
+     * @param _data Données facultatives à transmettre à la L1. Ces données sont fournies
+     *        uniquement pour la commodité des contrats externes. En dehors de l'application d'une longueur
+     *        maximale, ces contrats ne fournissent aucune garantie sur leur contenu.
      */
     function _initiateWithdrawal(
         address _l2Token,
@@ -1132,17 +1204,17 @@ Ces deux fonctions initient les retraits. Notez qu'il n'y a pas besoin de spéci
         uint32 _l1Gas,
         bytes calldata _data
     ) internal {
-        // When a withdrawal is initiated, we burn the withdrawer's funds to prevent subsequent L2
-        // usage
+        // Lorsqu'un retrait est initié, nous brûlons les fonds du retireur pour empêcher une utilisation ultérieure sur la L2
+        //
         // slither-disable-next-line reentrancy-events
         IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
 ```
 
-Notez que nous ne sommes _pas_ reliés au paramètre `_from` mais à `msg.sender` qui est beaucoup plus difficile à contrefaire (même impossible, à ma connaissance).
+Notez que nous ne nous fions _pas_ au paramètre `_from` mais à `msg.sender` qui est beaucoup plus difficile à falsifier (impossible, à ma connaissance).
 
 ```solidity
 
-        // Construct calldata for l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)
+        // Construire les calldata pour l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)
         // slither-disable-next-line reentrancy-events
         address l1Token = IL2StandardERC20(_l2Token).l1Token();
         bytes memory message;
@@ -1150,7 +1222,7 @@ Notez que nous ne sommes _pas_ reliés au paramètre `_from` mais à `msg.sender
         if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
 ```
 
-Sur L1, il est nécessaire de faire une distinction entre les jetons ETH et ERC-20.
+Sur la L1, il est nécessaire de distinguer l'ETH de l'ERC-20.
 
 ```solidity
             message = abi.encodeWithSelector(
@@ -1172,7 +1244,7 @@ Sur L1, il est nécessaire de faire une distinction entre les jetons ETH et ERC-
             );
         }
 
-        // Send message up to L1 bridge
+        // Envoyer le message au pont L1
         // slither-disable-next-line reentrancy-events
         sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);
 
@@ -1181,7 +1253,7 @@ Sur L1, il est nécessaire de faire une distinction entre les jetons ETH et ERC-
     }
 
     /************************************
-     * Cross-chain Function: Depositing *
+     * Fonction inter-chaînes : Dépôt *
      ************************************/
 
     /**
@@ -1196,69 +1268,71 @@ Sur L1, il est nécessaire de faire une distinction entre les jetons ETH et ERC-
         bytes calldata _data
 ```
 
-Cette fonction est appelée via `L1StandardBridge`.
+Cette fonction est appelée par `L1StandardBridge`.
 
 ```solidity
     ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
 ```
 
-Assurez-vous que la source du message est fiable. C'est important car cette fonction appelle `_mint` et peut être utilisée pour donner des jetons qui ne sont pas couverts par des jetons que la passerelle possède sur L1.
+Assurez-vous que la source du message est légitime.
+C'est important car cette fonction appelle `_mint` et pourrait être utilisée pour donner des jetons qui ne sont pas couverts par des jetons que le pont possède sur la L1.
 
 ```solidity
-        // Check the target token is compliant and
-        // verify the deposited token on L1 matches the L2 deposited token representation here
+        // Vérifier que le jeton cible est conforme et
+        // vérifier que le jeton déposé sur la L1 correspond à la représentation du jeton déposé sur la L2 ici
         if (
             // slither-disable-next-line reentrancy-events
             ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
             _l1Token == IL2StandardERC20(_l2Token).l1Token()
 ```
 
-Contrôle de cohérence :
+Vérifications de bon sens :
 
 1. L'interface correcte est prise en charge
-2. L'adresse du contrat L2 ERC-20 du L1 correspond à la source L1 des jetons
+2. L'adresse L1 du contrat ERC-20 L2 correspond à la source L1 des jetons
 
 ```solidity
         ) {
-            // When a deposit is finalized, we credit the account on L2 with the same amount of
-            // tokens.
+            // Lorsqu'un dépôt est finalisé, nous créditons le compte sur la L2 avec le même montant
+            // de jetons.
             // slither-disable-next-line reentrancy-events
             IL2StandardERC20(_l2Token).mint(_to, _amount);
             // slither-disable-next-line reentrancy-events
             emit DepositFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
 ```
 
-Si les contrôles de cohérence sont effectués, finalisez le dépôt :
+Si les vérifications de bon sens sont concluantes, finalisez le dépôt :
 
 1. Frapper les jetons
 2. Émettre l'événement approprié
 
 ```solidity
         } else {
-            // Either the L2 token which is being deposited-into disagrees about the correct address
-            // of its L1 token, or does not support the correct interface.
-            // This should only happen if there is a  malicious L2 token, or if a user somehow
-            // specified the wrong L2 token address to deposit into.
-            // In either case, we stop the process here and construct a withdrawal
-            // message so that users can get their funds out in some cases.
-            // There is no way to prevent malicious token contracts altogether, but this does limit
-            // user error and mitigate some forms of malicious contract behavior.
+            // Soit le jeton L2 dans lequel le dépôt est effectué est en désaccord sur l'adresse correcte
+            // de son jeton L1, soit il ne prend pas en charge l'interface correcte.
+            // Cela ne devrait se produire que s'il y a un jeton L2 malveillant, ou si un utilisateur a
+            // spécifié la mauvaise adresse de jeton L2 pour le dépôt.
+            // Dans tous les cas, nous arrêtons le processus ici et construisons un message de retrait
+            // afin que les utilisateurs puissent récupérer leurs fonds dans certains cas.
+            // Il n'y a aucun moyen d'empêcher complètement les contrats de jetons malveillants, mais cela limite
+            // les erreurs des utilisateurs et atténue certaines formes de comportement de contrat malveillant.
 ```
 
-Si un utilisateur a fait une erreur détectable en utilisant la mauvaise adresse de jeton L2, nous souhaitons annuler le dépôt et retourner les jetons sur L1. La seule façon de le faire à partir de L2 est d'envoyer un message qui devra attendre la période problématique de défaut mais c'est beaucoup mieux pour l'utilisateur que de perdre les jetons définitivement.
+Si un utilisateur a commis une erreur détectable en utilisant la mauvaise adresse de jeton L2, nous voulons annuler le dépôt et retourner les jetons sur la L1.
+La seule façon de le faire depuis la L2 est d'envoyer un message qui devra attendre la période de contestation des erreurs, mais c'est bien mieux pour l'utilisateur que de perdre les jetons de manière permanente.
 
 ```solidity
             bytes memory message = abi.encodeWithSelector(
                 IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                 _l1Token,
                 _l2Token,
-                _to, // switched the _to and _from here to bounce back the deposit to the sender
+                _to, // a inversé le _to et le _from ici pour renvoyer le dépôt à l'expéditeur
                 _from,
                 _amount,
                 _data
             );
 
-            // Send message up to L1 bridge
+            // Envoyer le message au pont L1
             // slither-disable-next-line reentrancy-events
             sendCrossDomainMessage(l1TokenBridge, 0, message);
             // slither-disable-next-line reentrancy-events
@@ -1270,8 +1344,13 @@ Si un utilisateur a fait une erreur détectable en utilisant la mauvaise adresse
 
 ## Conclusion {#conclusion}
 
-La passerelle standard est le mécanisme le plus souple pour les transferts d'actifs. Cependant, parce qu'il est si générique, ce n'est pas toujours le mécanisme le plus facile à utiliser. Spécialement pour les retraits, la plupart des utilisateurs préfèrent utiliser des [passerelles tierces](https://optimism.io/apps#bridge) qui n'attendent pas la période problématique et ne nécessitent pas de preuve de Merkle pour finaliser le retrait.
+Le pont standard est le mécanisme le plus flexible pour les transferts d'actifs.
+Cependant, parce qu'il est si générique, ce n'est pas toujours le mécanisme le plus facile à utiliser.
+En particulier pour les retraits, la plupart des utilisateurs préfèrent utiliser des [ponts tiers](https://optimism.io/apps#bridge) qui n'attendent pas la période de contestation et ne nécessitent pas de preuve de Merkle pour finaliser le retrait.
+
+Ces ponts fonctionnent généralement en ayant des actifs sur la L1, qu'ils fournissent immédiatement moyennant de faibles frais (souvent inférieurs au coût du gaz pour un retrait via un pont standard).
+Lorsque le pont (ou les personnes qui le gèrent) anticipe un manque d'actifs sur la L1, il transfère des actifs suffisants depuis la L2. Comme il s'agit de retraits très importants, le coût du retrait est amorti sur un montant élevé et représente un pourcentage beaucoup plus faible.
 
-Ces passerelles fonctionnent généralement en ayant des actifs sur L1 qu'ils fournissent immédiatement moyennant un petit supplément (souvent inférieur au coût du gaz pour un retrait standard d'une passerelle). Quand la passerelle (ou la personne qui la gère) prévoit d'être en deçà des actifs L1, elle transfère suffisamment d'actifs de L2. Comme il s'agit de retraits très importants, le coût de retrait est amorti sur une somme importante et représente un pourcentage beaucoup plus faible.
+Espérons que cet article vous a aidé à mieux comprendre le fonctionnement de la couche 2, et comment écrire du code Solidity clair et sécurisé.
 
-Espérons que cet article vous aide à mieux comprendre comment la couche 2 fonctionne, et comment écrire du code Solidity clair et sécurisé.
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/reverse-engineering-a-contract/index.md b/public/content/translations/fr/developers/tutorials/reverse-engineering-a-contract/index.md
index e1e7926cfb7..ebb64e72e94 100644
--- a/public/content/translations/fr/developers/tutorials/reverse-engineering-a-contract/index.md
+++ b/public/content/translations/fr/developers/tutorials/reverse-engineering-a-contract/index.md
@@ -3,307 +3,305 @@ title: "Ingénierie inverse d'un contrat"
 description: Comment comprendre un contrat quand vous n'avez pas le code source
 author: Ori Pomerantz
 lang: fr
-tags:
-  - "evm"
-  - "codes d'opérations"
+tags: [ "evm", "opcodes" ]
 skill: advanced
 published: 2021-12-30
 ---
 
 ## Introduction {#introduction}
 
-_Il n'y a aucun secret sur la blockchain_, tout ce qui se passe est cohérent, vérifiable et accessible au public. Idéalement, [les contrats devraient avoir leur code source publié et vérifié sur Etherscan](https://etherscan.io/address/0xb8901acb165ed027e32754e0ffe830802919727f#code). Or [ce n'est pas toujours le cas](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#code). Dans cet article, vous apprendrez comment rétro-concevoir des contrats en prenant comme exemple un contrat sans code source, [`0x2510c039cc3b061d79e564b38836da87e31b342f`](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f).
+_Il n'y a pas de secrets sur la blockchain_, tout ce qui se passe est cohérent, vérifiable et accessible au public. Idéalement, [les contrats devraient avoir leur code source publié et vérifié sur Etherscan](https://etherscan.io/address/0xb8901acb165ed027e32754e0ffe830802919727f#code). Cependant, [ce n'est pas toujours le cas](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#code). Dans cet article, vous apprendrez à faire de l'ingénierie inverse sur des contrats en examinant un contrat sans code source, [`0x2510c039cc3b061d79e564b38836da87e31b342f`](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f).
 
-Il existe des décompilateurs, mais ils ne produisent pas toujours [des résultats utilisables](https://etherscan.io/bytecode-decompiler?a=0x2510c039cc3b061d79e564b38836da87e31b342f). Dans cet article, vous apprendrez comment rétro-concevoir manuellement et comprendre un contrat grâce aux [opcodes](https://github.com/wolflo/evm-opcodes) et également comment interpréter les résultats du décompilateur.
+Il existe des compilateurs inverses, mais ils ne produisent pas toujours des [résultats utilisables](https://etherscan.io/bytecode-decompiler?a=0x2510c039cc3b061d79e564b38836da87e31b342f). Dans cet article, vous apprendrez comment faire manuellement de l'ingénierie inverse et comprendre un contrat à partir [des opcodes](https://github.com/wolflo/evm-opcodes), ainsi que comment interpréter les résultats d'un décompilateur.
 
-Pour être en mesure de comprendre cet article, vous devriez connaître les bases de l'EVM et être au moins familier avec l'assembleur EVM. [Vous pouvez en savoir plus sur ces sujets ici](https://medium.com/mycrypto/the-ethereum-virtual-machine-how-does-it-work-9abac2b7c9e).
+Pour pouvoir comprendre cet article, vous devez déjà connaître les bases de l'EVM et être au moins quelque peu familier avec l'assembleur EVM. [Vous pouvez vous renseigner sur ces sujets ici](https://medium.com/mycrypto/the-ethereum-virtual-machine-how-does-it-work-9abac2b7c9e).
 
-## Préparer le Code Exécutable {#prepare-the-executable-code}
+## Préparer le code exécutable {#prepare-the-executable-code}
 
-Vous pouvez récupérer les opcodes en cherchant le contrat sur Etherscan, cliquez sur l'onglet **Contract** et puis sur **Switch to Opcodes View**. Vous obtenez un affichage d'un opcode par ligne.
+Vous pouvez obtenir les opcodes en allant sur Etherscan pour le contrat, en cliquant sur l'onglet **Contract** puis sur **Switch to Opcodes View**. Vous obtenez une vue avec un opcode par ligne.
 
-![Vue Opcode depuis Etherscan](opcode-view.png)
+![Vue des opcodes depuis Etherscan](opcode-view.png)
 
-Pour être capable de comprendre les sauts, vous devez savoir où se trouve chaque opcode dans le code. Pour ce faire, vous pouvez ouvrir Google Spreadsheet et coller les codes d'opération dans le colonne C.[Vous pouvez sauter les étapes suivantes en faisant une copie de cette feuille de calcul](https://docs.google.com/spreadsheets/d/1tKmTJiNjUwHbW64wCKOSJxHjmh0bAUapt6btUYE7kDA/edit?usp=sharing).
+Toutefois, pour comprendre les sauts, vous devez savoir où se trouve chaque opcode dans le code. Pour ce faire, une solution consiste à ouvrir une feuille de calcul Google et à coller les opcodes dans la colonne C. [Vous pouvez sauter les étapes suivantes en faisant une copie de cette feuille de calcul déjà préparée](https://docs.google.com/spreadsheets/d/1tKmTJiNjUwHbW64wCKOSJxHjmh0bAUapt6btUYE7kDA/edit?usp=sharing).
 
-L'étape suivante est d'obtenir les emplacements corrects dans le code pour comprendre les sauts. Nous allons mettre la taille du code d'opération dans la colonne B et son emplacement (en hexadécimal) dans la colonne A. Entrez cette fonction dans la cellule `B1` et puis copiez-collez sur le reste de la colonne B jusqu'à la fin du code. Après cela, vous pouvez masquer la colonne B.
+L'étape suivante consiste à obtenir les emplacements de code corrects afin de pouvoir comprendre les sauts. Nous allons mettre la taille de l'opcode dans la colonne B, et l'emplacement (en hexadécimal) dans la colonne A. Tapez cette fonction dans la cellule `B1`, puis copiez-la et collez-la pour le reste de la colonne B, jusqu'à la fin du code. Après cela, vous pouvez masquer la colonne B.
 
 ```
 =1+IF(REGEXMATCH(C1,"PUSH"),REGEXEXTRACT(C1,"PUSH(\d+)"),0)
 ```
 
-Tout d'abord, cette fonction ajoute un octet au code d'opération, puis elle recherche le mot clé `PUSH`. Les codes d'opération PUSH sont spéciaux car ils doivent avoir des octets supplémentaires pour la valeur qui doit être poussée. Si l'opcode est un `PUSH`, nous extrayons le nombre d'octets et ajoutons la valeur à la taille de l'opcode.
+D'abord, cette fonction ajoute un octet pour l'opcode lui-même, puis recherche `PUSH`. Les opcodes Push sont spéciaux, car ils nécessitent des octets supplémentaires pour la valeur poussée. Si l'opcode est un `PUSH`, nous extrayons le nombre d'octets et nous l'ajoutons.
 
-Dans la cellule `A1`, déclarez la première valeur décalée à 0. Puis, dans la cellule `A2`, entrez cette fonction et copiez-collez la sur le reste de la colonne A :
+Dans `A1` mettez le premier décalage, zéro. Ensuite, dans `A2`, mettez cette fonction et copiez-collez la de nouveau pour le reste de la colonne A :
 
 ```
 =dec2hex(hex2dec(A1)+B1)
 ```
 
-Nous avons besoin de cette fonction pour nous donner la valeur hexadécimale car les valeurs poussées avant les sauts (`JUMP` et `JUMPI`) nous sont données en hexadécimal.
+Nous avons besoin de cette fonction pour nous donner la valeur hexadécimale, car les valeurs qui sont poussées avant les sauts (`JUMP` et `JUMPI`) nous sont données en hexadécimal.
 
-## Le Point d'Entrée (0x00) {#the-entry-point-0x00}
+## Le point d'entrée (0x00) {#the-entry-point-0x00}
 
-Les contrats sont toujours exécutés à partir du premier octet. Ceci est la première partie du code :
+Les contrats sont toujours exécutés à partir du premier octet. Ceci est la partie initiale du code :
 
-| Décalage | Opcode       | Pile (après le code d'opération) |
-| --------:| ------------ | -------------------------------- |
-|        0 | PUSH1 0x80   | 0x80                             |
-|        2 | PUSH1 0x40   | 0x40, 0x80                       |
-|        4 | MSTORE       | Vide                             |
-|        5 | PUSH1 0x04   | 0x04                             |
-|        7 | CALLDATASIZE | CALLDATASIZE 0x04                |
-|        8 | LT           | CALLDATASIZE\<4                   |
-|        9 | PUSH2 0x005e | 0x5E CALLDATASIZE\<4              |
-|        C | JUMPI        | Vide                             |
+| Décalage | Opcode       | Pile (après l'opcode)     |
+| -------: | ------------ | -------------------------------------------- |
+|        0 | PUSH1 0x80   | 0x80                                         |
+|        2 | PUSH1 0x40   | 0x40, 0x80                                   |
+|        4 | MSTORE       | Vide                                         |
+|        5 | PUSH1 0x04   | 0x04                                         |
+|        7 | CALLDATASIZE | CALLDATASIZE 0x04                            |
+|        8 | LT           | CALLDATASIZE&lt;4      |
+|        9 | PUSH2 0x005e | 0x5E CALLDATASIZE&lt;4 |
+|        C | JUMPI        | Vide                                         |
 
 Ce code fait deux choses :
 
-1. Écrit 0x80 sous la forme d'une valeur de 32 octets sur des emplacements de mémoire 0x40-0x5F (0x80 est stocké dans 0x5F, et 0x40-0x5E sont à zéro).
-2. Lire la taille des données d'appel. Normalement, les données d'appel pour un contrat Ethereum suivent [l'ABI (interface binaire-programme)](https://docs.soliditylang.org/en/v0.8.10/abi-spec.html), qui nécessite au minimum quatre octets pour le sélecteur de fonction. Si la taille des données d'appel est inférieure à quatre, il y a un saut à 0x5E.
+1. Écrit 0x80 comme une valeur de 32 octets aux emplacements mémoire 0x40-0x5F (0x80 est stocké dans 0x5F, et 0x40-0x5E sont tous des zéros).
+2. Lit la taille des données d'appel. Normalement, les données d'appel pour un contrat Ethereum suivent [l'ABI (interface binaire d'application)](https://docs.soliditylang.org/en/v0.8.10/abi-spec.html), qui nécessite au minimum quatre octets pour le sélecteur de fonction. Si la taille des données d'appel est inférieure à quatre, sautez à 0x5E.
 
-![Organigramme de cette partie](flowchart-entry.png)
+![Organigramme pour cette partie](flowchart-entry.png)
 
-### Le Gestionnaire à 0x5E (pour les données d'appel non-ABI) {#the-handler-at-0x5e-for-non-abi-call-data}
+### Le gestionnaire à 0x5E (pour les données d'appel non-ABI) {#the-handler-at-0x5e-for-non-abi-call-data}
 
 | Décalage | Opcode       |
-| --------:| ------------ |
+| -------: | ------------ |
 |       5E | JUMPDEST     |
 |       5F | CALLDATASIZE |
 |       60 | PUSH2 0x007c |
 |       63 | JUMPI        |
 
-Ce snippet commence avec un `JUMPDEST`. Les programmes EVM (machine virtuelle Ethereum) lèvent une exception si l'on saute à un code d'opération qui n'est pas `JUMPDEST`. Puis, il vérifie le CALLDATASIZE et si c'est « true » (c'est-à-dire, si ce n'est pas zéro), il saute à 0x7C. Nous verrons ça ci-dessous.
+Cet extrait de code commence par un `JUMPDEST`. Les programmes EVM (machine virtuelle Ethereum) lèvent une exception si vous sautez vers un opcode qui n'est pas `JUMPDEST`. Ensuite, il examine le CALLDATASIZE, et si c'est « vrai » (c'est-à-dire non nul), il saute à 0x7C. Nous y reviendrons ci-dessous.
 
-| Décalage | Opcode     | Pile (après l'opcode)                                                      |
-| --------:| ---------- | -------------------------------------------------------------------------- |
+| Décalage | Opcode     | Pile (après l'opcode)                                                   |
+| -------: | ---------- | ------------------------------------------------------------------------------------------ |
 |       64 | CALLVALUE  | [Wei](/glossary/#wei) fourni par l'appel. Appelé `msg.value` dans Solidity |
-|       65 | PUSH1 0x06 | 6 CALLVALUE                                                                |
-|       67 | PUSH1 0x00 | 0 6 CALLVALUE                                                              |
-|       69 | DUP3       | CALLVALUE 0 6 CALLVALUE                                                    |
-|       6A | DUP3       | 6 CALLVALUE 0 6 CALLVALUE                                                  |
-|       6B | SLOAD      | Storage[6] CALLVALUE 0 6 CALLVALUE                                         |
+|       65 | PUSH1 0x06 | 6 CALLVALUE                                                                                |
+|       67 | PUSH1 0x00 | 0 6 CALLVALUE                                                                              |
+|       69 | DUP3       | CALLVALUE 0 6 CALLVALUE                                                                    |
+|       6A | DUP3       | 6 CALLVALUE 0 6 CALLVALUE                                                                  |
+|       6B | SLOAD      | Stockage[6] CALLVALUE 0 6 CALLVALUE    |
 
-Ainsi, lorsqu'il n'y a pas de données d'appel, nous lisons la valeur de Stockage[6]. Nous ne savons pas encore quelle est cette valeur, mais nous pouvons rechercher les transactions que le contrat a reçues sans aucune donnée d'appel. Les transactions qui transfèrent juste de l'ETH sans aucune donnée d'appel (et donc aucune méthode) disposent de la méthode `Transfer` dans Etherscan. En fait, [la toute première transaction reçue par le contrat](https://etherscan.io/tx/0xeec75287a583c36bcc7ca87685ab41603494516a0f5986d18de96c8e630762e7) est un transfert.
+Ainsi, lorsqu'il n'y a pas de données d'appel, nous lisons la valeur de Stockage[6]. Nous ne savons pas encore quelle est cette valeur, mais nous pouvons rechercher les transactions que le contrat a reçues sans données d'appel. Les transactions qui ne font que transférer des ETH sans données d'appel (et donc sans méthode) ont dans Etherscan la méthode `Transfer`. En fait, [la toute première transaction que le contrat a reçue](https://etherscan.io/tx/0xeec75287a583c36bcc7ca87685ab41603494516a0f5986d18de96c8e630762e7) est un transfert.
 
-Si nous regardons la transaction et que nous cliquons sur **Click to see More**, nous voyons que l'appel de donnée, appelé une donnée d'entrée, est en fait vide (`0x`). Notez aussi que la valeur est à 1.559 ETH, ce qui sera intéressant plus tard.
+Si nous examinons cette transaction et cliquons sur **Click to see More**, nous voyons que les données d'appel, appelées données d'entrée, sont en effet vides (`0x`). Notez également que la valeur est de 1,559 ETH, ce qui sera pertinent plus tard.
 
 ![Les données d'appel sont vides](calldata-empty.png)
 
-Ensuite, cliquez sur l'onglet **State** et développez le contrat que nous rétro-concevons (0x2510...). Vous pouvez voir que `Stockage[6]` a changé pendant la transaction, et si vous changez l'hexadécimal en **Numéro**, vous voyez que la valeur transférée est maintenant affichée en wei : 1,559,000,000,000,000 (j'ai ajouté les virgules à des fins de clarté), correspondant à la valeur du prochain contrat.
+Ensuite, cliquez sur l'onglet **State** et développez le contrat sur lequel nous effectuons de l'ingénierie inverse (0x2510...). Vous pouvez voir que `Stockage[6]` a bien changé pendant la transaction, et si vous passez de Hex à **Number**, vous verrez que la valeur est devenue 1 559 000 000 000 000 000, la valeur transférée en wei (j'ai ajouté les virgules pour plus de clarté), correspondant à la valeur du contrat suivante.
 
 ![Le changement dans Stockage[6]](storage6.png)
 
-Si nous regardons dans les changements d'état causés par [d'autres transactions `Transfer` de la même période](https://etherscan.io/tx/0xf708d306de39c422472f43cb975d97b66fd5d6a6863db627067167cbf93d84d1#statechange) nous voyons que `Storage[6]` a suivi la valeur du contrat pendant un certain temps. Pour le moment, nous l'appellerons `Valeur*`. L'astérisque (`*`) nous rappelle que nous ne _savons_ pas ce que cette variable fait pour le moment, mais ça ne peut pas être simplement de tracer la valeur du contrat parce qu'il n'y a pas besoin d'utiliser  le stockage, qui est très cher, quand vous pouvez obtenir le solde de vos comptes à l'aide de `ADDRESS BALANCE`. Le premier code d'opérations dévoile la propre adresse du contrat. Le deuxième lit l'adresse en haut de la pile et la remplace par le solde de cette adresse.
+Si nous examinons les changements d'état causés par [d'autres transactions `Transfer` de la même période](https://etherscan.io/tx/0xf708d306de39c422472f43cb975d97b66fd5d6a6863db627067167cbf93d84d1#statechange) nous voyons que `Stockage[6]` a suivi la valeur du contrat pendant un certain temps. Pour l'instant, nous l'appellerons `Value*`. L'astérisque (\*) nous rappelle que nous ne _savons_ pas encore ce que fait cette variable, mais elle ne peut pas servir uniquement à suivre la valeur du contrat, car il n'est pas nécessaire d'utiliser le stockage, qui est très coûteux, alors que vous pouvez obtenir le solde de vos comptes en utilisant `ADDRESS BALANCE`. Le premier opcode pousse la propre adresse du contrat. Le second lit l'adresse en haut de la pile et la remplace par le solde de cette adresse.
 
-| Décalage | Opcode       | Pile                                          |
-| --------:| ------------ | --------------------------------------------- |
+| Décalage | Opcode       | Base                                        |
+| -------: | ------------ | ------------------------------------------- |
 |       6C | PUSH2 0x0075 | 0x75 Value\* CALLVALUE 0 6 CALLVALUE        |
 |       6F | SWAP2        | CALLVALUE Value\* 0x75 0 6 CALLVALUE        |
 |       70 | SWAP1        | Value\* CALLVALUE 0x75 0 6 CALLVALUE        |
 |       71 | PUSH2 0x01a7 | 0x01A7 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-|       74 | JUMP         |                                               |
+|       74 | JUMP         |                                             |
 
 Nous continuerons à tracer ce code à la destination du saut.
 
-| Décalage | Opcode     | Pile                                                          |
-| --------:| ---------- | ------------------------------------------------------------- |
+| Décalage | Opcode     | Base                                                        |
+| -------: | ---------- | ----------------------------------------------------------- |
 |      1A7 | JUMPDEST   | Value\* CALLVALUE 0x75 0 6 CALLVALUE                        |
 |      1A8 | PUSH1 0x00 | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE                   |
 |      1AA | DUP3       | CALLVALUE 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE         |
 |      1AB | NOT        | 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
 
-Le `NOT` est au niveau des bits donc il inverse la valeur de chaque bit dans la valeur d'appel.
+Le `NOT` est un opérateur au niveau du bit, donc il inverse la valeur de chaque bit dans la valeur d'appel.
 
-| Décalage | Opcode       | Pile                                                                            |
-| --------:| ------------ | ------------------------------------------------------------------------------- |
-|      1AC | DUP3         | Value\* 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE         |
-|      1AD | GT           | Value\*>2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE         |
+| Décalage | Opcode       | Base                                                                                                 |
+| -------: | ------------ | ---------------------------------------------------------------------------------------------------- |
+|      1AC | DUP3         | Value\* 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE                                  |
+|      1AD | GT           | Value\*>2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE                                  |
 |      1AE | ISZERO       | Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE        |
 |      1AF | PUSH2 0x01df | 0x01DF Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-|      1B2 | JUMPI        |                                                                                 |
+|      1B2 | JUMPI        |                                                                                                      |
 
-On saute si `Value*` est inférieure à 2^256-CALLVALUE-1 ou égale à celle-ci. Cela ressemble à une logique pour éviter les dépassements. Et en effet, nous voyons qu'après quelques opérations absurdes (écrire en mémoire est sur le point d'être supprimé, par exemple) au décalage 0x01DE, le contrat annule si le dépassement est détecté, ce qui est le comportement normal.
+On saute si `Value*` est plus petit ou égal à 2^256-CALLVALUE-1. Cela ressemble à une logique pour éviter les dépassements. Et en effet, nous voyons qu'après quelques opérations absurdes (par exemple, écrire dans la mémoire qui est sur le point d'être effacée), au décalage 0x01DE, le contrat est annulé si le dépassement est détecté, ce qui est un comportement normal.
 
-Notez qu'un tel dépassement est extrêmement improbable, parce qu'il nécessiterait une valeur d'appel et `Value*` d'être d'un ordre de grandeur de 2^256 wei, environ 10^59 ETH. [L'offre d'ETH total, au moment ou l'on écrit ceci, est inférieur à deux cents millions](https://etherscan.io/stat/supply).
+Notez qu'un tel dépassement est extrêmement improbable, car il faudrait que la valeur d'appel plus `Value*` soit comparable à 2^256 wei, soit environ 10^59 ETH. [L'offre totale d'ETH, au moment de la rédaction de cet article, est inférieure à deux cents millions](https://etherscan.io/stat/supply).
 
-| Décalage | Opcode   | Pile                                        |
-| --------:| -------- | ------------------------------------------- |
+| Décalage | Opcode   | Base                                      |
+| -------: | -------- | ----------------------------------------- |
 |      1DF | JUMPDEST | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
 |      1E0 | POP      | Value\* CALLVALUE 0x75 0 6 CALLVALUE      |
 |      1E1 | ADD      | Value\*+CALLVALUE 0x75 0 6 CALLVALUE      |
 |      1E2 | SWAP1    | 0x75 Value\*+CALLVALUE 0 6 CALLVALUE      |
-|      1E3 | JUMP     |                                             |
+|      1E3 | JUMP     |                                           |
 
-Si nous sommes arrivés ici, obtenons `Value* + CALLVALUE` et sautons au décalage 0x75.
+Si nous sommes arrivés ici, obtenez `Value* + CALLVALUE` et sautez au décalage 0x75.
 
-| Décalage | Opcode   | Pile                              |
-| --------:| -------- | --------------------------------- |
+| Décalage | Opcode   | Base                            |
+| -------: | -------- | ------------------------------- |
 |       75 | JUMPDEST | Value\*+CALLVALUE 0 6 CALLVALUE |
 |       76 | SWAP1    | 0 Value\*+CALLVALUE 6 CALLVALUE |
 |       77 | SWAP2    | 6 Value\*+CALLVALUE 0 CALLVALUE |
-|       78 | SSTORE   | 0 CALLVALUE                       |
+|       78 | SSTORE   | 0 CALLVALUE                     |
 
-Si nous arrivons ici (ce qui nécessite que les données d'appel soient vides), nous ajoutons à `Value*` la valeur d'appel. Ceci est cohérent avec ce que nous disons sur ce que les transactions `Transfer` font.
+Si nous arrivons ici (ce qui nécessite que les données d'appel soient vides), nous ajoutons à `Value*` la valeur d'appel. Ceci est cohérent avec ce que nous disons que les transactions de `Transfer` font.
 
 | Décalage | Opcode |
-| --------:| ------ |
+| -------: | ------ |
 |       79 | POP    |
 |       7A | POP    |
 |       7B | STOP   |
 
-Enfin, effacez la pile (qui n'est pas nécessaire) et signalez la fin réussie de la transaction.
+Enfin, videz la pile (ce qui n'est pas nécessaire) et signalez la fin réussie de la transaction.
 
-Pour tout résumer, voici un diagramme du code initial.
+Pour résumer, voici un organigramme du code initial.
 
-![Organigramme des points d'entrée](flowchart-entry.png)
+![Organigramme du point d'entrée](flowchart-entry.png)
 
 ## Le gestionnaire à 0x7C {#the-handler-at-0x7c}
 
-J'ai sciemment omis de mettre dans la rubrique ce que fait ce gestionnaire. Le but n'est pas de vous enseigner comment fonctionne ce contrat spécifique, mais comment rétro-concevoir les contrats. Vous apprendrez ce qu'il fait de la même manière que moi, en suivant le code.
+Je n'ai volontairement pas indiqué dans le titre ce que fait ce gestionnaire. L'objectif n'est pas de vous apprendre le fonctionnement de ce contrat spécifique, mais la manière de faire de l'ingénierie inverse sur des contrats. Vous apprendrez ce qu'il fait de la même manière que moi, en suivant le code.
 
-Nous arrivons ici de plusieurs façons :
+Nous arrivons ici depuis plusieurs endroits :
 
-- S'il y a des données d'appel de 1, 2 ou 3 octets (à partir du décalage 0x63)
-- Si la signature de la méthode est inconnue (à partir des décalages 0x42 et 0x5D)
+- S'il y a des données d'appel de 1, 2 ou 3 octets (depuis le décalage 0x63)
+- Si la signature de la méthode est inconnue (depuis les décalages 0x42 et 0x5D)
 
-| Décalage | Opcode       | Pile                 |
-| --------:| ------------ | -------------------- |
-|       7C | JUMPDEST     |                      |
-|       7D | PUSH1 0x00   | 0x00                 |
-|       7F | PUSH2 0x009d | 0x9D 0x00            |
-|       82 | PUSH1 0x03   | 0x03 0x9D 0x00       |
-|       84 | SLOAD        | Storage[3] 0x9D 0x00 |
+| Décalage | Opcode       | Base                                                                      |
+| -------: | ------------ | ------------------------------------------------------------------------- |
+|       7C | JUMPDEST     |                                                                           |
+|       7D | PUSH1 0x00   | 0x00                                                                      |
+|       7F | PUSH2 0x009d | 0x9D 0x00                                                                 |
+|       82 | PUSH1 0x03   | 0x03 0x9D 0x00                                                            |
+|       84 | SLOAD        | Stockage[3] 0x9D 0x00 |
 
-Il s'agit d'une autre cellule de stockage, une cellule que je n'ai pas trouvée dans aucune transaction, donc il est plus difficile de savoir ce que cela signifie. Le code ci-dessous clarifiera la question.
+C'est une autre cellule de stockage, que je n'ai pu trouver dans aucune transaction, il est donc plus difficile de savoir ce qu'elle signifie. Le code ci-dessous clarifiera cela.
 
-| Décalage | Opcode                                            | Pile                            |
-| --------:| ------------------------------------------------- | ------------------------------- |
-|       85 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xff....ff Storage[3] 0x9D 0x00 |
-|       9A | AND                                               | Storage[3]-as-address 0x9D 0x00 |
+| Décalage | Opcode                                            | Base                                                                                                                                                 |
+| -------: | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+|       85 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xff....ff Stockage[3] 0x9D 0x00 |
+|       9A | AND                                               | Stockage[3](en tant qu'adresse) 0x9D 0x00                                    |
 
-Ces codes d'opération tronquent la valeur que nous lisons de Stockage[3] à 160 bits, la longueur d'une adresse Ethereum.
+Ces opcodes tronquent la valeur que nous lisons de Stockage[3] à 160 bits, la longueur d'une adresse Ethereum.
 
-| Décalage | Opcode | Pile                            |
-| --------:| ------ | ------------------------------- |
-|       9B | SWAP1  | 0x9D Storage[3]-as-address 0x00 |
-|       9C | JUMP   | Storage[3]-as-address 0x00      |
+| Décalage | Opcode | Base                                                                                                              |
+| -------: | ------ | ----------------------------------------------------------------------------------------------------------------- |
+|       9B | SWAP1  | 0x9D Stockage[3](en tant qu'adresse) 0x00 |
+|       9C | JUMP   | Stockage[3](en tant qu'adresse) 0x00      |
 
-Ce saut est superflu puisque nous allons au prochain code d'opérations. Ce code n'est pas aussi efficace en gaz qu'il pourrait l'être.
+Ce saut est superflu, puisque nous allons à l'opcode suivant. Ce code n'est pas aussi économe en gaz qu'il pourrait l'être.
 
-| Décalage | Opcode     | Pile                            |
-| --------:| ---------- | ------------------------------- |
-|       9D | JUMPDEST   | Storage[3]-as-address 0x00      |
-|       9E | SWAP1      | 0x00 Storage[3]-as-address      |
-|       9F | POP        | Storage[3]-as-address           |
-|       A0 | PUSH1 0x40 | 0x40 Storage[3]-as-address      |
-|       A2 | MLOAD      | Mem[0x40] Storage[3]-as-address |
+| Décalage | Opcode     | Base                                                                                                                                                                  |
+| -------: | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|       9D | JUMPDEST   | Stockage[3](en tant qu'adresse) 0x00                                                          |
+|       9E | SWAP1      | 0x00 Stockage[3](en tant qu'adresse)                                                          |
+|       9F | POP        | Stockage[3](en tant qu'adresse)                                                               |
+|       A0 | PUSH1 0x40 | 0x40 Stockage[3](en tant qu'adresse)                                                          |
+|       A2 | MLOAD      | Mem[0x40] Stockage[3](en tant qu'adresse) |
 
-Au tout début du code, nous définissons Mem[0x40] à 0x80. Si nous cherchons 0x40 plus tard, nous voyons que nous ne le changeons pas - nous pouvons donc supposer qu'il est 0x80.
+Au tout début du code, nous avons défini Mem[0x40] sur 0x80. Si nous cherchons 0x40 plus tard, nous voyons que nous ne le changeons pas ; nous pouvons donc supposer qu'il s'agit de 0x80.
 
-| Décalage | Opcode       | Pile                                              |
-| --------:| ------------ | ------------------------------------------------- |
-|       A3 | CALLDATASIZE | CALLDATASIZE 0x80 Storage[3]-as-address           |
-|       A4 | PUSH1 0x00   | 0x00 CALLDATASIZE 0x80 Storage[3]-as-address      |
-|       A6 | DUP3         | 0x80 0x00 CALLDATASIZE 0x80 Storage[3]-as-address |
-|       A7 | CALLDATACOPY | 0x80 Storage[3]-as-address                        |
+| Décalage | Opcode       | Base                                                                                                                                |
+| -------: | ------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
+|       A3 | CALLDATASIZE | CALLDATASIZE 0x80 Stockage[3](en tant qu'adresse)           |
+|       A4 | PUSH1 0x00   | 0x00 CALLDATASIZE 0x80 Stockage[3](en tant qu'adresse)      |
+|       A6 | DUP3         | 0x80 0x00 CALLDATASIZE 0x80 Stockage[3](en tant qu'adresse) |
+|       A7 | CALLDATACOPY | 0x80 Stockage[3](en tant qu'adresse)                        |
 
 Copiez toutes les données d'appel en mémoire, à partir de 0x80.
 
-| Décalage | Opcode        | Pile                                                                             |
-| --------:| ------------- | -------------------------------------------------------------------------------- |
-|       A8 | PUSH1 0x00    | 0x00 0x80 Storage[3]-as-address                                                  |
-|       AA | DUP1          | 0x00 0x00 0x80 Storage[3]-as-address                                             |
-|       AB | CALLDATASIZE  | CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address                                |
-|       AC | DUP4          | 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address                           |
-|       AD | DUP6          | Storage[3]-as-address 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address     |
-|       AE | GAS           | GAS Storage[3]-as-address 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
-|       AF | DELEGATE_CALL |                                                                                  |
+| Décalage | Opcode                             | Base                                                                                                                                                                                                                                                 |
+| -------: | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|       A8 | PUSH1 0x00                         | 0x00 0x80 Stockage[3](en tant qu'adresse)                                                                                                                                    |
+|       AA | DUP1                               | 0x00 0x00 0x80 Stockage[3](en tant qu'adresse)                                                                                                                               |
+|       AB | CALLDATASIZE                       | CALLDATASIZE 0x00 0x00 0x80 Stockage[3](en tant qu'adresse)                                                                                                                  |
+|       AC | DUP4                               | 0x80 CALLDATASIZE 0x00 0x00 0x80 Stockage[3](en tant qu'adresse)                                                                                                             |
+|       AD | DUP6                               | Stockage[3](en tant qu'adresse) 0x80 CALLDATASIZE 0x00 0x00 0x80 Stockage[3](en tant qu'adresse)     |
+|       AE | GAS                                | GAS Stockage[3](en tant qu'adresse) 0x80 CALLDATASIZE 0x00 0x00 0x80 Stockage[3](en tant qu'adresse) |
+|       AF | DELEGATE_CALL |                                                                                                                                                                                                                                                      |
 
-Les choses sont maintenant beaucoup plus claires. Ce contrat peut agir comme un [proxy](https://blog.openzeppelin.com/proxy-patterns/), en appelant l'adresse dans Stockage[3] pour faire le travail réel. `DELEGATE_CALL` appelle un contrat séparé, mais reste dans le même stockage. Cela signifie que le contrat délégué, celui pour lequel nous sommes un proxy, accède au même espace de stockage. Les paramètres d'appel sont :
+Les choses sont maintenant beaucoup plus claires. Ce contrat peut agir comme un [proxy](https://blog.openzeppelin.com/proxy-patterns/), en appelant l'adresse dans Stockage[3] pour faire le vrai travail. `DELEGATE_CALL` appelle un contrat séparé, mais reste dans le même stockage. Cela signifie que le contrat délégué, celui pour lequel nous sommes un proxy, accède au même espace de stockage. Les paramètres de l'appel sont :
 
 - _Gaz_ : Tout le gaz restant
-- _Adresse appelée_ : Stockage[3] comme adresse
-- _Données d'appel_ : Les octets CALLDATASIZE commençant à 0x80, où nous avons mis les données d'appel d'origine
-- _Données de retour_ : Aucune (0x00 - 0x00), nous allons obtenir les données de retour par d'autres moyens (voir ci-dessous)
-
-| Décalage | Opcode         | Pile                                                                                          |
-| --------:| -------------- | --------------------------------------------------------------------------------------------- |
-|       B0 | RETURNDATASIZE | RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address                          |
-|       B1 | DUP1           | RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address           |
-|       B2 | PUSH1 0x00     | 0x00 RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address      |
-|       B4 | DUP5           | 0x80 0x00 RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-|       B5 | RETURNDATACOPY | RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address                          |
-
-Ici, nous copions toutes les données retournées dans le tampon de mémoire à partir de 0x80.
-
-| Décalage | Opcode       | Pile                                                                                                                         |
-| --------:| ------------ | ---------------------------------------------------------------------------------------------------------------------------- |
-|       B6 | DUP2         | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address                              |
-|       B7 | DUP1         | (((call success/failure))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address   |
-|       B8 | ISZERO       | (((did the call fail))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address      |
-|       B9 | PUSH2 0x00c0 | 0xC0 (((did the call fail))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-|       BC | JUMPI        | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address                              |
-|       BD | DUP2         | RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address               |
-|       BE | DUP5         | 0x80 RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address          |
-|       BF | RETOUR       |                                                                                                                              |
-
-Donc, après l'appel, nous copions les données retournées dans le tampon 0x80 - 0x80+RETURNDATASIZE, et si l'appel réussit, nous retournons `RETURN` avec exactement ce tampon.
+- _Adresse appelée_ : Stockage[3](en tant qu'adresse)
+- _Données d'appel_ : Les octets CALLDATASIZE commençant à 0x80, là où nous avons mis les données d'appel d'origine
+- _Données de retour_ : Aucune (0x00 - 0x00). Nous obtiendrons les données de retour par d'autres moyens (voir ci-dessous).
+
+| Décalage | Opcode         | Base                                                                                                                                                                                                                                        |
+| -------: | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|       B0 | RETURNDATASIZE | RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                          |
+|       B1 | DUP1           | RETURNDATASIZE RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)           |
+|       B2 | PUSH1 0x00     | 0x00 RETURNDATASIZE RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)      |
+|       B4 | DUP5           | 0x80 0x00 RETURNDATASIZE RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse) |
+|       B5 | RETURNDATACOPY | RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                          |
+
+Ici, nous copions toutes les données de retour dans le tampon mémoire à partir de 0x80.
+
+| Décalage | Opcode       | Base                                                                                                                                                                                                                                                                                                                                                                                                |
+| -------: | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|       B6 | DUP2         | (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                                                                                           |
+|       B7 | DUP1         | (((succès/échec de l'appel))) (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)    |
+|       B8 | ISZERO       | (((l'appel a-t-il échoué))) (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)      |
+|       B9 | PUSH2 0x00c0 | 0xC0 (((l'appel a-t-il échoué))) (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse) |
+|       BC | JUMPI        | (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                                                                                           |
+|       BD | DUP2         | RETURNDATASIZE (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                                                                            |
+|       BE | DUP5         | 0x80 RETURNDATASIZE (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                                                                       |
+|       BF | RETOUR       |                                                                                                                                                                                                                                                                                                                                                                                                     |
+
+Ainsi, après l'appel, nous copions les données de retour dans le tampon 0x80 - 0x80+RETURNDATASIZE, et si l'appel réussit, nous exécutons `RETURN` avec exactement ce tampon.
 
 ### Échec de DELEGATECALL {#delegatecall-failed}
 
-Si nous arrivons ici, à 0xC0, cela signifie que le contrat que nous avons appelé a annulé son exécution. Étant donné que nous ne sommes qu'un proxy pour ce contrat, nous voulons retourner les mêmes données et annuler également.
+Si nous arrivons ici, à 0xC0, cela signifie que le contrat que nous avons appelé a été annulé. Comme nous ne sommes qu'un proxy pour ce contrat, nous voulons retourner les mêmes données et également annuler.
 
-| Décalage | Opcode   | Pile                                                                                                                |
-| --------:| -------- | ------------------------------------------------------------------------------------------------------------------- |
-|       C0 | JUMPDEST | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address                     |
-|       C1 | DUP2     | RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address      |
-|       C2 | DUP5     | 0x80 RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-|       C3 | REVERT   |                                                                                                                     |
+| Décalage | Opcode   | Base                                                                                                                                                                                                                                                                                                                          |
+| -------: | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|       C0 | JUMPDEST | (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)                     |
+|       C1 | DUP2     | RETURNDATASIZE (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse)      |
+|       C2 | DUP5     | 0x80 RETURNDATASIZE (((succès/échec de l'appel))) RETURNDATASIZE (((succès/échec de l'appel))) 0x80 Stockage[3](en tant qu'adresse) |
+|       C3 | REVERT   |                                                                                                                                                                                                                                                                                                                               |
 
-Donc nous annulons `REVERT` avec le même tampon que nous avons utilisé pour `RETURN` précédemment : 0x80 - 0x80+RETURNDATASIZE
+Nous exécutons donc `REVERT` avec le même tampon que nous avons utilisé pour `RETURN` précédemment : 0x80 - 0x80+RETURNDATASIZE
 
-![Organigramme de l'appel de proxy](flowchart-proxy.png)
+![Organigramme de l'appel au proxy](flowchart-proxy.png)
 
 ## Appels ABI {#abi-calls}
 
-Si la taille des données de l'appel est de quatre octets ou plus, il peut s'agir d'un appel ABI valide.
+Si la taille des données d'appel est de quatre octets ou plus, il peut s'agir d'un appel ABI valide.
 
-| Décalage | Opcode       | Pile                                              |
-| --------:| ------------ | ------------------------------------------------- |
-|        D | PUSH1 0x00   | 0x00                                              |
-|        F | CALLDATALOAD | (((First word (256 bits) of the call data)))      |
-|       10 | PUSH1 0xe0   | 0xE0 (((First word (256 bits) of the call data))) |
-|       12 | SHR          | (((first 32 bits (4 bytes) of the call data)))    |
+| Décalage | Opcode       | Base                                                                                                                              |
+| -------: | ------------ | --------------------------------------------------------------------------------------------------------------------------------- |
+|        D | PUSH1 0x00   | 0x00                                                                                                                              |
+|        F | CALLDATALOAD | (((Premier mot (256 bits) des données d'appel)))      |
+|       10 | PUSH1 0xe0   | 0xE0 (((Premier mot (256 bits) des données d'appel))) |
+|       12 | SHR          | (((premiers 32 bits (4 octets) des données d'appel))) |
 
-Etherscan nous dit que `1C` est un code d'opération inconnu, parce qu'[il a été ajouté après que Etherscan ait écrit cette fonctionnalité](https://eips.ethereum.org/EIPS/eip-145) et qu'ils ne l'ont pas mise à jour. Un [tableau d'opcode à jour](https://github.com/wolflo/evm-opcodes) nous montre que c'est un décalage à droite
+Etherscan nous dit que `1C` est un opcode inconnu, car [il a été ajouté après qu'Etherscan ait écrit cette fonctionnalité](https://eips.ethereum.org/EIPS/eip-145) et ils ne l'ont pas mis à jour. Une [table d'opcodes à jour](https://github.com/wolflo/evm-opcodes) nous montre qu'il s'agit d'un décalage à droite
 
-| Décalage | Opcode           | Pile                                                                                                     |
-| --------:| ---------------- | -------------------------------------------------------------------------------------------------------- |
-|       13 | DUP1             | (((first 32 bits (4 bytes) of the call data))) (((first 32 bits (4 bytes) of the call data)))            |
-|       14 | PUSH4 0x3cd8045e | 0x3CD8045E (((first 32 bits (4 bytes) of the call data))) (((first 32 bits (4 bytes) of the call data))) |
-|       19 | GT               | 0x3CD8045E>first-32-bits-of-the-call-data (((first 32 bits (4 bytes) of the call data)))                 |
-|       1A | PUSH2 0x0043     | 0x43 0x3CD8045E>first-32-bits-of-the-call-data (((first 32 bits (4 bytes) of the call data)))            |
-|       1D | JUMPI            | (((first 32 bits (4 bytes) of the call data)))                                                           |
+| Décalage | Opcode           | Base                                                                                                                                                                                                                                                                           |
+| -------: | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+|       13 | DUP1             | (((premiers 32 bits (4 octets) des données d'appel))) (((premiers 32 bits (4 octets) des données d'appel)))            |
+|       14 | PUSH4 0x3cd8045e | 0x3CD8045E (((premiers 32 bits (4 octets) des données d'appel))) (((premiers 32 bits (4 octets) des données d'appel))) |
+|       19 | GT               | 0x3CD8045E > premiers 32 bits des données d'appel (((premiers 32 bits (4 octets) des données d'appel)))                                                                                            |
+|       1A | PUSH2 0x0043     | 0x43 0x3CD8045E > premiers 32 bits des données d'appel (((premiers 32 bits (4 octets) des données d'appel)))                                                                                       |
+|       1D | JUMPI            | (((premiers 32 bits (4 octets) des données d'appel)))                                                                                                                                              |
 
-Diviser les tests de correspondance de la signature de la méthode en deux comme cela réduit les tests de moitié en moyenne. Le code qui suit immédiatement cela et le code en 0x43 suivent le même modèle : `DUP1` les 32 premiers bits des données d'appel, `PUSH4 (((méthode signature>`, exécutez `EQ` pour vérifier l'égalité, puis `JUMPI` si la signature de la méthode correspond. Voici les signatures de la méthode, leurs adresses, et si elles sont connues [la définition de méthode correspondante](https://www.4byte.directory/) :
+Diviser ainsi les tests de correspondance de signature de méthode en deux permet de réduire de moitié le nombre moyen de tests. Le code qui suit immédiatement et le code en 0x43 suivent le même modèle : `DUP1` les 32 premiers bits des données d'appel, `PUSH4 (((signature de méthode>`, exécutez `EQ` pour vérifier l'égalité, puis `JUMPI` si la signature de méthode correspond. Voici les signatures de méthode, leurs adresses et, si elle est connue, [la définition de méthode correspondante](https://www.4byte.directory/) :
 
-| Méthode                                                                                | Signature de la méthode | Décalage vers lequel sauter |
-| -------------------------------------------------------------------------------------- | ----------------------- | --------------------------- |
-| [splitter()](https://www.4byte.directory/signatures/?bytes4_signature=0x3cd8045e)      | 0x3cd8045e              | 0x0103                      |
-| ???                                                                                    | 0x81e580d3              | 0x0138                      |
-| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4) | 0xba0bafb4              | 0x0158                      |
-| ???                                                                                    | 0x1f135823              | 0x00C4                      |
-| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab)    | 0x2eb4a7ab              | 0x00ED                      |
+| Méthode                                                                                                   | Signature de la méthode | Décalage de destination du saut |
+| --------------------------------------------------------------------------------------------------------- | ----------------------- | ------------------------------- |
+| [splitter()](https://www.4byte.directory/signatures/?bytes4_signature=0x3cd8045e)      | 0x3cd8045e              | 0x0103                          |
+| ???                                                                                                       | 0x81e580d3              | 0x0138                          |
+| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4) | 0xba0bafb4              | 0x0158                          |
+| ???                                                                                                       | 0x1f135823              | 0x00C4                          |
+| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab)    | 0x2eb4a7ab              | 0x00ED                          |
 
-Si aucune correspondance n'est trouvée, le code saute vers [le gestionnaire de proxy à 0x7C](#the-handler-at-0x7c), dans l'espoir que le contrat pour lequel nous sommes proxy ait une correspondance.
+Si aucune correspondance n'est trouvée, le code saute vers [le gestionnaire de proxy à 0x7C](#the-handler-at-0x7c), dans l'espoir que le contrat pour lequel nous sommes un proxy ait une correspondance.
 
 ![Organigramme des appels ABI](flowchart-abi.png)
 
 ## splitter() {#splitter}
 
-| Décalage | Opcode       | Pile                          |
-| --------:| ------------ | ----------------------------- |
+| Décalage | Opcode       | Base                          |
+| -------: | ------------ | ----------------------------- |
 |      103 | JUMPDEST     |                               |
 |      104 | CALLVALUE    | CALLVALUE                     |
 |      105 | DUP1         | CALLVALUE CALLVALUE           |
@@ -314,27 +312,27 @@ Si aucune correspondance n'est trouvée, le code saute vers [le gestionnaire de
 |      10D | DUP1         | 0x00 0x00 CALLVALUE           |
 |      10E | REVERT       |                               |
 
-La première chose que fait cette fonction est de vérifier que l'appel n'a pas envoyé d'ETH. Cette fonction n'est pas [`payable`](https://solidity-by-example.org/payable/). Si quelqu'un nous a envoyé des ETH, cela doit être une erreur et nous voulons `REVERT` pour éviter d'avoir cet ETH où il ne peut le récupérer.
-
-| Décalage | Opcode                                            | Pile                                                                        |
-| --------:| ------------------------------------------------- | --------------------------------------------------------------------------- |
-|      10F | JUMPDEST                                          |                                                                             |
-|      110 | POP                                               |                                                                             |
-|      111 | PUSH1 0x03                                        | 0x03                                                                        |
-|      113 | SLOAD                                             | (((Storage[3] a.k.a the contract for which we are a proxy)))                |
-|      114 | PUSH1 0x40                                        | 0x40 (((Storage[3] a.k.a the contract for which we are a proxy)))           |
-|      116 | MLOAD                                             | 0x80 (((Storage[3] a.k.a the contract for which we are a proxy)))           |
-|      117 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xFF...FF 0x80 (((Storage[3] a.k.a the contract for which we are a proxy))) |
-|      12C | SWAP1                                             | 0x80 0xFF...FF (((Storage[3] a.k.a the contract for which we are a proxy))) |
-|      12D | SWAP2                                             | (((Storage[3] a.k.a the contract for which we are a proxy))) 0xFF...FF 0x80 |
-|      12E | AND                                               | ProxyAddr 0x80                                                              |
-|      12F | DUP2                                              | 0x80 ProxyAddr 0x80                                                         |
-|      130 | MSTORE                                            | 0x80                                                                        |
+La première chose que fait cette fonction est de vérifier que l'appel n'a envoyé aucun ETH. Cette fonction n'est pas [`payable`](https://solidity-by-example.org/payable/). Si quelqu'un nous a envoyé des ETH, cela doit être une erreur et nous voulons exécuter `REVERT` pour éviter que ces ETH ne soient bloqués là où ils ne peuvent pas être récupérés.
+
+| Décalage | Opcode                                            | Base                                                                                                                                                                                                                                            |
+| -------: | ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|      10F | JUMPDEST                                          |                                                                                                                                                                                                                                                 |
+|      110 | POP                                               |                                                                                                                                                                                                                                                 |
+|      111 | PUSH1 0x03                                        | 0x03                                                                                                                                                                                                                                            |
+|      113 | SLOAD                                             | (((Stockage[3] alias le contrat pour lequel nous sommes un proxy)))                                                                |
+|      114 | PUSH1 0x40                                        | 0x40 (((Stockage[3] alias le contrat pour lequel nous sommes un proxy)))                                                           |
+|      116 | MLOAD                                             | 0x80 (((Stockage[3] alias le contrat pour lequel nous sommes un proxy)))                                                           |
+|      117 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xFF...FF 0x80 (((Stockage[3] alias le contrat pour lequel nous sommes un proxy))) |
+|      12C | SWAP1                                             | 0x80 0xFF...FF (((Stockage[3] alias le contrat pour lequel nous sommes un proxy))) |
+|      12D | SWAP2                                             | (((Stockage[3] alias le contrat pour lequel nous sommes un proxy))) 0xFF...FF 0x80 |
+|      12E | AND                                               | ProxyAddr 0x80                                                                                                                                                                                                                                  |
+|      12F | DUP2                                              | 0x80 ProxyAddr 0x80                                                                                                                                                                                                                             |
+|      130 | MSTORE                                            | 0x80                                                                                                                                                                                                                                            |
 
 Et 0x80 contient maintenant l'adresse du proxy
 
-| Décalage | Opcode       | Pile      |
-| --------:| ------------ | --------- |
+| Décalage | Opcode       | Base      |
+| -------: | ------------ | --------- |
 |      131 | PUSH1 0x20   | 0x20 0x80 |
 |      133 | ADD          | 0xA0      |
 |      134 | PUSH2 0x00e4 | 0xE4 0xA0 |
@@ -342,10 +340,10 @@ Et 0x80 contient maintenant l'adresse du proxy
 
 ### Le code E4 {#the-e4-code}
 
-C'est la première fois que nous voyons ces lignes, mais elles sont partagées avec d'autres méthodes (voir ci-dessous). Nous allons donc appeler la valeur dans la pile X, et n'oubliez pas que dans la fonction `splitter()` la valeur de ce X est 0xA0.
+C'est la première fois que nous voyons ces lignes, mais elles sont partagées avec d'autres méthodes (voir ci-dessous). Nous appellerons donc la valeur dans la pile X, et nous nous souviendrons simplement que dans `splitter()`, la valeur de ce X est 0xA0.
 
-| Décalage | Opcode     | Pile        |
-| --------:| ---------- | ----------- |
+| Décalage | Opcode     | Base        |
+| -------: | ---------- | ----------- |
 |       E4 | JUMPDEST   | X           |
 |       E5 | PUSH1 0x40 | 0x40 X      |
 |       E7 | MLOAD      | 0x80 X      |
@@ -355,30 +353,30 @@ C'est la première fois que nous voyons ces lignes, mais elles sont partagées a
 |       EB | SWAP1      | 0x80 X-0x80 |
 |       EC | RETOUR     |             |
 
-Ce code reçoit un pointeur de mémoire dans la pile (X), et entraîne le contrat à `RETURN` avec un tampon qui est 0x80 - X.
+Ce code reçoit donc un pointeur de mémoire dans la pile (X) et fait en sorte que le contrat exécute `RETURN` avec un tampon qui est 0x80 - X.
 
-Dans le cas de `splitter()`, ceci retourne l'adresse pour laquelle nous sommes un proxy. `RETURN` retourne le tampon en 0x80-0x9F, où nous avons écrit ces données (décalage 0x130 ci-dessus).
+Dans le cas de `splitter()`, ceci retourne l'adresse pour laquelle nous sommes un proxy. `RETURN` renvoie le tampon dans 0x80-0x9F, où nous avons écrit ces données (décalage 0x130 ci-dessus).
 
 ## currentWindow() {#currentwindow}
 
-Le code aux décalages 0x158-0x163 est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que `currentWindow()` n'est pas `payable` non plus.
+Le code aux décalages 0x158-0x163 est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que `currentWindow()` n'est pas non plus `payable`.
 
-| Décalage | Opcode       | Pile                 |
-| --------:| ------------ | -------------------- |
-|      164 | JUMPDEST     |                      |
-|      165 | POP          |                      |
-|      166 | PUSH2 0x00da | 0xDA                 |
-|      169 | PUSH1 0x01   | 0x01 0xDA            |
-|      16B | SLOAD        | Storage[1] 0xDA      |
-|      16C | DUP2         | 0xDA Storage[1] 0xDA |
-|      16D | JUMP         | Storage[1] 0xDA      |
+| Décalage | Opcode       | Base                                                                      |
+| -------: | ------------ | ------------------------------------------------------------------------- |
+|      164 | JUMPDEST     |                                                                           |
+|      165 | POP          |                                                                           |
+|      166 | PUSH2 0x00da | 0xDA                                                                      |
+|      169 | PUSH1 0x01   | 0x01 0xDA                                                                 |
+|      16B | SLOAD        | Stockage[1] 0xDA      |
+|      16C | DUP2         | 0xDA Stockage[1] 0xDA |
+|      16D | JUMP         | Stockage[1] 0xDA      |
 
 ### Le code DA {#the-da-code}
 
-Ce code est aussi partagé avec d'autres méthodes. Nous allons donc appeler la valeur dans la pile Y, et n'oubliez pas que dans la fonction `currentWindow()` la valeur de ce Y est Stockage[1].
+Ce code est aussi partagé avec d'autres méthodes. Nous allons donc appeler la valeur dans la pile Y, et nous souvenir que dans `currentWindow()` la valeur de ce Y est Stockage[1].
 
-| Décalage | Opcode     | Pile             |
-| --------:| ---------- | ---------------- |
+| Décalage | Opcode     | Base             |
+| -------: | ---------- | ---------------- |
 |       DA | JUMPDEST   | Y 0xDA           |
 |       DB | PUSH1 0x40 | 0x40 Y 0xDA      |
 |       DD | MLOAD      | 0x80 Y 0xDA      |
@@ -388,201 +386,203 @@ Ce code est aussi partagé avec d'autres méthodes. Nous allons donc appeler la
 
 Écrire Y à 0x80-0x9F.
 
-| Décalage | Opcode     | Pile           |
-| --------:| ---------- | -------------- |
+| Décalage | Opcode     | Base           |
+| -------: | ---------- | -------------- |
 |       E1 | PUSH1 0x20 | 0x20 0x80 0xDA |
 |       E3 | ADD        | 0xA0 0xDA      |
 
-Et le reste est déjà expliqué [au-dessus](#the-e4-code). Donc les sauts à 0xDA écrivent la pile supérieure (Y) à 0x80-0x9F, et retournent cette valeur. Dans le cas de `currentWindow()`, il retourne Stockage[1].
+Et le reste est déjà expliqué [ci-dessus](#the-e4-code). Les sauts vers 0xDA écrivent donc la valeur supérieure de la pile (Y) à 0x80-0x9F, et renvoient cette valeur. Dans le cas de `currentWindow()`, il retourne Stockage[1].
 
 ## merkleRoot() {#merkleroot}
 
-Le code aux décalages 0xED-0xF8 est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que `merkleRoot()` n'est pas `payable` non plus.
+Le code aux décalages 0xED-0xF8 est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que `merkleRoot()` n'est pas non plus `payable`.
 
-| Décalage | Opcode       | Pile                 |
-| --------:| ------------ | -------------------- |
-|       F9 | JUMPDEST     |                      |
-|       FA | POP          |                      |
-|       FB | PUSH2 0x00da | 0xDA                 |
-|       FE | PUSH1 0x00   | 0x00 0xDA            |
-|      100 | SLOAD        | Storage[0] 0xDA      |
-|      101 | DUP2         | 0xDA Storage[0] 0xDA |
-|      102 | JUMP         | Storage[0] 0xDA      |
+| Décalage | Opcode       | Base                                                                      |
+| -------: | ------------ | ------------------------------------------------------------------------- |
+|       F9 | JUMPDEST     |                                                                           |
+|       FA | POP          |                                                                           |
+|       FB | PUSH2 0x00da | 0xDA                                                                      |
+|       FE | PUSH1 0x00   | 0x00 0xDA                                                                 |
+|      100 | SLOAD        | Stockage[0] 0xDA      |
+|      101 | DUP2         | 0xDA Stockage[0] 0xDA |
+|      102 | JUMP         | Stockage[0] 0xDA      |
 
-[Nous avons déjà compris](#the-da-code) ce qu'il se passe après le saut. Donc `merkleRoot()` retourne Stockage[0].
+Nous avons déjà compris ce qu'il se passe après le saut ([voir plus haut](#the-da-code)). Donc `merkleRoot()` retourne Stockage[0].
 
 ## 0x81e580d3 {#0x81e580d3}
 
-Le code aux décalages 0x138-0x143 est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que cette fonction n'est pas `payable` non plus.
-
-| Décalage | Opcode       | Pile                                                         |
-| --------:| ------------ | ------------------------------------------------------------ |
-|      144 | JUMPDEST     |                                                              |
-|      145 | POP          |                                                              |
-|      146 | PUSH2 0x00da | 0xDA                                                         |
-|      149 | PUSH2 0x0153 | 0x0153 0xDA                                                  |
-|      14C | CALLDATASIZE | CALLDATASIZE 0x0153 0xDA                                     |
-|      14D | PUSH1 0x04   | 0x04 CALLDATASIZE 0x0153 0xDA                                |
-|      14F | PUSH2 0x018f | 0x018F 0x04 CALLDATASIZE 0x0153 0xDA                         |
-|      152 | JUMP         | 0x04 CALLDATASIZE 0x0153 0xDA                                |
-|      18F | JUMPDEST     | 0x04 CALLDATASIZE 0x0153 0xDA                                |
-|      190 | PUSH1 0x00   | 0x00 0x04 CALLDATASIZE 0x0153 0xDA                           |
-|      192 | PUSH1 0x20   | 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA                      |
-|      194 | DUP3         | 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA                 |
-|      195 | DUP5         | CALLDATASIZE 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA    |
-|      196 | SUB          | CALLDATASIZE-4 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA       |
-|      197 | SLT          | CALLDATASIZE-4\<32 0x00 0x04 CALLDATASIZE 0x0153 0xDA         |
-|      198 | ISZERO       | CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA        |
-|      199 | PUSH2 0x01a0 | 0x01A0 CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-|      19C | JUMPI        | 0x00 0x04 CALLDATASIZE 0x0153 0xDA                           |
+Le code aux décalages 0x138-0x143 est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que cette fonction n'est pas non plus `payable`.
+
+| Décalage | Opcode       | Base                                                                          |
+| -------: | ------------ | ----------------------------------------------------------------------------- |
+|      144 | JUMPDEST     |                                                                               |
+|      145 | POP          |                                                                               |
+|      146 | PUSH2 0x00da | 0xDA                                                                          |
+|      149 | PUSH2 0x0153 | 0x0153 0xDA                                                                   |
+|      14C | CALLDATASIZE | CALLDATASIZE 0x0153 0xDA                                                      |
+|      14D | PUSH1 0x04   | 0x04 CALLDATASIZE 0x0153 0xDA                                                 |
+|      14F | PUSH2 0x018f | 0x018F 0x04 CALLDATASIZE 0x0153 0xDA                                          |
+|      152 | JUMP         | 0x04 CALLDATASIZE 0x0153 0xDA                                                 |
+|      18F | JUMPDEST     | 0x04 CALLDATASIZE 0x0153 0xDA                                                 |
+|      190 | PUSH1 0x00   | 0x00 0x04 CALLDATASIZE 0x0153 0xDA                                            |
+|      192 | PUSH1 0x20   | 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA                                       |
+|      194 | DUP3         | 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA                                  |
+|      195 | DUP5         | CALLDATASIZE 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA                     |
+|      196 | SUB          | CALLDATASIZE-4 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA                        |
+|      197 | SLT          | CALLDATASIZE-4&lt;32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+|      198 | ISZERO       | CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA                         |
+|      199 | PUSH2 0x01a0 | 0x01A0 CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA                  |
+|      19C | JUMPI        | 0x00 0x04 CALLDATASIZE 0x0153 0xDA                                            |
 
 Il semblerait que cette fonction prenne au moins 32 octets (un mot) de données d'appel.
 
-| Décalage | Opcode | Pile                                         |
-| --------:| ------ | -------------------------------------------- |
+| Décalage | Opcode | Base                                         |
+| -------: | ------ | -------------------------------------------- |
 |      19D | DUP1   | 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA      |
 |      19E | DUP2   | 0x00 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
 |      19F | REVERT |                                              |
 
-Si elle ne récupère pas les données d'appel, la transaction est annulée sans aucune donnée retournée.
+Si elle n'obtient pas les données d'appel, la transaction est annulée sans aucune donnée de retour.
 
 Voyons ce qui se passe si la fonction _obtient_ les données d'appel dont elle a besoin.
 
-| Décalage | Opcode       | Pile                                     |
-| --------:| ------------ | ---------------------------------------- |
-|      1A0 | JUMPDEST     | 0x00 0x04 CALLDATASIZE 0x0153 0xDA       |
-|      1A1 | POP          | 0x04 CALLDATASIZE 0x0153 0xDA            |
+| Décalage | Opcode       | Base                                                        |
+| -------: | ------------ | ----------------------------------------------------------- |
+|      1A0 | JUMPDEST     | 0x00 0x04 CALLDATASIZE 0x0153 0xDA                          |
+|      1A1 | POP          | 0x04 CALLDATASIZE 0x0153 0xDA                               |
 |      1A2 | CALLDATALOAD | calldataload(4) CALLDATASIZE 0x0153 0xDA |
 
 `calldataload(4)` est le premier mot des données d'appel _après_ la signature de la méthode
 
-| Décalage | Opcode       | Pile                                                                         |
-| --------:| ------------ | ---------------------------------------------------------------------------- |
-|      1A3 | SWAP2        | 0x0153 CALLDATASIZE calldataload(4) 0xDA                                     |
-|      1A4 | SWAP1        | CALLDATASIZE 0x0153 calldataload(4) 0xDA                                     |
-|      1A5 | POP          | 0x0153 calldataload(4) 0xDA                                                  |
-|      1A6 | JUMP         | calldataload(4) 0xDA                                                         |
-|      153 | JUMPDEST     | calldataload(4) 0xDA                                                         |
-|      154 | PUSH2 0x016e | 0x016E calldataload(4) 0xDA                                                  |
-|      157 | JUMP         | calldataload(4) 0xDA                                                         |
-|      16E | JUMPDEST     | calldataload(4) 0xDA                                                         |
-|      16F | PUSH1 0x04   | 0x04 calldataload(4) 0xDA                                                    |
-|      171 | DUP2         | calldataload(4) 0x04 calldataload(4) 0xDA                                    |
-|      172 | DUP2         | 0x04 calldataload(4) 0x04 calldataload(4) 0xDA                               |
-|      173 | SLOAD        | Storage[4] calldataload(4) 0x04 calldataload(4) 0xDA                         |
-|      174 | DUP2         | calldataload(4) Storage[4] calldataload(4) 0x04 calldataload(4) 0xDA         |
-|      175 | LT           | calldataload(4)\<Storage[4] calldataload(4) 0x04 calldataload(4) 0xDA         |
-|      176 | PUSH2 0x017e | 0x017EC calldataload(4)\<Storage[4] calldataload(4) 0x04 calldataload(4) 0xDA |
-|      179 | JUMPI        | calldataload(4) 0x04 calldataload(4) 0xDA                                    |
-
-Si le premier mot n'est pas inférieur à Stockage[4], la fonction échoue. Elle s'annule sans valeur retournée :
-
-| Décalage | Opcode     | Pile          |
-| --------:| ---------- | ------------- |
+| Décalage | Opcode       | Base                                                                                                                                                                                                                |
+| -------: | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|      1A3 | SWAP2        | 0x0153 CALLDATASIZE calldataload(4) 0xDA                                                                                                                                                         |
+|      1A4 | SWAP1        | CALLDATASIZE 0x0153 calldataload(4) 0xDA                                                                                                                                                         |
+|      1A5 | POP          | 0x0153 calldataload(4) 0xDA                                                                                                                                                                      |
+|      1A6 | JUMP         | calldataload(4) 0xDA                                                                                                                                                                             |
+|      153 | JUMPDEST     | calldataload(4) 0xDA                                                                                                                                                                             |
+|      154 | PUSH2 0x016e | 0x016E calldataload(4) 0xDA                                                                                                                                                                      |
+|      157 | JUMP         | calldataload(4) 0xDA                                                                                                                                                                             |
+|      16E | JUMPDEST     | calldataload(4) 0xDA                                                                                                                                                                             |
+|      16F | PUSH1 0x04   | 0x04 calldataload(4) 0xDA                                                                                                                                                                        |
+|      171 | DUP2         | calldataload(4) 0x04 calldataload(4) 0xDA                                                                                                                                     |
+|      172 | DUP2         | 0x04 calldataload(4) 0x04 calldataload(4) 0xDA                                                                                                                                |
+|      173 | SLOAD        | Stockage[4] calldataload(4) 0x04 calldataload(4) 0xDA                                                                     |
+|      174 | DUP2         | calldataload(4) Stockage[4] calldataload(4) 0x04 calldataload(4) 0xDA                                  |
+|      175 | LT           | calldataload(4)\<Stockage[4] calldataload(4) 0x04 calldataload(4) 0xDA         |
+|      176 | PUSH2 0x017e | 0x017EC calldataload(4)\<Stockage[4] calldataload(4) 0x04 calldataload(4) 0xDA |
+|      179 | JUMPI        | calldataload(4) 0x04 calldataload(4) 0xDA                                                                                                                                     |
+
+Si le premier mot n'est pas inférieur à Stockage[4], la fonction échoue. Elle annule sans valeur retournée :
+
+| Décalage | Opcode     | Base                                                          |
+| -------: | ---------- | ------------------------------------------------------------- |
 |      17A | PUSH1 0x00 | 0x00 ...      |
 |      17C | DUP1       | 0x00 0x00 ... |
-|      17D | REVERT     |               |
+|      17D | REVERT     |                                                               |
 
-Si le calldataload(4) est inférieur au Stockage[4], nous obtenons ce code :
+Si le calldataload(4) est inférieur à Stockage[4], nous obtenons ce code :
 
-| Décalage | Opcode     | Pile                                                |
-| --------:| ---------- | --------------------------------------------------- |
+| Décalage | Opcode     | Base                                                                                      |
+| -------: | ---------- | ----------------------------------------------------------------------------------------- |
 |      17E | JUMPDEST   | calldataload(4) 0x04 calldataload(4) 0xDA           |
 |      17F | PUSH1 0x00 | 0x00 calldataload(4) 0x04 calldataload(4) 0xDA      |
 |      181 | SWAP2      | 0x04 calldataload(4) 0x00 calldataload(4) 0xDA      |
 |      182 | DUP3       | 0x00 0x04 calldataload(4) 0x00 calldataload(4) 0xDA |
 |      183 | MSTORE     | calldataload(4) 0x00 calldataload(4) 0xDA           |
 
-Et les emplacements mémoire 0x00-0x1F contiennent maintenant les données 0x04 (0x00-0x1E sont tous des zéros, 0x1F est quatre)
+Et les emplacements mémoire 0x00-0x1F contiennent maintenant les données 0x04 (0x00-0x1E sont tous des zéros, 0x1F est quatre).
 
-| Décalage | Opcode     | Pile                                                                    |
-| --------:| ---------- | ----------------------------------------------------------------------- |
-|      184 | PUSH1 0x20 | 0x20 calldataload(4) 0x00 calldataload(4) 0xDA                          |
-|      186 | SWAP1      | calldataload(4) 0x20 0x00 calldataload(4) 0xDA                          |
-|      187 | SWAP2      | 0x00 0x20 calldataload(4) calldataload(4) 0xDA                          |
-|      188 | SHA3       | (((SHA3 of 0x00-0x1F))) calldataload(4) calldataload(4) 0xDA            |
-|      189 | ADD        | (((SHA3 of 0x00-0x1F)))+calldataload(4) calldataload(4) 0xDA            |
-|      18A | SLOAD      | Storage[(((SHA3 of 0x00-0x1F))) + calldataload(4)] calldataload(4) 0xDA |
+| Décalage | Opcode     | Base                                                                                                                                                                                                                        |
+| -------: | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|      184 | PUSH1 0x20 | 0x20 calldataload(4) 0x00 calldataload(4) 0xDA                                                                                                                                        |
+|      186 | SWAP1      | calldataload(4) 0x20 0x00 calldataload(4) 0xDA                                                                                                                                        |
+|      187 | SWAP2      | 0x00 0x20 calldataload(4) calldataload(4) 0xDA                                                                                                                                        |
+|      188 | SHA3       | (((SHA3 de 0x00-0x1F))) calldataload(4) calldataload(4) 0xDA                                                                 |
+|      189 | ADD        | (((SHA3 de 0x00-0x1F)))+calldataload(4) calldataload(4) 0xDA                                                                 |
+|      18A | SLOAD      | Stockage[(((SHA3 de 0x00-0x1F))) + calldataload(4)] calldataload(4) 0xDA |
 
-Il y a une table de recherche dans le stockage, qui commence à SHA3 de 0x000... 004 et a une entrée pour chaque valeur légitime de données d'appel (valeur au-dessous de Stockage[4]).
+Il y a donc une table de recherche dans le stockage, qui commence à SHA3 de 0x000...0004 et a une entrée pour chaque valeur de données d'appel légitime (valeur inférieure à Stockage[4]).
 
-| Décalage | Opcode | Pile                                                                    |
-| --------:| ------ | ----------------------------------------------------------------------- |
-|      18B | SWAP1  | calldataload(4) Storage[(((SHA3 of 0x00-0x1F))) + calldataload(4)] 0xDA |
-|      18C | POP    | Storage[(((SHA3 of 0x00-0x1F))) + calldataload(4)] 0xDA                 |
-|      18D | DUP2   | 0xDA Storage[(((SHA3 of 0x00-0x1F))) + calldataload(4)] 0xDA            |
-|      18E | JUMP   | Storage[(((SHA3 of 0x00-0x1F))) + calldataload(4)] 0xDA                 |
+| Décalage | Opcode | Base                                                                                                                                                                                                                        |
+| -------: | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|      18B | SWAP1  | calldataload(4) Stockage[(((SHA3 de 0x00-0x1F))) + calldataload(4)] 0xDA |
+|      18C | POP    | Stockage[(((SHA3 de 0x00-0x1F))) + calldataload(4)] 0xDA                                    |
+|      18D | DUP2   | 0xDA Stockage[(((SHA3 de 0x00-0x1F))) + calldataload(4)] 0xDA                               |
+|      18E | JUMP   | Stockage[(((SHA3 de 0x00-0x1F))) + calldataload(4)] 0xDA                                    |
 
-Nous savons déjà ce que fait [le code à la valeur décalée 0xDA](#the-da-code) , il retourne la valeur la plus élevée de la pile à l'appelant. Ainsi, cette fonction retourne la valeur de la table de recherche à l'appelant.
+Nous savons déjà ce que fait [le code au décalage 0xDA](#the-da-code) : il renvoie la valeur supérieure de la pile à l'appelant. Cette fonction renvoie donc la valeur de la table de recherche à l'appelant.
 
 ## 0x1f135823 {#0x1f135823}
 
-Le code aux décalages 0xC4-0xCF est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que cette fonction n'est pas `payable` non plus.
+Le code aux décalages 0xC4-0xCF est identique à ce que nous avons vu en 0x103-0x10E dans `splitter()` (autre que la destination `JUMPI`), donc nous savons que cette fonction n'est pas non plus `payable`.
 
-| Décalage | Opcode       | Pile                |
-| --------:| ------------ | ------------------- |
-|       D0 | JUMPDEST     |                     |
-|       D1 | POP          |                     |
-|       D2 | PUSH2 0x00da | 0xDA                |
-|       D5 | PUSH1 0x06   | 0x06 0xDA           |
+| Décalage | Opcode       | Base              |
+| -------: | ------------ | ----------------- |
+|       D0 | JUMPDEST     |                   |
+|       D1 | POP          |                   |
+|       D2 | PUSH2 0x00da | 0xDA              |
+|       D5 | PUSH1 0x06   | 0x06 0xDA         |
 |       D7 | SLOAD        | Value\* 0xDA      |
 |       D8 | DUP2         | 0xDA Value\* 0xDA |
 |       D9 | JUMP         | Value\* 0xDA      |
 
-Nous savons déjà ce que fait [le code à la position 0xDA](#the-da-code) , il retourne la valeur la plus élevée de la pile à l'appelant. Donc cette fonction retourne `Value*`.
+Nous savons déjà ce que fait [le code au décalage 0xDA](#the-da-code) : il renvoie la valeur supérieure de la pile à l'appelant. Cette fonction retourne donc `Value*`.
 
 ### Résumé de la méthode {#method-summary}
 
-Avez-vous l'impression de comprendre le contrat à ce stade ? Non. Jusqu'à présent, nous disposons de ces méthodes :
+Avez-vous l'impression de comprendre le contrat à ce stade ? Moi, non. Jusqu'à présent, nous disposons de ces méthodes :
 
-| Méthode                           | Signification                                                                                          |
-| --------------------------------- | ------------------------------------------------------------------------------------------------------ |
-| Transférer                        | Accepte la valeur fournie par l'appel et augmente `Value*` de ce montant                               |
-| [splitter()](#splitter)           | Return Storage[3], the proxy address                                                                   |
-| [currentWindow()](#currentwindow) | Return Storage[1]                                                                                      |
-| [merkleRoot()](#merkeroot)        | Return Storage[0]                                                                                      |
-| [0x81e580d3](#0x81e580d3)         | Retourne la valeur d'une table de recherche, à condition que le paramètre soit inférieur à Stockage[4] |
-| [0x1f135823](#0x1f135823)         | Return Storage[6], a.k.a. Value\*                                                                    |
+| Méthode                                              | Signification                                                                                                                                               |
+| ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Transférer                                           | Accepter la valeur fournie par l'appel et augmenter `Value*` de ce montant                                                                                  |
+| [splitter()](#splitter)           | Retourner Stockage[3], l'adresse du proxy                                                               |
+| [currentWindow()](#currentwindow) | Retourner Stockage[1]                                                                                   |
+| [merkleRoot()](#merkleroot)       | Retourner Stockage[0]                                                                                   |
+| [0x81e580d3](#0x81e580d3)                            | Retourner la valeur d'une table de recherche, à condition que le paramètre soit inférieur à Stockage[4] |
+| [0x1f135823](#0x1f135823)                            | Retourner Stockage[6], alias Valeur\*                                                                   |
 
-Mais nous savons que toute autre fonctionnalité est fournie par le contrat dans Stockage[3]. Peut-être que si nous savions quel est ce contrat, cela nous donnerait un indice. Heureusement, ceci est la blockchain et tout est connu, du moins en théorie. Nous n'avons pas vu de méthode qui définisse Stockage[3], donc il doit avoir été défini par le constructeur.
+Mais nous savons que toute autre fonctionnalité est fournie par le contrat dans Stockage[3]. Peut-être que si nous savions quel est ce contrat, cela nous donnerait un indice. Heureusement, il s'agit de la blockchain et tout est connu, du moins en théorie. Nous n'avons pas vu de méthode qui définisse Stockage[3], il doit donc avoir été défini par le constructeur.
 
-## Le Constructeur {#the-constructor}
+## Le constructeur {#the-constructor}
 
-Lorsque nous [regardons un contrat](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f) nous pouvons également voir la transaction qui l'a créée.
+Quand nous [examinons un contrat](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f), nous pouvons aussi voir la transaction qui l'a créé.
 
 ![Cliquez sur la transaction de création](create-tx.png)
 
-Si nous cliquons sur cette transaction, puis sur l'onglet **État** , nous pouvons voir les valeurs initiales des paramètres. Plus précisément, nous pouvons voir que Stockage[3] contient [0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761](https://etherscan.io/address/0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761). Ce contrat doit contenir la fonctionnalité manquante. Nous pouvons le comprendre en utilisant les mêmes outils que ceux utilisés pour le contrat que nous étudions.
+Si nous cliquons sur cette transaction, puis sur l'onglet **State**, nous pouvons voir les valeurs initiales des paramètres. Plus précisément, nous pouvons voir que Stockage[3] contient [0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761](https://etherscan.io/address/0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761). Ce contrat doit contenir la fonctionnalité manquante. Nous pouvons le comprendre en utilisant les mêmes outils que ceux que nous avons utilisés pour le contrat que nous étudions.
 
-## Le contrat de proxy {#the-proxy-contract}
+## Le contrat proxy {#the-proxy-contract}
 
-En utilisant les mêmes techniques que celles utilisées pour le contrat original ci-dessus, nous pouvons voir que le contrat est annulé si :
+En utilisant les mêmes techniques que celles que nous avons utilisées pour le contrat original ci-dessus, nous pouvons voir que le contrat est annulé si :
 
-- Il y a de l'ETH joint à l'appel (0x05-0x0F)
+- Il y a des ETH attachés à l'appel (0x05-0x0F)
 - La taille des données d'appel est inférieure à quatre (0x10-0x19 et 0xBE-0xC2)
 
-Et que les méthodes qu'il supporte sont :
+Et les méthodes qu'il prend en charge sont :
 
-| Méthode                                                                                                         | Signature de la méthode      | Décalage vers lequel sauter |
-| --------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------- |
-| [scaleAmountByPercentage(uint256,uint256)](https://www.4byte.directory/signatures/?bytes4_signature=0x8ffb5c97)          | 0x8ffb5c97                   | 0x0135                      |
-| [isClaimed(uint256,address)](https://www.4byte.directory/signatures/?bytes4_signature=0xd2ef0795)               | 0xd2ef0795                   | 0x0151                      |
-| [claim(uint256,address,uint256,bytes32[])](https://www.4byte.directory/signatures/?bytes4_signature=0x2e7ba6ef) | 0x2e7ba6ef                   | 0x00F4                      |
-| [incrementWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0x338b1d31)                        | 0x338b1d31                   | 0x0110                      |
-| ???                                                                                                             | 0x3f26479e                   | 0x0118                      |
-| ???                                                                                                             | 0x1e7df9d3                   | 0x00C3                      |
-| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4)                          | [0xba0bafb4](#currentwindow) | 0x0148                      |
-| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab)                             | [0x2eb4a7ab](#merkleroot)    | 0x0107                      |
-| ???                                                                                                             | [0x81e580d3](#0x81e580d3)    | 0x0122                      |
-| ???                                                                                                             | [0x1f135823](#0x1f135823)    | 0x00D8                      |
+| Méthode                                                                                                                                                                                | Signature de la méthode      | Décalage de destination du saut |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------- |
+| [scaleAmountByPercentage(uint256,uint256)](https://www.4byte.directory/signatures/?bytes4_signature=0x8ffb5c97)                                                     | 0x8ffb5c97                   | 0x0135                          |
+| [isClaimed(uint256,address)](https://www.4byte.directory/signatures/?bytes4_signature=0xd2ef0795)                                                                   | 0xd2ef0795                   | 0x0151                          |
+| [claim(uint256,address,uint256,bytes32[])](https://www.4byte.directory/signatures/?bytes4_signature=0x2e7ba6ef) | 0x2e7ba6ef                   | 0x00F4                          |
+| [incrementWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0x338b1d31)                                                                            | 0x338b1d31                   | 0x0110                          |
+| ???                                                                                                                                                                                    | 0x3f26479e                   | 0x0118                          |
+| ???                                                                                                                                                                                    | 0x1e7df9d3                   | 0x00C3                          |
+| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4)                                                                              | [0xba0bafb4](#currentwindow) | 0x0148                          |
+| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab)                                                                                 | [0x2eb4a7ab](#merkleroot)    | 0x0107                          |
+| ???                                                                                                                                                                                    | [0x81e580d3](#0x81e580d3)    | 0x0122                          |
+| ???                                                                                                                                                                                    | [0x1f135823](#0x1f135823)    | 0x00D8                          |
 
-Nous pouvons ignorer les quatre dernières méthodes parce que nous ne les atteindrons jamais. Leurs signatures sont telles que notre contrat original les prend en charge par lui-même (vous pouvez cliquer sur les signatures pour voir les détails ci-dessus), donc elles doivent être des [méthodes qui sont contournées](https://medium.com/upstate-interactive/solidity-override-vs-virtual-functions-c0a5dfb83aaf).
+Nous pouvons ignorer les quatre dernières méthodes, car nous ne les atteindrons jamais. Leurs signatures sont telles que notre contrat original s'en occupe lui-même (vous pouvez cliquer sur les signatures pour voir les détails ci-dessus), donc il doit s'agir de [méthodes qui sont surchargées](https://medium.com/upstate-interactive/solidity-override-vs-virtual-functions-c0a5dfb83aaf).
 
-Une des méthodes restantes est `claim(<params>)`, et une autre est `isClaimed(<params>)`, donc cela ressemble à un contrat d'airdrop. Au lieu de fouiller le code d'opération restant par opcode, nous pouvons [essayer le décompilateur](https://etherscan.io/bytecode-decompiler?a=0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761), qui donne des résultats utilisables pour trois fonctions de ce contrat. La rétro-conception des autres est laissée au lecteur comme exercice de travail.
+L'une des méthodes restantes est `claim(<params>)` et une autre est `isClaimed(<params>)`, donc cela ressemble à un contrat d'airdrop. Une des méthodes restantes est `claim(<params>)`, et une autre est `isClaimed(<params>)`, donc cela ressemble à un contrat d'airdrop. Au lieu de passer en revue le reste des opcodes un par un, nous pouvons [essayer le décompilateur](https://etherscan.io/bytecode-decompiler?a=0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761), qui produit des résultats utilisables pour trois fonctions de ce contrat.
+
+L'ingénierie inverse des autres est laissée comme exercice au lecteur.
 
 ### scaleAmountByPercentage {#scaleamountbypercentage}
 
-Voilà ce que nous donne le décompilateur pour cette fonction :
+Voici ce que le décompilateur nous donne pour cette fonction :
 
 ```python
 def unknown8ffb5c97(uint256 _param1, uint256 _param2) payable:
@@ -592,15 +592,15 @@ def unknown8ffb5c97(uint256 _param1, uint256 _param2) payable:
   return (_param1 * _param2 / 100 * 10^6)
 ```
 
-Le premier `require` vérifie que les données d'appel ont, en plus des quatre octets de la signature de la fonction, au moins 64 octets, assez pour les deux paramètres. Si ce n'est pas le cas, il y a évidemment quelque chose qui ne va pas.
+Le premier `require` teste si les données d'appel contiennent, en plus des quatre octets de la signature de fonction, au moins 64 octets, ce qui est suffisant pour les deux paramètres. Sinon, il y a manifestement un problème.
 
-L'instruction `if` semble vérifier que `_param1` n'est pas zéro et que `_param1 * _param2` n'est pas négatif. C'est probablement pour éviter des cas de renvoi à la ligne.
+L'instruction `if` semble vérifier que `_param1` n'est pas nul et que `_param1 * _param2` n'est pas négatif. C'est probablement pour éviter les cas de bouclage (wrap around).
 
 Enfin, la fonction retourne une valeur mise à l'échelle.
 
 ### claim {#claim}
 
-Le code que le décompilateur crée est complexe, et tout n'est pas pertinent pour nous. Je vais en passer une partie pour me concentrer sur les lignes qui je pense fournissent des informations utiles
+Le code que le décompilateur crée est complexe, et tout n'est pas pertinent pour nous. Je vais en sauter une partie pour me concentrer sur les lignes qui, à mon avis, fournissent des informations utiles.
 
 ```python
 def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _param4) payable:
@@ -611,10 +611,10 @@ def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _pa
       revert with 0, 'cannot claim for a future window'
 ```
 
-Nous voyons ici deux choses importantes :
+Nous voyons ici deux choses importantes :
 
 - `_param2`, bien qu'il soit déclaré comme un `uint256`, est en fait une adresse
-- `_param1` est la fenêtre revendiquée, qui doit être `currentWindow` ou antérieure.
+- `_param1` est la fenêtre réclamée, qui doit être `currentWindow` ou une fenêtre antérieure.
 
 ```python
   ...
@@ -622,7 +622,7 @@ Nous voyons ici deux choses importantes :
       revert with 0, 'Account already claimed the given window'
 ```
 
-Nous savons donc maintenant que Stockage[5] est un tableau de fenêtres et d'adresses, et si l'adresse a réclamé la récompense pour cette fenêtre.
+Nous savons donc maintenant que Stockage[5] est un tableau de fenêtres et d'adresses, et qu'il indique si l'adresse a réclamé la récompense pour cette fenêtre.
 
 ```python
   ...
@@ -642,7 +642,7 @@ Nous savons donc maintenant que Stockage[5] est un tableau de fenêtres et d'adr
       revert with 0, 'Invalid proof'
 ```
 
-Nous savons que `unknown2eb4a7ab` est en fait la fonction `merkleRoot()`, donc ce code semble vérifier une [preuve de Merkle](https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5). Cela signifie que `_param4` est une preuve de Merkle.
+Nous savons que `unknown2eb4a7ab` est en fait la fonction `merkleRoot()`, ce code semble donc vérifier une [preuve de Merkle](https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5). Cela signifie que `_param4` est une preuve de Merkle.
 
 ```python
   call addr(_param2) with:
@@ -650,7 +650,7 @@ Nous savons que `unknown2eb4a7ab` est en fait la fonction `merkleRoot()`, donc c
        gas 30000 wei
 ```
 
-C’est ainsi qu’un contrat transfère son propre ETH à une autre adresse (contrat ou propriété externe). Il l'appelle avec une valeur qui est le montant à transférer. On dirait donc qu'il s'agit d'un airdrop d'ETH.
+C'est ainsi qu'un contrat transfère ses propres ETH à une autre adresse (contrat ou compte externe). Il l'appelle avec une valeur qui est le montant à transférer. Il semble donc qu'il s'agisse d'un airdrop d'ETH.
 
 ```python
   if not return_data.size:
@@ -660,22 +660,22 @@ C’est ainsi qu’un contrat transfère son propre ETH à une autre adresse (co
              value unknown81e580d3[_param1] * _param3 / 100 * 10^6 wei
 ```
 
-Les deux dernières lignes nous disent que Stockage[2] est également un contrat que nous appelons. Si nous [regardons la transaction constructeur](https://etherscan.io/tx/0xa1ea0549fb349eb7d3aff90e1d6ce7469fdfdcd59a2fd9b8d1f5e420c0d05b58#statechange) nous voyons que ce contrat est [0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), un contrat de Wrapped Ether[dont le code source a été téléchargé sur Etherscan](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code).
+Les deux dernières lignes nous disent que Stockage[2] est aussi un contrat que nous appelons. Si nous [examinons la transaction du constructeur](https://etherscan.io/tx/0xa1ea0549fb349eb7d3aff90e1d6ce7469fdfdcd59a2fd9b8d1f5e420c0d05b58#statechange), nous voyons que ce contrat est [0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), un contrat Wrapped Ether [dont le code source a été téléversé sur Etherscan](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code).
 
-Il semble donc que les contrats tentent d'envoyer de l'ETH à `_param2`. S'ils peuvent le faire, très bien. Sinon, il tente d'envoyer [WETH](https://weth.tkn.eth.limo/). Si `_param2` est un compte externe (EOA) alors il peut toujours recevoir de l'ETH, mais les contrats peuvent refuser de recevoir de l'ETH. Cependant, WETH est ERC-20 et les contrats ne peuvent pas refuser de l'accepter.
+Il semble donc que les contrats tentent d'envoyer des ETH à `_param2`. S'il peut le faire, tant mieux. Sinon, il tente d'envoyer du [WETH](https://weth.tkn.eth.limo/). Si `_param2` est un compte externe (EOA), il peut toujours recevoir des ETH, mais les contrats peuvent refuser de recevoir des ETH. Cependant, le WETH est un ERC-20 et les contrats ne peuvent pas refuser de l'accepter.
 
 ```python
   ...
   log 0xdbd5389f: addr(_param2), unknown81e580d3[_param1] * _param3 / 100 * 10^6, bool(ext_call.success)
 ```
 
-À la fin de la fonction, nous voyons qu'une entrée de journal est générée. [Regardez les entrées de journal générées](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#events) et filtrez sur le sujet qui commence par `0xdbd5...`. Si nous [cliquons sur l'une des transactions qui ont généré une telle entrée](https://etherscan.io/tx/0xe7d3b7e00f645af17dfbbd010478ef4af235896c65b6548def1fe95b3b7d2274) nous voyons qu'effectivement cela ressemble à une demande - le compte a envoyé un message au contrat que nous rétro-concevons et a reçu de l'ETH en retour.
+À la fin de la fonction, nous voyons qu'une entrée de journal est générée. [Examinez les entrées de journal générées](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#events) et filtrez sur le sujet qui commence par `0xdbd5...`. Si nous [cliquons sur l'une des transactions qui ont généré une telle entrée](https://etherscan.io/tx/0xe7d3b7e00f645af17dfbbd010478ef4af235896c65b6548def1fe95b3b7d2274), nous voyons qu'il s'agit bien d'une réclamation : le compte a envoyé un message au contrat sur lequel nous faisons de l'ingénierie inverse et a reçu de l'ETH en retour.
 
 ![Une transaction de réclamation](claim-tx.png)
 
 ### 1e7df9d3 {#1e7df9d3}
 
-Cette fonction est très similaire à [`claim`](#claim) ci-dessus. Elle vérifie également une preuve de Merkle, tente de transférer de l'ETH au premier, et produit le même type d'entrée de journal.
+Cette fonction est très similaire à [`claim`](#claim) ci-dessus. Elle vérifie également une preuve de Merkle, tente de transférer de l'ETH à la première et produit le même type d'entrée de journal.
 
 ```python
 def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
@@ -708,7 +708,7 @@ def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
   log 0xdbd5389f: addr(_param1), s, bool(ext_call.success)
 ```
 
-La principale différence est que le premier paramètre, la fenêtre du retrait, n'est pas là. Au lieu de cela, il y a une boucle sur toutes les fenêtres qui pourraient être réclamées.
+La principale différence est que le premier paramètre, la fenêtre à retirer, n'est pas là. À la place, il y a une boucle sur toutes les fenêtres qui pourraient être réclamées.
 
 ```python
   idx = 0
@@ -737,8 +737,10 @@ La principale différence est que le premier paramètre, la fenêtre du retrait,
       continue
 ```
 
-Donc elle ressemble à une variante de `claim` qui réclame toutes les fenêtres.
+Cela ressemble donc à une variante de `claim` qui réclame toutes les fenêtres.
 
 ## Conclusion {#conclusion}
 
-À présent, vous devriez savoir comment comprendre les contrats dont le code source n'est pas disponible, en utilisant soit les codes d'opérations soit (quand cela fonctionne) le décompilateur. Comme le montre la longueur de cet article, rétro-concevoir un contrat n'est pas trivial, mais dans un système où la sécurité est essentielle, il est important d'être capable de vérifier que les contrats fonctionnent comme promis.
+À présent, vous devriez savoir comment comprendre les contrats dont le code source n'est pas disponible, en utilisant soit les opcodes, soit (quand cela fonctionne) le décompilateur. Comme le montre la longueur de cet article, l'ingénierie inverse d'un contrat n'est pas triviale, mais dans un système où la sécurité est essentielle, c'est une compétence importante de pouvoir vérifier que les contrats fonctionnent comme promis.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/run-node-raspberry-pi/index.md b/public/content/translations/fr/developers/tutorials/run-node-raspberry-pi/index.md
index 8fa671cbd92..b3616f18b78 100644
--- a/public/content/translations/fr/developers/tutorials/run-node-raspberry-pi/index.md
+++ b/public/content/translations/fr/developers/tutorials/run-node-raspberry-pi/index.md
@@ -1,47 +1,49 @@
 ---
-title: Comment transformer son Raspberry Pi 4 en un nœud en flashant simplement la carte MicroSD
-description: Flashez votre Raspberry Pi 4, branchez-y un câble ethernet, connectez le disque SSD et mettez l'appareil en marche pour transformer votre Raspberry Pi 4 en un nœud Ethereum complet + validateur
+title: "Exécuter un nœud Ethereum sur un Raspberry Pi 4"
+description: "Flashez votre Raspberry Pi 4, branchez un câble Ethernet, connectez le disque SSD et mettez l'appareil sous tension pour le transformer en un nœud et validateur Ethereum complet"
 author: "EthereumOnArm"
 tags:
-  - "clients"
-  - "couche d'exécution"
-  - "couche de consensus"
-  - "nœuds"
+  [
+    "clients",
+    "couche d'exécution",
+    "couche de consensus",
+    "nœuds"
+  ]
 lang: fr
 skill: intermediate
 published: 2022-06-10
-source: Ethereum sur ARM
+source: Ethereum on ARM
 sourceUrl: https://ethereum-on-arm-documentation.readthedocs.io/en/latest/
 ---
 
-**Ethereum sur Arm est une image Linux personnalisée qui peut transformer un Raspberry Pi en un nœud Ethereum.**
+**Ethereum on Arm est une image Linux personnalisée qui peut transformer un Raspberry Pi en un nœud Ethereum.**
 
-Pour utiliser Ethereum sur Arm pour transformer un Raspberry Pi en un nœud Ethereum, le matériel suivant est recommandé :
+Pour utiliser Ethereum on Arm afin de transformer un Raspberry Pi en nœud Ethereum, le matériel suivant est recommandé :
 
-- Carte Raspberry 4 (modèle B 8Go), Odroid M1 ou Rock 5B (8Go/16Go de RAM)
-- Carte MicroSD (16 Go Classe 10 minimum)
-- Disque 2 To SSD USB 3.0 minimum ou un SSD avec USB vers un SATA.
+- Carte Raspberry 4 (modèle B 8 Go), Odroid M1 ou Rock 5B (8 Go/16 Go de RAM)
+- Carte microSD (16 Go, classe 10 au minimum)
+- Disque SSD de 2 To minimum avec port USB 3.0 ou un SSD avec un boîtier USB vers SATA.
 - Alimentation électrique
-- Un câble Ethernet
-- Transfert de port (voir clients pour plus d'informations)
-- Un boîtier avec dissipateur de chaleur et ventilateur
-- Clavier USB, moniteur et câble HDMI (micro-HDMI) (facultatif)
+- Câble Ethernet
+- Redirection de port (voir les clients pour plus d'informations)
+- Un boîtier avec dissipateur thermique et ventilateur
+- Clavier USB, moniteur et câble HDMI (micro-HDMI) (en option)
 
-## Pourquoi utiliser Ethereum avec ARM ? {#why-run-ethereum-on-arm}
+## Pourquoi faire tourner Ethereum sur ARM ? {#why-run-ethereum-on-arm}
 
-Les cartes ARM sont très abordables, flexibles et équivalentes à de petits ordinateurs. Elles sont de bons choix pour faire fonctionner des nœuds Ethereum car elles sont bon marché, configurées de sorte que toutes leurs ressources se concentrent uniquement sur le nœud, les rendant ainsi efficaces, elles consomment peu de puissance et sont physiquement peu nombreuses pour qu'elles puissent s'adapter discrètement à n'importe quel environnement. Il est également très facile de faire tourner des nœuds puisque la MicroSD du Raspberry Pi peut simplement être flashée avec une image reconstruite, sans téléchargement ou logiciel de construction requis.
+Les cartes ARM sont de petits ordinateurs très abordables et flexibles. Elles sont un bon choix pour exécuter des nœuds Ethereum, car elles sont bon marché, peuvent être configurées de manière à ce que toutes leurs ressources se concentrent sur le nœud (ce qui les rend efficaces), consomment peu d'énergie et sont de petite taille, ce qui leur permet de s'intégrer discrètement dans n'importe quel foyer. Il est également très facile de lancer des nœuds, car la carte MicroSD du Raspberry Pi peut simplement être flashée avec une image pré-construite, sans qu'il soit nécessaire de télécharger ou de compiler des logiciels.
 
 ## Comment ça marche ? {#how-does-it-work}
 
-La carte mémoire du Raspberry Pi est flashée avec une image préconstruite. Cette image contient tout ce qui est nécessaire pour exécuter un nœud Ethereum. Avec une carte flash, tout ce que l'utilisateur a besoin de faire est d'allumer son Raspberry Pi. Tous les processus requis pour exécuter le nœud sont démarrés automatiquement. Cela fonctionne parce que la carte mémoire contient un système d'exploitation (OS) basé sur Linux sur lequel sont exécutés automatiquement les processus au niveau du système qui transforment l'unité en un nœud Ethereum.
+La carte mémoire du Raspberry Pi est flashée avec une image pré-construite. Cette image contient tout ce qui est nécessaire pour exécuter un nœud Ethereum. Avec une carte flashée, il suffit à l'utilisateur d'allumer le Raspberry Pi. Tous les processus nécessaires pour exécuter le nœud sont démarrés automatiquement. Cela fonctionne, car la carte mémoire contient un système d'exploitation (SE) basé sur Linux, sur lequel des processus au niveau du système sont exécutés automatiquement pour transformer l'appareil en un nœud Ethereum.
 
-Ethereum ne peut pas être exécuté en utilisant le populaire Raspberry Pi Linux OS « Raspbian » car Raspbian utilise toujours une architecture 32 bits qui conduit les utilisateurs d'Ethereum à rencontrer des problèmes de mémoire et les clients de consensus ne prennent pas en charge les binaires 32 bits. Pour surmonter cela, l'équipe Ethereum on Arm a migré vers un OS 64 bits natif appelé « Armbian ».
+Ethereum ne peut pas être exécuté avec le système d'exploitation populaire du Raspberry Pi, « Raspbian », car ce dernier utilise toujours une architecture 32 bits, ce qui cause des problèmes de mémoire aux utilisateurs d'Ethereum, et les clients de consensus ne prennent pas en charge les binaires 32 bits. Pour surmonter cela, l'équipe Ethereum on Arm a migré vers un système d'exploitation natif 64 bits appelé « Armbian ».
 
-**Les images s'occupent de réaliser toutes les étapes nécessaires**, allant de la configuration de l'environnement et du formatage du disque SSD, à l'installation et à l'exécution du logiciel Ethereum, ainsi qu'au lancement de la synchronisation avec la blockchain.
+**Les images s'occupent de toutes les étapes nécessaires**, de la configuration de l'environnement et du formatage du disque SSD à l'installation et l'exécution du logiciel Ethereum, ainsi qu'au démarrage de la synchronisation de la blockchain.
 
-## Note sur les clients d'exécution et de consensus {#note-on-execution-and-consensus-clients}
+## Remarque sur les clients d'exécution et de consensus {#note-on-execution-and-consensus-clients}
 
-L'image Ethereum sur Arm inclut les clients d'exécution et de consensuel préconstruits en tant que services. Un nœud Ethereum nécessite que les deux clients soient synchronisés et exécutés. Vous devez seulement télécharger et flasher l'image et ensuite démarrer les services. L'image est préchargée avec les clients d'exécution suivants :
+L'image Ethereum on Arm inclut des clients d'exécution et de consensus pré-construits en tant que services. Un nœud Ethereum nécessite que les deux clients soient synchronisés et en cours d'exécution. Il vous suffit de télécharger et de flasher l'image, puis de démarrer les services. L'image est préchargée avec les clients d'exécution suivants :
 
 - Geth
 - Nethermind
@@ -54,84 +56,84 @@ et les clients de consensus suivants :
 - Prysm
 - Teku
 
-Vous devez choisir un de chaque à exécuter - tous les clients d'exécution sont compatibles avec tous les clients de consensus. Si vous ne sélectionnez pas explicitement un client, le noeud va revenir à ses valeurs par défaut - Geth et Lighthouse - et les exécuter automatiquement lorsque la carte sera mise en marche. Vous devez ouvrir le port 30303 sur votre routeur pour que Geth puisse trouver et se connecter aux pairs.
+Vous devez en choisir un de chaque à exécuter. Tous les clients d'exécution sont compatibles avec tous les clients de consensus. Si vous ne sélectionnez pas explicitement un client, le nœud utilisera ses options par défaut (Geth et Lighthouse) et les exécutera automatiquement à la mise sous tension de la carte. Vous devez ouvrir le port 30303 sur votre routeur pour que Geth puisse trouver des pairs et s'y connecter.
 
 ## Téléchargement de l'image {#downloading-the-image}
 
-L'image Ethereum Raspberry Pi 4 est une image « plug and play » qui installe et configure automatiquement à la fois les clients d'exécution et de consensus pour communiquer mutuellement et se connecter au réseau Ethereum. Tout ce que l'utilisateur doit faire est de démarrer ses processus en utilisant une commande simple.
+L'image Ethereum pour Raspberry Pi 4 est une image « prête à l'emploi » qui installe et configure automatiquement les clients d'exécution et de consensus, en les configurant pour qu'ils communiquent entre eux et se connectent au réseau Ethereum. L'utilisateur n'a qu'à démarrer les processus à l'aide d'une simple commande.
 
-Téléchargez l'image Raspberry Pi depuis [Ethereum sur Arm](https://ethereumonarm-my.sharepoint.com/:u:/p/dlosada/Ec_VmUvr80VFjf3RYSU-NzkBmj2JOteDECj8Bibde929Gw?download=1) et vérifiez le hachage SHA256 :
+Téléchargez l'image du Raspberry Pi depuis [Ethereum on Arm](https://ethereumonarm-my.sharepoint.com/:u:/p/dlosada/Ec_VmUvr80VFjf3RYSU-NzkBmj2JOteDECj8Bibde929Gw?download=1) et vérifiez le hachage SHA256 :
 
 ```sh
-# From directory containing the downloaded image
+# À partir du répertoire contenant l'image téléchargée
 shasum -a 256 ethonarm_22.04.00.img.zip
-# Hash should output: fb497e8f8a7388b62d6e1efbc406b9558bee7ef46ec7e53083630029c117444f
+# Le hachage devrait être : fb497e8f8a7388b62d6e1efbc406b9558bee7ef46ec7e53083630029c117444f
 ```
 
-Notez que les images des cartes Rock 5B et Odroid M1 sont disponibles sur la page de téléchargement [Ethereum sur Arm](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/).
+Notez que les images pour les cartes Rock 5B et Odroid M1 sont disponibles sur la [page de téléchargement](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) d'Ethereum-on-Arm.
 
 ## Flasher la carte MicroSD {#flashing-the-microsd}
 
-La carte MicroSD qui sera utilisée pour le Raspberry Pi doit d'abord être insérée dans un ordinateur de bureau ou portable pour qu'elle puisse être flashée. Ensuite, les commandes de terminal suivantes installeront l'image téléchargée sur la carte SD :
+La carte MicroSD qui sera utilisée pour le Raspberry Pi doit d'abord être insérée dans un ordinateur de bureau ou un ordinateur portable afin de pouvoir être flashée. Ensuite, les commandes de terminal suivantes flasheront l'image téléchargée sur la carte SD :
 
 ```shell
-# check the MicroSD card name
+# vérifiez le nom de la carte MicroSD
 sudo fdisk -l
 
 >> sdxxx
 ```
 
-Il est vraiment important d'obtenir le nom correct, car la commande suivante inclut `dd` qui efface complètement le contenu existant de la carte avant de flasher l'image dessus. Pour continuer, accédez au répertoire contenant l'image compressée :
+Il est très important d'utiliser le bon nom, car la commande suivante inclut `dd`, qui efface complètement le contenu de la carte avant d'y copier l'image. Pour continuer, accédez au répertoire contenant l'image compressée :
 
 ```shell
-# unzip and flash image
+# décompressez et flashez l'image
 unzip ethonarm_22.04.00.img.zip
 sudo dd bs=1M if=ethonarm_22.04.00.img of=/dev/<sdxx> conv=fdatasync status=progress
 ```
 
-La carte est maintenant flashée et peut être insérée dans le Raspberry Pi.
+La carte est maintenant flashée, elle peut donc être insérée dans le Raspberry Pi.
 
 ## Démarrer le nœud {#start-the-node}
 
-Avec la carte SD insérée dans le Raspberry Pi, connectez le câble ethernet et le SSD puis allumez l'alimentation. L'OS démarrera et commencera automatiquement à exécuter les tâches préconfigurées qui transforment le Raspberry Pi en un nœud Ethereum, y compris l'installation et la construction du logiciel client. Cela prendra probablement 10 à 15 minutes.
+Une fois la carte SD insérée dans le Raspberry Pi, branchez le câble Ethernet et le SSD, puis mettez l'appareil sous tension. Le système d'exploitation démarrera et commencera automatiquement à exécuter les tâches préconfigurées qui transforment le Raspberry Pi en un nœud Ethereum, y compris l'installation et la compilation du logiciel client. Cela prendra probablement 10 à 15 minutes.
 
-Une fois que tout est installé et configuré, connectez-vous au périphérique via une connexion ssh ou directement en utilisant le terminal si un moniteur et un clavier sont connectés à la carte. Utilisez le compte `ethereum` pour vous connecter, car il a les permissions requises pour démarrer le nœud.
+Une fois que tout est installé et configuré, connectez-vous à l'appareil via une connexion SSH ou en utilisant directement le terminal si un moniteur et un clavier sont connectés à la carte. Utilisez le compte `ethereum` pour vous connecter, car il dispose des autorisations requises pour démarrer le nœud.
 
 ```shell
 Utilisateur : ethereum
 Mot de passe : ethereum
 ```
 
-Le client d'exécution par défaut, Geth, démarrera automatiquement. Vous pouvez confirmer cela en vérifiant les logs en utilisant la ligne de commande suivante :
+Le client d'exécution par défaut, Geth, démarrera automatiquement. Vous pouvez le confirmer en vérifiant les journaux à l'aide de la commande suivante :
 
 ```sh
 sudo journalctl -u geth -f
 ```
 
-Le client de consensus doit être démarré explicitement. Pour ce faire, ouvrez d'abord le port 9000 sur votre routeur afin que Lighthouse puisse trouver des paires et s'y connecter. Ensuite, activez et démarrez le service Lighthouse :
+Le client de consensus doit être démarré explicitement. Pour ce faire, ouvrez d'abord le port 9000 sur votre routeur afin que Lighthouse puisse trouver des pairs et s'y connecter. Ensuite, activez et démarrez le service Lighthouse :
 
 ```sh
 sudo systemctl enable lighthouse-beacon
 sudo systemctl start lighthouse-beacon
 ```
 
-Vérifiez le client en utilisant les logs :
+Vérifiez le client à l'aide des journaux :
 
 ```sh
 sudo journalctl -u lighthouse-beacon
 ```
 
-Notez que le client de consensus se synchronisera après quelques minutes car il utilise la synchronisation de point de contrôle. Le client d'exécution prendra plus de temps - potentiellement plusieurs heures, et il ne démarrera pas jusqu'à ce que le client de consensus soit déjà synchronisé (du fait que le client d'exécution a besoin d'une cible pour synchroniser, que le client de consensus synchronisé fournit).
+Notez que le client de consensus se synchronisera en quelques minutes, car il utilise la synchronisation par point de contrôle. Le client d'exécution mettra plus de temps (potentiellement plusieurs heures) et ne démarrera pas tant que le client de consensus n'aura pas terminé sa synchronisation (car le client d'exécution a besoin d'une cible avec laquelle se synchroniser, cible qui est fournie par le client de consensus synchronisé).
 
-Avec les services Geth et Lighthouse exécutant et synchronisés, votre Raspberry Pi est maintenant un nœud Ethereum ! Il est plus courant d'interagir avec le réseau Ethereum en utilisant la console JavaScript de Geth, qui peut être reliée au client Geth sur le port 8545. Il est également possible de soumettre des commandes formatées en objets JSON en utilisant un outil de requête tel que Curl. En savoir plus dans la [documentation Geth](https://geth.ethereum.org).
+Une fois les services Geth et Lighthouse en cours d'exécution et synchronisés, votre Raspberry Pi est désormais un nœud Ethereum complet ! L'interaction avec le réseau Ethereum se fait le plus souvent via la console Javascript de Geth, qui peut être attachée au client Geth sur le port 8545. Il est également possible de soumettre des commandes formatées en tant qu'objets JSON à l'aide d'un outil de requête tel que Curl. Pour en savoir plus, consultez la [documentation de Geth](https://geth.ethereum.org/).
 
-Geth est préconfiguré pour rapporter des mesures sur un tableau de bord Grafana qui peut être consulté dans le navigateur. Les utilisateurs plus avancés pourraient vouloir utiliser cette fonctionnalité pour surveiller la santé de leur nœud en naviguant vers `ipaddress:3000`, utilisant `utilisateur : admin` et `passe: ethereum`.
+Geth est préconfiguré pour envoyer des métriques à un tableau de bord Grafana qui peut être consulté dans le navigateur. Les utilisateurs plus avancés peuvent utiliser cette fonctionnalité pour surveiller la santé de leur nœud en se rendant sur `ipaddress:3000`, et en utilisant `user: admin` et `passwd: ethereum`.
 
 ## Validateurs {#validators}
 
-Un validateur peut également être ajouté au client de consensus. Le logiciel du validateur permet à votre nœud de participer activement au consensus et fournit au réseau une sécurité cryptoéconomique. Vous avez été récompensé pour ce travail en ETH. Pour faire fonctionner un validateur, vous devez d'abord avoir 32 ETH, qui doivent être déposés dans le contrat de dépôt. **Ceci est un engagement à long terme - il n'est pas encore possible de retirer cet ETH !**. Le dépôt peut être fait en suivant le guide étape par étape sur la [plateforme de lancement](https://launchpad.ethereum.org/). Faites ceci sur un ordinateur de bureau ou portable, mais ne générez pas de clés — cela peut être fait directement sur le Raspberry Pi.
+Un validateur peut également être ajouté en option au client de consensus. Le logiciel de validation permet à votre nœud de participer activement au consensus et de fournir au réseau une sécurité cryptoéconomique. Vous êtes récompensé pour ce travail en ETH. Pour exécuter un validateur, vous devez d'abord disposer de 32 ETH, qui doivent être déposés dans le contrat de dépôt. Le dépôt peut être effectué en suivant le guide étape par étape sur le [Launchpad](https://launchpad.ethereum.org/). Faites-le sur un ordinateur de bureau/portable, mais ne générez pas les clés – cette opération peut être effectuée directement sur le Raspberry Pi.
 
-Ouvrir un terminal sur le Raspberry Pi et exécutez la commande suivante pour générer les clés de dépôt :
+Ouvrez un terminal sur le Raspberry Pi et exécutez la commande suivante pour générer les clés de dépôt :
 
 ```
 sudo apt-get update
@@ -139,32 +141,35 @@ sudo apt-get install staking-deposit-cli
 cd && deposit new-mnemonic --num_validators 1
 ```
 
-Gardez la phrase mnémonique en sécurité ! La commande ci-dessus a généré deux fichiers dans le répertoire de clés du noeud : les clés du validateur et un fichier de données de dépôt. Les données de dépôt doivent être téléchargées sur la plateforme de lancement, donc elles doivent être copiées du Raspberry Pi à l'ordinateur. Cela peut être fait en utilisant une connexion ssh ou toute autre méthode de copier/coller.
+(Ou téléchargez le [staking-deposit-cli](https://github.com/ethereum/staking-deposit-cli) pour l'exécuter sur une machine hors ligne, et exécutez la commande `deposit new-mnemnonic`)
 
-Une fois que le fichier de données de dépôt est disponible sur l'ordinateur exécutant la plateforme de lancement, il peut être déplacé et déposé sur le `+` de l'écran de la plateforme de lancement. Suivez les instructions à l'écran pour envoyer une transaction au contrat de dépôt.
+Conservez la phrase mnémonique en lieu sûr ! La commande ci-dessus a généré deux fichiers dans le keystore du nœud : les clés de validateur et un fichier de données de dépôt. Les données de dépôt doivent être téléversées sur le Launchpad, elles doivent donc être copiées du Raspberry Pi vers l'ordinateur de bureau/portable. Cela peut être fait en utilisant une connexion SSH ou toute autre méthode de copier-coller.
 
-Sur le Raspberry Pi, un validateur peut être démarré. Cela nécessite d'importer les clés du validateur, de définir l'adresse pour collecter les récompenses, puis de démarrer le processus de validateur préconfiguré. L'exemple ci-dessous est pour Lighthouse : des instructions pour d'autres clients de consensus sont disponibles sur [la documentation Ethereum on Arm](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) :
+Une fois que le fichier de données de dépôt est disponible sur l'ordinateur exécutant le Launchpad, il peut être glissé-déposé sur le `+` de l'écran du Launchpad. Suivez les instructions à l'écran pour envoyer une transaction au contrat de dépôt.
+
+De retour sur le Raspberry Pi, un validateur peut être démarré. Cela nécessite d'importer les clés du validateur, de définir l'adresse de collecte des récompenses, puis de démarrer le processus de validation préconfiguré. L'exemple ci-dessous concerne Lighthouse. Les instructions pour les autres clients de consensus sont disponibles dans la [documentation Ethereum on Arm](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) :
 
 ```shell
-# import the validator keys
+# importer les clés du validateur
 lighthouse account validator import --directory=/home/ethereum/validator_keys
 
-# set the reward address
+# définir l'adresse de récompense
 sudo sed -i 's/<ETH_ADDRESS>' /etc/ethereum/lighthouse-validator.conf
 
-# start the validator
+# démarrer le validateur
 sudo systemctl start lighthouse-validator
 ```
 
-Félicitations, vous disposez maintenant d'un nœud Ethereum complet et d'un validateur fonctionnant sur un Raspberry Pi !
+Félicitations, vous avez maintenant un nœud et un validateur Ethereum complets fonctionnant sur un Raspberry Pi !
 
 ## Plus de détails {#more-details}
 
-Cette page a donné un aperçu de la façon de mettre en place un nœud et un validateur Geth-Lighthouse utilisant Raspberry Pi. Des instructions plus détaillées sont disponibles sur[ le site Ethereum-on-Arm](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/).
+Cette page a donné un aperçu de la configuration d'un nœud et d'un validateur Geth-Lighthouse à l'aide d'un Raspberry Pi. Des instructions plus détaillées sont disponibles sur le [site web d'Ethereum-on-Arm](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/index.html).
 
-## Commentaires appréciés {#feedback-appreciated}
+## Vos commentaires sont les bienvenus {#feedback-appreciated}
 
-Nous savons que le Raspberry Pi dispose d'une importante base d'utilisateurs qui pourrait avoir un impact très positif sur la santé du réseau Ethereum. Veuillez parcourir les détails de ce tutoriel, essayez d'exécuter sur les réseaux de test, regardez sur le GitHub Ethereum-on-Arm, émettez vos commentaires, soulevez des problématiques et des pull requests et aidez ainsi à faire avancer la technologie et la documentation !
+Nous savons que le Raspberry Pi a une base d'utilisateurs massive qui pourrait avoir un impact très positif sur la santé du réseau Ethereum.
+N'hésitez pas à examiner les détails de ce tutoriel, à faire des essais sur les réseaux de test, à consulter le GitHub d'Ethereum on Arm, à donner votre avis, à signaler des problèmes et à proposer des pull requests pour aider à faire progresser la technologie et la documentation !
 
 ## Références {#references}
 
diff --git a/public/content/translations/fr/developers/tutorials/scam-token-tricks/index.md b/public/content/translations/fr/developers/tutorials/scam-token-tricks/index.md
new file mode 100644
index 00000000000..1b1008fee1a
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/scam-token-tricks/index.md
@@ -0,0 +1,470 @@
+---
+title: "Quelques astuces utilisées par les jetons frauduleux et comment les détecter"
+description: "Dans ce tutoriel, nous disséquons un jeton frauduleux pour voir certaines des astuces que les escrocs utilisent, comment ils les mettent en œuvre, et comment nous pouvons les détecter."
+author: Ori Pomerantz
+tags:
+  [
+    "escroquerie",
+    "Solidity",
+    "erc-20",
+    "JavaScript",
+    "TypeScript"
+  ]
+skill: intermediate
+published: 2023-09-15
+lang: fr
+---
+
+Dans ce tutoriel, nous disséquons [un jeton frauduleux](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) pour voir certaines des astuces que les escrocs utilisent et comment ils les mettent en œuvre. À la fin de ce tutoriel, vous aurez une vue plus complète des contrats de jeton ERC-20, de leurs capacités, et de la raison pour laquelle le scepticisme est nécessaire. Ensuite, nous examinons les événements émis par ce jeton frauduleux et voyons comment nous pouvons identifier automatiquement qu'il n'est pas légitime.
+
+## Jetons frauduleux - que sont-ils, pourquoi les gens les créent-ils, et comment les éviter {#scam-tokens}
+
+Ethereum est couramment utilisé par des groupes pour créer des jetons échangeables ou, dans un certain sens, leur propre monnaie. Cependant, partout où il existe des cas d'utilisation légitimes qui apportent de la valeur, il y a aussi des criminels qui essaient de voler cette valeur à leur profit.
+
+Vous pouvez en lire plus sur ce sujet [ailleurs sur ethereum.org](/guides/how-to-id-scam-tokens/) du point de vue de l'utilisateur. Ce tutoriel se concentre sur la dissection d'un jeton frauduleux pour voir comment cela est fait et comment il peut être détecté.
+
+### Comment savoir que wARB est une escroquerie ? {#warb-scam}
+
+Le jeton que nous disséquons est [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code), qui prétend être équivalent au [jeton ARB](https://etherscan.io/token/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1) légitime.
+
+Le moyen le plus simple de savoir quel est le jeton légitime est de regarder l'organisation d'origine, [Arbitrum](https://arbitrum.foundation/). Les adresses légitimes sont spécifiées [dans leur documentation](https://docs.arbitrum.foundation/deployment-addresses#token).
+
+### Pourquoi le code source est-il disponible ? {#why-source}
+
+Normalement, on s'attendrait à ce que les gens qui essaient d'escroquer les autres soient secrets, et en effet beaucoup de jetons frauduleux n'ont pas leur code disponible (par exemple, [celui-ci](https://optimistic.etherscan.io/token/0x15992f382d8c46d667b10dc8456dc36651af1452#code) et [celui-là](https://optimistic.etherscan.io/token/0x026b623eb4aada7de37ef25256854f9235207178#code)).
+
+Cependant, les jetons légitimes publient généralement leur code source, donc pour paraître légitimes, les auteurs de jetons frauduleux font parfois la même chose. [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) est l'un de ces jetons dont le code source est disponible, ce qui facilite sa compréhension.
+
+Alors que les déployeurs de contrats peuvent choisir de publier ou non le code source, ils _ne peuvent pas_ publier le mauvais code source. L'explorateur de blocs compile le code source fourni de manière indépendante, et s'il n'obtient pas exactement le même bytecode, il rejette ce code source. [Vous pouvez en savoir plus à ce sujet sur le site Etherscan](https://etherscan.io/verifyContract).
+
+## Comparaison avec les jetons ERC-20 légitimes {#compare-legit-erc20}
+
+Nous allons comparer ce jeton à des jetons ERC-20 légitimes. Si vous ne savez pas comment les jetons ERC-20 légitimes sont généralement écrits, [consultez ce tutoriel](/developers/tutorials/erc20-annotated-code/).
+
+### Constantes pour les adresses privilégiées {#constants-for-privileged-addresses}
+
+Les contrats ont parfois besoin d'adresses privilégiées. Les contrats qui sont conçus pour une utilisation à long terme permettent à une adresse privilégiée de changer ces adresses, par exemple pour permettre l'utilisation d'un nouveau contrat multisig. Il y a plusieurs façons de le faire.
+
+Le contrat de [jeton `HOP`](https://etherscan.io/address/0xc5102fe9359fd9a28f877a67e36b0f050d81a3cc#code) utilise le modèle [`Ownable`](https://docs.openzeppelin.com/contracts/2.x/access-control#ownership-and-ownable). L'adresse privilégiée est conservée dans le stockage, dans un champ appelé `_owner` (voir le troisième fichier, `Ownable.sol`).
+
+```solidity
+abstract contract Ownable is Context {
+    address private _owner;
+    .
+    .
+    .
+}
+```
+
+Le contrat de [jeton `ARB`](https://etherscan.io/address/0xad0c361ef902a7d9851ca7dcc85535da2d3c6fc7#code) n'a pas directement d'adresse privilégiée. Cependant, il n'en a pas besoin. Il se trouve derrière un [`proxy`](https://docs.openzeppelin.com/contracts/5.x/api/proxy) à l'[adresse `0xb50721bcf8d664c30412cfbc6cf7a15145234ad1`](https://etherscan.io/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1#code). Ce contrat a une adresse privilégiée (voir le quatrième fichier, `ERC1967Upgrade.sol`) qui peut être utilisée pour les mises à niveau.
+
+```solidity
+    /**
+     * @dev Stocke une nouvelle adresse dans l'emplacement d'administration EIP1967.
+     */
+    function _setAdmin(address newAdmin) private {
+        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
+        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
+    }
+```
+
+En revanche, le contrat `wARB` a un `contract_owner` codé en dur.
+
+```solidity
+contract WrappedArbitrum is Context, IERC20 {
+    .
+    .
+    .
+    address deployer = 0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1;
+    address public contract_owner = 0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33;
+    .
+    .
+    .
+}
+```
+
+[Ce propriétaire de contrat](https://etherscan.io/address/0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33) n'est pas un contrat qui pourrait être contrôlé par différents comptes à différents moments, mais un [compte externe](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs). Cela signifie qu'il est probablement conçu pour une utilisation à court terme par un individu, plutôt que comme une solution à long terme pour contrôler un ERC-20 qui restera de valeur.
+
+Et en effet, si nous regardons dans Etherscan, nous voyons que l'escroc n'a utilisé ce contrat que pendant 12 heures (de la [première transaction](https://etherscan.io/tx/0xf49136198c3f925fcb401870a669d43cecb537bde36eb8b41df77f06d5f6fbc2) à la [dernière transaction](https://etherscan.io/tx/0xdfd6e717157354e64bbd5d6adf16761e5a5b3f914b1948d3545d39633244d47b)) le 19 mai 2023.
+
+### La fausse fonction `_transfer` {#the-fake-transfer-function}
+
+Il est standard que les transferts réels se produisent en utilisant [une fonction `_transfer` interne](/developers/tutorials/erc20-annotated-code/#the-_transfer-function-_transfer).
+
+Dans `wARB`, cette fonction semble presque légitime :
+
+```solidity
+    function _transfer(address sender, address recipient, uint256 amount)  internal virtual{
+        require(sender != address(0), "ERC20: transfer from the zero address");
+        require(recipient != address(0), "ERC20: transfer to the zero address");
+
+        _beforeTokenTransfer(sender, recipient, amount);
+
+        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+        _balances[recipient] = _balances[recipient].add(amount);
+        if (sender == contract_owner){
+            sender = deployer;
+        }
+        emit Transfer(sender, recipient, amount);
+    }
+```
+
+La partie suspecte est :
+
+```solidity
+        if (sender == contract_owner){
+            sender = deployer;
+        }
+        emit Transfer(sender, recipient, amount);
+```
+
+Si le propriétaire du contrat envoie des jetons, pourquoi l'événement `Transfer` montre-t-il qu'ils proviennent de `deployer` ?
+
+Cependant, il y a un problème plus important. Qui appelle cette fonction `_transfer` ? Elle ne peut pas être appelée de l'extérieur, elle est marquée comme `internal`. Et le code que nous avons n'inclut aucun appel à `_transfer`. Clairement, il est ici comme un leurre.
+
+```solidity
+    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+        _f_(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
+        _f_(sender, recipient, amount);
+        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+        return true;
+    }
+```
+
+Lorsque nous examinons les fonctions qui sont appelées pour transférer des jetons, `transfer` et `transferFrom`, nous voyons qu'elles appellent une fonction complètement différente, `_f_`.
+
+### La vraie fonction `_f_` {#the-real-f-function}
+
+```solidity
+    function _f_(address sender, address recipient, uint256 amount) internal _mod_(sender,recipient,amount) virtual {
+        require(sender != address(0), "ERC20: transfer from the zero address");
+        require(recipient != address(0), "ERC20: transfer to the zero address");
+
+        _beforeTokenTransfer(sender, recipient, amount);
+
+        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+        _balances[recipient] = _balances[recipient].add(amount);
+        if (sender == contract_owner){
+
+            sender = deployer;
+        }
+        emit Transfer(sender, recipient, amount);
+    }
+```
+
+Il y a deux signaux d'alarme potentiels dans cette fonction.
+
+- L'utilisation du [modificateur de fonction](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) `_mod_`. Cependant, quand nous examinons le code source, nous voyons que `_mod_` est en fait inoffensif.
+
+  ```solidity
+  modifier _mod_(address sender, address recipient, uint256 amount){
+    _;
+  }
+  ```
+
+- Le même problème que nous avons vu dans `_transfer`, qui est que lorsque `contract_owner` envoie des jetons, ils semblent provenir de `deployer`.
+
+### La fausse fonction d'événements `dropNewTokens` {#the-fake-events-function-dropNewTokens}
+
+Nous arrivons maintenant à quelque chose qui ressemble à une véritable escroquerie. J'ai un peu modifié la fonction pour la lisibilité, mais elle est fonctionnellement équivalente.
+
+```solidity
+function dropNewTokens(address uPool,
+                       address[] memory eReceiver,
+                       uint256[] memory eAmounts) public auth()
+```
+
+Cette fonction a le modificateur `auth()`, ce qui signifie qu'elle ne peut être appelée que par le propriétaire du contrat.
+
+```solidity
+modifier auth() {
+    require(msg.sender == contract_owner, "Not allowed to interact");
+    _;
+}
+```
+
+Cette restriction est parfaitement logique, car nous ne voudrions pas que des comptes aléatoires distribuent des jetons. Cependant, le reste de la fonction est suspect.
+
+```solidity
+{
+    for (uint256 i = 0; i < eReceiver.length; i++) {
+        emit Transfer(uPool, eReceiver[i], eAmounts[i]);
+    }
+}
+```
+
+Une fonction pour transférer depuis un compte de pool vers un tableau de récepteurs un tableau de montants est parfaitement logique. Il existe de nombreux cas d'utilisation dans lesquels vous voudrez distribuer des jetons d'une source unique à plusieurs destinations, comme les paies, les airdrops, etc. Il est moins cher (en gaz) de le faire en une seule transaction plutôt que d'émettre plusieurs transactions, ou même d'appeler l'ERC-20 plusieurs fois à partir d'un contrat différent dans le cadre de la même transaction.
+
+Cependant, `dropNewTokens` ne fait pas cela. Il émet des [événements `Transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer-1), mais ne transfère en réalité aucun jeton. Il n'y a aucune raison légitime de semer la confusion dans les applications hors chaîne en leur parlant d'un transfert qui n'a pas vraiment eu lieu.
+
+### La fonction `Approve` de burn {#the-burning-approve-function}
+
+Les contrats ERC-20 sont censés avoir [une fonction `approve`](/developers/tutorials/erc20-annotated-code/#approve) pour les allocations, et en effet notre jeton frauduleux a une telle fonction, et elle est même correcte. Cependant, comme Solidity est un dérivé du C, il est sensible à la casse. "Approve" et "approve" sont des chaînes de caractères différentes.
+
+De plus, la fonctionnalité n'est pas liée à `approve`.
+
+```solidity
+    function Approve(
+        address[] memory holders)
+```
+
+Cette fonction est appelée avec un tableau d'adresses pour les détenteurs du jeton.
+
+```solidity
+    public approver() {
+```
+
+Le modificateur `approver()` s'assure que seul `contract_owner` est autorisé à appeler cette fonction (voir ci-dessous).
+
+```solidity
+        for (uint256 i = 0; i < holders.length; i++) {
+            uint256 amount = _balances[holders[i]];
+            _beforeTokenTransfer(holders[i], 0x0000000000000000000000000000000000000001, amount);
+            _balances[holders[i]] = _balances[holders[i]].sub(amount,
+                "ERC20: burn amount exceeds balance");
+            _balances[0x0000000000000000000000000000000000000001] =
+                _balances[0x0000000000000000000000000000000000000001].add(amount);
+        }
+    }
+
+```
+
+Pour chaque adresse de détenteur, la fonction déplace l'intégralité du solde du détenteur vers l'adresse `0x00...01`, le brûlant (« burn ») de fait (le `burn` réel dans la norme modifie également l'offre totale, et transfère les jetons vers `0x00...00`). Cela signifie que `contract_owner` peut supprimer les actifs de n'importe quel utilisateur. Cela ne semble pas être une fonctionnalité que vous voudriez dans un jeton de gouvernance.
+
+### Problèmes de qualité du code {#code-quality-issues}
+
+Ces problèmes de qualité du code ne _prouvent_ pas que ce code est une escroquerie, mais ils le font paraître suspect. Les entreprises organisées telles qu'Arbitrum ne publient généralement pas de code d'aussi mauvaise qualité.
+
+#### La fonction `mount` {#the-mount-function}
+
+Bien que cela ne soit pas spécifié dans [la norme](https://eips.ethereum.org/EIPS/eip-20), de manière générale, la fonction qui crée de nouveaux jetons est appelée [`mint`](https://ethereum.org/el/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn).
+
+Si nous regardons dans le constructeur de `wARB`, nous voyons que la fonction de frappe a été renommée en `mount` pour une raison quelconque, et est appelée cinq fois avec un cinquième de l'offre initiale, au lieu d'une seule fois pour le montant total par souci d'efficacité.
+
+```solidity
+    constructor () public {
+
+        _name = "Wrapped Arbitrum";
+        _symbol = "wARB";
+        _decimals = 18;
+        uint256 initialSupply = 1000000000000;
+
+        mount(deployer, initialSupply*(10**18)/5);
+        mount(deployer, initialSupply*(10**18)/5);
+        mount(deployer, initialSupply*(10**18)/5);
+        mount(deployer, initialSupply*(10**18)/5);
+        mount(deployer, initialSupply*(10**18)/5);
+    }
+```
+
+La fonction `mount` elle-même est également suspecte.
+
+```solidity
+    function mount(address account, uint256 amount) public {
+        require(msg.sender == contract_owner, "ERC20: mint to the zero address");
+```
+
+En regardant le `require`, nous voyons que seul le propriétaire du contrat est autorisé à frapper. C'est légitime. Mais le message d'erreur devrait être _seul le propriétaire est autorisé à frapper_ ou quelque chose comme ça. Au lieu de cela, c'est l'inapproprié _ERC20: mint to the zero address_. Le test correct pour la frappe vers l'adresse nulle est `require(account != address(0), "<message d'erreur>")`, que le contrat ne prend jamais la peine de vérifier.
+
+```solidity
+        _totalSupply = _totalSupply.add(amount);
+        _balances[contract_owner] = _balances[contract_owner].add(amount);
+        emit Transfer(address(0), account, amount);
+    }
+```
+
+Il y a deux autres faits suspects, directement liés à la frappe :
+
+- Il y a un paramètre `account`, qui est vraisemblablement le compte qui devrait recevoir le montant frappé. Mais le solde qui augmente est en fait celui de `contract_owner`.
+
+- Alors que le solde augmenté appartient à `contract_owner`, l'événement émis montre un transfert vers `account`.
+
+### Pourquoi `auth` et `approver` à la fois ? Pourquoi le `mod` qui ne fait rien ? {#why-both-autho-and-approver-why-the-mod-that-does-nothing}
+
+Ce contrat contient trois modificateurs : `_mod_`, `auth`, et `approver`.
+
+```solidity
+    modifier _mod_(address sender, address recipient, uint256 amount){
+        _;
+    }
+```
+
+`_mod_` prend trois paramètres et n'en fait rien. Pourquoi l'avoir ?
+
+```solidity
+    modifier auth() {
+        require(msg.sender == contract_owner, "Not allowed to interact");
+        _;
+    }
+
+    modifier approver() {
+        require(msg.sender == contract_owner, "Not allowed to interact");
+        _;
+    }
+```
+
+`auth` et `approver` sont plus logiques, car ils vérifient que le contrat a été appelé par `contract_owner`. Nous nous attendrions à ce que certaines actions privilégiées, comme la frappe, soient limitées à ce compte. Cependant, quel est l'intérêt d'avoir deux fonctions distinctes qui font _précisément la même chose_ ?
+
+## Que pouvons-nous détecter automatiquement ? {#what-can-we-detect-automatically}
+
+Nous pouvons voir que `wARB` est un jeton frauduleux en regardant sur Etherscan. Cependant, c'est une solution centralisée. En théorie, Etherscan pourrait être subverti ou piraté. Il est préférable de pouvoir déterminer indépendamment si un jeton est légitime ou non.
+
+Il y a quelques astuces que nous pouvons utiliser pour identifier qu'un jeton ERC-20 est suspect (soit une escroquerie, soit très mal écrit), en regardant les événements qu'il émet.
+
+## Événements `Approval` suspects {#suspicious-approval-events}
+
+Les [événements `Approval`](https://eips.ethereum.org/EIPS/eip-20#approval) ne devraient se produire qu'avec une demande directe (contrairement aux [événements `Transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer-1) qui peuvent se produire à la suite d'une allocation). [Consultez la documentation de Solidity](https://docs.soliditylang.org/en/v0.8.20/security-considerations.html#tx-origin) pour une explication détaillée de ce problème et pourquoi les requêtes doivent être directes, plutôt que médiatisées par un contrat.
+
+Cela signifie que les événements `Approval` qui approuvent les dépenses d'un [compte externe](/developers/docs/accounts/#types-of-account) doivent provenir de transactions qui proviennent de ce compte, et dont la destination est le contrat ERC-20. Toute autre type d'approbation d'un compte externe est suspect.
+
+Voici [un programme qui identifie ce type d'événement](https://github.com/qbzzt/20230915-scam-token-detection), utilisant [viem](https://viem.sh/) et [TypeScript](https://www.typescriptlang.org/docs/), une variante de JavaScript avec une sécurité de type. Pour l'exécuter :
+
+1. Copiez `.env.example` dans `.env`.
+2. Modifiez `.env` pour fournir l'URL d'un nœud du réseau principal Ethereum.
+3. Exécutez `pnpm install` pour installer les paquets nécessaires.
+4. Exécutez `pnpm susApproval` pour rechercher les approbations suspectes.
+
+Voici une explication ligne par ligne :
+
+```typescript
+import {
+  Address,
+  TransactionReceipt,
+  createPublicClient,
+  http,
+  parseAbiItem,
+} from "viem"
+import { mainnet } from "viem/chains"
+```
+
+Importez les définitions de type, les fonctions, et la définition de la chaîne depuis `viem`.
+
+```typescript
+import { config } from "dotenv"
+config()
+```
+
+Lisez `.env` pour obtenir l'URL.
+
+```typescript
+const client = createPublicClient({
+  chain: mainnet,
+  transport: http(process.env.URL),
+})
+```
+
+Créez un client Viem. Nous n'avons besoin que de lire à partir de la blockchain, donc ce client n'a pas besoin d'une clé privée.
+
+```typescript
+const testedAddress = "0xb047c8032b99841713b8e3872f06cf32beb27b82"
+const fromBlock = 16859812n
+const toBlock = 16873372n
+```
+
+L'adresse du contrat ERC-20 suspect, et les blocs dans lesquels nous chercherons des événements. Les fournisseurs de nœuds limitent généralement notre capacité à lire les événements car la bande passante peut devenir coûteuse. Heureusement, `wARB` n'a pas été utilisé pendant une période de dix-huit heures, nous pouvons donc rechercher tous les événements (il n'y en avait que 13 au total).
+
+```typescript
+const approvalEvents = await client.getLogs({
+  address: testedAddress,
+  fromBlock,
+  toBlock,
+  event: parseAbiItem(
+    "event Approval(address indexed _owner, address indexed _spender, uint256 _value)"
+  ),
+})
+```
+
+C'est la façon de demander à Viem des informations sur les événements. Lorsque nous lui fournissons la signature exacte de l'événement, y compris les noms de champs, il analyse l'événement pour nous.
+
+```typescript
+const isContract = async (addr: Address): boolean =>
+  await client.getBytecode({ address: addr })
+```
+
+Notre algorithme ne s'applique qu'aux comptes externes. Si un bytecode est retourné par `client.getBytecode`, cela signifie qu'il s'agit d'un contrat et que nous devrions simplement l'ignorer.
+
+Si vous n'avez jamais utilisé TypeScript auparavant, la définition de la fonction peut sembler un peu bizarre. Nous ne lui disons pas seulement que le premier (et unique) paramètre s'appelle `addr`, mais aussi qu'il est de type `Address`. De même, la partie `: boolean` indique à TypeScript que la valeur de retour de la fonction est un booléen.
+
+```typescript
+const getEventTxn = async (ev: Event): TransactionReceipt =>
+  await client.getTransactionReceipt({ hash: ev.transactionHash })
+```
+
+Cette fonction obtient le reçu de transaction d'un événement. Nous avons besoin du reçu pour nous assurer que nous connaissons la destination de la transaction.
+
+```typescript
+const suspiciousApprovalEvent = async (ev : Event) : (Event | null) => {
+```
+
+C'est la fonction la plus importante, celle qui décide réellement si un événement est suspect ou non. Le type de retour, `(Event | null)`, indique à TypeScript que cette fonction peut retourner soit un `Event`, soit `null`. Nous retournons `null` si l'événement n'est pas suspect.
+
+```typescript
+const owner = ev.args._owner
+```
+
+Viem a les noms de champs, il a donc analysé l'événement pour nous. `_owner` est le propriétaire des jetons à dépenser.
+
+```typescript
+// Les approbations par les contrats ne sont pas suspectes
+if (await isContract(owner)) return null
+```
+
+Si le propriétaire est un contrat, supposez que cette approbation n'est pas suspecte. Pour vérifier si l'approbation d'un contrat est suspecte ou non, nous devrons tracer l'exécution complète de la transaction pour voir si elle a atteint le contrat propriétaire, et si ce contrat a appelé directement le contrat ERC-20. C'est beaucoup plus coûteux en ressources que ce que nous aimerions faire.
+
+```typescript
+const txn = await getEventTxn(ev)
+```
+
+Si l'approbation provient d'un compte externe, obtenez la transaction qui l'a causée.
+
+```typescript
+// L'approbation est suspecte si elle provient d'un propriétaire EOA qui n'est pas le `from` de la transaction
+if (owner.toLowerCase() != txn.from.toLowerCase()) return ev
+```
+
+Nous ne pouvons pas simplement vérifier l'égalité des chaînes de caractères car les adresses sont hexadécimales, donc elles contiennent des lettres. Parfois, par exemple dans `txn.from`, ces lettres sont toutes en minuscules. Dans d'autres cas, comme `ev.args._owner`, l'adresse est en [casse mixte pour l'identification d'erreurs](https://eips.ethereum.org/EIPS/eip-55).
+
+Mais si la transaction ne provient pas du propriétaire, et que ce propriétaire est détenu par un externe, alors nous avons une transaction suspecte.
+
+```typescript
+// C'est aussi suspect si la destination de la transaction n'est pas le contrat ERC-20 que nous
+// examinons
+if (txn.to.toLowerCase() != testedAddress) return ev
+```
+
+De même, si l'adresse `to` de la transaction, le premier contrat appelé, n'est pas le contrat ERC-20 sous investigation, alors c'est suspect.
+
+```typescript
+    // S'il n'y a aucune raison d'être suspect, retourner null.
+    return null
+}
+```
+
+Si aucune des deux conditions n'est vraie, alors l'événement `Approval` n'est pas suspect.
+
+```typescript
+const testPromises = approvalEvents.map((ev) => suspiciousApprovalEvent(ev))
+const testResults = (await Promise.all(testPromises)).filter((x) => x != null)
+
+console.log(testResults)
+```
+
+[Une fonction `async`](https://www.w3schools.com/js/js_async.asp) retourne un objet `Promise`. Avec la syntaxe courante, `await x()`, nous attendons que cette `Promise` soit remplie avant de continuer le traitement. C'est simple à programmer et à suivre, mais c'est aussi inefficace. Pendant que nous attendons que la `Promise` d'un événement spécifique soit remplie, nous pouvons déjà commencer à travailler sur l'événement suivant.
+
+Ici, nous utilisons [`map`](https://www.w3schools.com/jsref/jsref_map.asp) pour créer un tableau d'objets `Promise`. Ensuite, nous utilisons [`Promise.all`](https://www.javascripttutorial.net/es6/javascript-promise-all/) pour attendre que toutes ces promesses soient résolues. Nous [`filtrons`](https://www.w3schools.com/jsref/jsref_filter.asp) ensuite ces résultats pour supprimer les événements non suspects.
+
+### Événements `Transfer` suspects {#suspicious-transfer-events}
+
+Une autre façon possible d'identifier les jetons frauduleux est de voir s'ils ont des transferts suspects. Par exemple, les transferts provenant de comptes qui n'ont pas autant de jetons. Vous pouvez voir [comment implémenter ce test](https://github.com/qbzzt/20230915-scam-token-detection/blob/main/susTransfer.ts), mais `wARB` n'a pas ce problème.
+
+## Conclusion {#conclusion}
+
+La détection automatisée des escroqueries ERC-20 souffre de [faux négatifs](https://en.wikipedia.org/wiki/False_positives_and_false_negatives#False_negative_error), car une escroquerie peut utiliser un contrat de jeton ERC-20 parfaitement normal qui ne représente simplement rien de réel. Vous devriez donc toujours essayer d'_obtenir l'adresse du jeton d'une source de confiance_.
+
+La détection automatisée peut aider dans certains cas, comme pour les éléments de la DeFi, où il y a de nombreux jetons qui doivent être gérés automatiquement. Mais comme toujours [caveat emptor](https://www.investopedia.com/terms/c/caveatemptor.asp), faites vos propres recherches, et encouragez vos utilisateurs à faire de même.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/secret-state/index.md b/public/content/translations/fr/developers/tutorials/secret-state/index.md
new file mode 100644
index 00000000000..ac12823930c
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/secret-state/index.md
@@ -0,0 +1,741 @@
+---
+title: "Utiliser la preuve à divulgation nulle de connaissance pour un état secret"
+description: "les jeux en chaîne sont limités car ils ne peuvent pas conserver d'informations cachées. Après avoir lu ce tutoriel, un lecteur sera en mesure de combiner des preuves à divulgation nulle de connaissance et des composants de serveur pour créer des jeux vérifiables avec un état secret, hors chaîne, composant. La technique pour ce faire sera démontrée en créant un jeu de démineur."
+author: Ori Pomerantz
+tags:
+  [
+    "serveur",
+    "hors-chaîne",
+    "centralisé",
+    "preuve à divulgation nulle de connaissance",
+    "zokrates",
+    "mud"
+  ]
+skill: advanced
+lang: fr
+published: 2025-03-15
+---
+
+_Il n'y a pas de secret sur la blockchain_. Tout ce qui est publié sur la blockchain est ouvert à la lecture de tous. C'est nécessaire, car la blockchain est basée sur le fait que tout le monde peut la vérifier. Cependant, les jeux reposent souvent sur un état secret. Par exemple, le jeu du [démineur](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) n'a absolument aucun sens si vous pouvez simplement aller sur un explorateur de blockchain et voir la carte.
+
+La solution la plus simple est d'utiliser un [composant serveur](/developers/tutorials/server-components/) pour contenir l'état secret. Cependant, la raison pour laquelle nous utilisons la blockchain est d'empêcher la triche par le développeur du jeu. Nous devons garantir l'honnêteté du composant serveur. Le serveur peut fournir un hachage de l'état, et utiliser des [preuves à divulgation nulle de connaissance](/zero-knowledge-proofs/#why-zero-knowledge-proofs-are-important) pour prouver que l'état utilisé pour calculer le résultat d'un mouvement est le bon.
+
+Après avoir lu cet article, vous saurez comment créer ce type de serveur de maintien d'état secret, un client pour montrer l'état, et un composant en chaîne pour la communication entre les deux. Les principaux outils que nous utiliserons seront :
+
+| Outil                                         | Objectif                                                         |                  Vérifié sur la version |
+| --------------------------------------------- | ---------------------------------------------------------------- | --------------------------------------: |
+| [Zokrates](https://zokrates.github.io/)       | Preuves à divulgation nulle de connaissance et leur vérification |   1.1.9 |
+| [Typescript](https://www.typescriptlang.org/) | Langage de programmation pour le serveur et le client            |   5.4.2 |
+| [Node](https://nodejs.org/en)                 | Exécution du serveur                                             | 20.18.2 |
+| [Viem](https://viem.sh/)                      | Communication avec la Blockchain                                 |  2.9.20 |
+| [MUD](https://mud.dev/)                       | Gestion des données en chaîne                                    |  2.0.12 |
+| [React](https://react.dev/)                   | Interface utilisateur du client                                  |  18.2.0 |
+| [Vite](https://vitejs.dev/)                   | Servir le code client                                            |   4.2.1 |
+
+## Exemple de démineur {#minesweeper}
+
+Le [démineur](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) est un jeu qui comprend une carte secrète avec un champ de mines. Le joueur choisit de creuser à un endroit précis. Si cet emplacement contient une mine, la partie est terminée. Sinon, le joueur obtient le nombre de mines dans les huit cases environnantes.
+
+Cette application est écrite en utilisant [MUD](https://mud.dev/), un framework qui nous permet de stocker des données en chaîne en utilisant une [base de données clé-valeur](https://aws.amazon.com/nosql/key-value/) et de synchroniser ces données automatiquement avec des composants hors chaîne. En plus de la synchronisation, MUD facilite le contrôle d'accès et permet aux autres utilisateurs d'[étendre](https://mud.dev/guides/extending-a-world) notre application sans permission.
+
+### Exécuter l'exemple du démineur {#running-minesweeper-example}
+
+Pour exécuter l'exemple du démineur :
+
+1. Assurez-vous d'[avoir installé les prérequis](https://mud.dev/quickstart#prerequisites) : [Node](https://mud.dev/quickstart#prerequisites), [Foundry](https://book.getfoundry.sh/getting-started/installation), [`git`](https://git-scm.com/downloads), [`pnpm`](https://git-scm.com/downloads), et [`mprocs`](https://github.com/pvolok/mprocs).
+
+2. Cloner le dépôt.
+
+   ```sh copy
+   git clone https://github.com/qbzzt/20240901-secret-state.git
+   ```
+
+3. Installez les paquets.
+
+   ```sh copy
+   cd 20240901-secret-state/
+   pnpm install
+   npm install -g mprocs
+   ```
+
+   Si Foundry a été installé dans le cadre de `pnpm install`, vous devez redémarrer le shell de ligne de commande.
+
+4. Compiler les contrats
+
+    ```sh copy
+    cd packages/contracts
+    forge build
+    cd ../..
+    ```
+
+5. Démarrez le programme (y compris une blockchain [anvil](https://book.getfoundry.sh/anvil/)) et attendez.
+
+   ```sh copy
+   mprocs
+   ```
+
+   Notez que le démarrage prend beaucoup de temps. Pour voir la progression, utilisez d'abord la flèche vers le bas pour faire défiler jusqu'à l'onglet _contracts_ pour voir les contrats MUD en cours de déploiement. Lorsque vous recevez le message _Waiting for file changes…_, les contrats sont déployés et la suite de la progression se déroulera dans l'onglet _server_. Là, vous attendez de recevoir le message _Verifier address: 0x...._.
+
+   Si cette étape est réussie, vous verrez l'écran `mprocs`, avec les différents processus à gauche et la sortie de la console pour le processus actuellement sélectionné à droite.
+
+   ![L'écran mprocs](./mprocs.png)
+
+   En cas de problème avec `mprocs`, vous pouvez exécuter les quatre processus manuellement, chacun dans sa propre fenêtre de ligne de commande :
+
+   - **Anvil**
+
+     ```sh
+     cd packages/contracts
+     anvil --base-fee 0 --block-time 2
+     ```
+
+   - **Contrats**
+
+     ```sh
+     cd packages/contracts
+     pnpm mud dev-contracts --rpc http://127.0.0.1:8545
+     ```
+
+   - **Serveur**
+
+     ```sh
+     cd packages/server
+     pnpm start
+     ```
+
+   - **Client**
+
+     ```sh
+     cd packages/client
+     pnpm run dev
+     ```
+
+6. Vous pouvez maintenant naviguer vers [le client](http://localhost:3000), cliquer sur **New Game** et commencer à jouer.
+
+### Tables {#tables}
+
+Nous avons besoin de [plusieurs tables](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts) en chaîne.
+
+- `Configuration` : cette table est un singleton, elle n'a pas de clé et un seul enregistrement. Elle est utilisée pour contenir les informations de configuration du jeu :
+  - `height` : la hauteur d'un champ de mines
+  - `width` : la largeur d'un champ de mines
+  - `numberOfBombs` : le nombre de bombes dans chaque champ de mines
+
+- `VerifierAddress`: cette table est également un singleton. Elle est utilisée pour contenir une partie de la configuration, l'adresse du contrat de vérification (`verifier`). Nous aurions pu mettre cette information dans la table `Configuration`, mais elle est définie par un composant différent, le serveur, il est donc plus facile de la mettre dans une table séparée.
+
+- `PlayerGame` : la clé est l'adresse du joueur. Les données sont :
+
+  - `gameId` : valeur de 32 octets qui est le hachage de la carte sur laquelle le joueur joue (l'identifiant du jeu).
+  - `win` : un booléen indiquant si le joueur a gagné la partie.
+  - `lose` : un booléen indiquant si le joueur a perdu la partie.
+  - `digNumber` : le nombre de creusements réussis dans le jeu.
+
+- `GamePlayer` : cette table contient le mappage inverse, de `gameId` à l'adresse du joueur.
+
+- `Map` : la clé est un tuple de trois valeurs :
+
+  - `gameId` : valeur de 32 octets qui est le hachage de la carte sur laquelle le joueur joue (l'identifiant du jeu).
+  - Coordonnée `x`
+  - Coordonnée `y`
+
+  La valeur est un nombre unique. C'est 255 si une bombe a été détectée. Sinon, c'est le nombre de bombes autour de cet emplacement plus un. Nous ne pouvons pas simplement utiliser le nombre de bombes, car par défaut, tout le stockage dans l'EVM et toutes les valeurs de lignes dans MUD sont à zéro. Nous devons faire la distinction entre « le joueur n'a pas encore creusé ici » et « le joueur a creusé ici, et a trouvé qu'il n'y avait aucune bombe aux alentours ».
+
+De plus, la communication entre le client et le serveur se fait via le composant en chaîne. Ceci est également implémenté en utilisant des tables.
+
+- `PendingGame`: demandes non traitées pour démarrer une nouvelle partie.
+- `PendingDig`: demandes non traitées pour creuser à un endroit spécifique dans un jeu spécifique. Il s'agit d'une [table hors chaîne](https://mud.dev/store/tables#types-of-tables), ce qui signifie qu'elle n'est pas écrite dans le stockage EVM, elle n'est lisible qu'en dehors de la chaîne en utilisant des événements.
+
+### Flux d'exécution et de données {#execution-data-flows}
+
+Ces flux coordonnent l'exécution entre le client, le composant en chaîne et le serveur.
+
+#### Initialisation {#initialization-flow}
+
+Lorsque vous exécutez `mprocs`, ces étapes se produisent :
+
+1. [`mprocs`](https://github.com/pvolok/mprocs) exécute quatre composants :
+
+   - [Anvil](https://book.getfoundry.sh/anvil/), qui exécute une blockchain locale
+   - [Contracts](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/contracts), qui compile (si nécessaire) et déploie les contrats pour MUD
+   - [Client](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/client), qui exécute [Vite](https://vitejs.dev/) pour servir l'interface utilisateur et le code client aux navigateurs Web.
+   - [Serveur](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/server), qui effectue les actions du serveur
+
+2. Le paquet `contracts` déploie les contrats MUD puis exécute [le script `PostDeploy.s.sol`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol). Ce script définit la configuration. Le code de github spécifie [un champ de mines de 10x5 avec huit mines](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol#L23).
+
+3. [Le serveur](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts) commence par [configurer MUD](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L6). Entre autres, cela active la synchronisation des données, de sorte qu'une copie des tables pertinentes existe dans la mémoire du serveur.
+
+4. Le serveur abonne une fonction à exécuter [lorsque la table `Configuration` change](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L23). [Cette fonction](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L24-L168) est appelée après l'exécution de `PostDeploy.s.sol` et la modification de la table.
+
+5. Lorsque la fonction d'initialisation du serveur dispose de la configuration, [elle appelle `zkFunctions`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L34-L35) pour initialiser [la partie preuve à divulgation nulle de connaissance du serveur](#using-zokrates-from-typescript). Cela ne peut pas se produire tant que nous n'avons pas la configuration, car les fonctions de preuve à divulgation nulle de connaissance doivent avoir la largeur et la hauteur du champ de mines comme constantes.
+
+6. Une fois que la partie preuve à divulgation nulle de connaissance du serveur est initialisée, l'étape suivante consiste à [déployer le contrat de vérification de la preuve à divulgation nulle de connaissance sur la blockchain](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L42-L53) et à définir l'adresse du vérifié dans MUD.
+
+7. Enfin, nous nous abonnons aux mises à jour pour savoir quand un joueur demande soit [de commencer une nouvelle partie](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71) soit de [creuser dans une partie existante](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73-L108).
+
+#### Nouvelle partie {#new-game-flow}
+
+Voici ce qui se passe lorsque le joueur demande une nouvelle partie.
+
+1. S'il n'y a pas de partie en cours pour ce joueur, ou s'il y en a une mais avec un gameId à zéro, le client affiche un [bouton nouvelle partie](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175). Lorsque l'utilisateur appuie sur ce bouton, [React exécute la fonction `newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L96).
+
+2. [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L43-L46) est un appel `System`. Dans MUD, tous les appels sont acheminés via le contrat `World`, et dans la plupart des cas, vous appelez `<namespace>__<function name>`. Dans ce cas, l'appel est à `app__newGame`, que MUD achemine ensuite vers [`newGame` dans `GameSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L16-L22).
+
+3. La fonction en chaîne vérifie que le joueur n'a pas de partie en cours, et s'il n'y en a pas, [ajoute la demande à la table `PendingGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L21).
+
+4. Le serveur détecte le changement dans `PendingGame` et [exécute la fonction abonnée](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71). Cette fonction appelle [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L110-L114), qui à son tour appelle [`createGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L116-L144).
+
+5. La première chose que `createGame` fait est de [créer une carte aléatoire avec le nombre de mines approprié](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L120-L135). Ensuite, elle appelle [`makeMapBorders`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L147-L166) pour créer une carte avec des bordures vides, ce qui est nécessaire pour Zokrates. Enfin, `createGame` appelle [`calculateMapHash`](#calculateMapHash), pour obtenir le hachage de la carte, qui est utilisé comme ID de jeu.
+
+6. La fonction `newGame` ajoute la nouvelle partie à `gamesInProgress`.
+
+7. La dernière chose que fait le serveur est d'appeler [`app__newGameResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L38-L43), qui est en chaîne. Cette fonction se trouve dans un `System` différent, [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol), pour permettre le contrôle d'accès. Le contrôle d'accès est défini dans le [fichier de configuration MUD](https://mud.dev/config), [`mud.config.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts#L67-L72).
+
+   La liste d'accès n'autorise qu'une seule adresse à appeler le `System`. Cela restreint l'accès aux fonctions du serveur à une seule adresse, afin que personne ne puisse se faire passer pour le serveur.
+
+8. Le composant en chaîne met à jour les tables pertinentes :
+
+   - Créer la partie dans `PlayerGame`.
+   - Définir le mappage inverse dans `GamePlayer`.
+   - Supprimer la demande de `PendingGame`.
+
+9. Le serveur identifie le changement dans `PendingGame`, mais ne fait rien car [`wantsGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L58-L60) est faux.
+
+10. Sur le client, [`gameRecord`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L143-L148) est défini sur l'entrée `PlayerGame` pour l'adresse du joueur. Lorsque `PlayerGame` change, `gameRecord` change aussi.
+
+11. S'il y a une valeur dans `gameRecord`, et que la partie n'a été ni gagnée ni perdue, le client [affiche la carte](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190).
+
+#### Creuser {#dig-flow}
+
+1. Le joueur [clique sur le bouton de la cellule de la carte](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L188), ce qui appelle [la fonction `dig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L33-L36). Cette fonction appelle [`dig` en chaîne](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L24-L32).
+
+2. Le composant en chaîne [effectue un certain nombre de vérifications de cohérence](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L25-L30), et en cas de succès, ajoute la demande de creusage à [`PendingDig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L31).
+
+3. Le serveur [détecte le changement dans `PendingDig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73). [Si elle est valide](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L75-L84), il [appelle le code de preuve à divulgation nulle de connaissance](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L86-L95) (expliqué ci-dessous) pour générer à la fois le résultat et une preuve de sa validité.
+
+4. [Le serveur](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L97-L107) appelle [`digResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L45-L64) en chaîne.
+
+5. `digResponse` fait deux choses. Tout d'abord, il vérifie [la preuve à divulgation nulle de connaissance](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L47-L61). Ensuite, si la preuve est valide, il appelle [`processDigResult`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L67-L86) pour traiter réellement le résultat.
+
+6. `processDigResult` vérifie si la partie a été [perdue](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L76-L78) ou [gagnée](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L83-L86), et [met à jour `Map`, la carte en chaîne](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L80).
+
+7. Le client récupère automatiquement les mises à jour et [met à jour la carte affichée au joueur](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190), et le cas échéant, informe le joueur s'il s'agit d'une victoire ou d'une défaite.
+
+## Utiliser Zokrates {#using-zokrates}
+
+Dans les flux expliqués ci-dessus, nous avons ignoré les parties concernant la preuve à divulgation nulle de connaissance, en les traitant comme une boîte noire. Maintenant, ouvrons-la et voyons comment ce code est écrit.
+
+### Hachage de la carte {#hashing-map}
+
+Nous pouvons utiliser [ce code JavaScript](https://github.com/ZK-Plus/ICBC24_Tutorial_Compute-Offchain-Verify-onchain/tree/solutions/exercise) pour implémenter [Poseidon](https://www.poseidon-hash.info), la fonction de hachage Zokrates que nous utilisons. Cependant, bien que cela serait plus rapide, ce serait aussi plus compliqué que de simplement utiliser la fonction de hachage Zokrates pour le faire. Ceci est un tutoriel, et le code est donc optimisé pour la simplicité, non pour la performance. Par conséquent, nous avons besoin de deux programmes Zokrates différents, un pour calculer simplement le hachage d'une carte (`hash`) et un pour créer réellement une preuve à divulgation nulle de connaissance du résultat du creusement à un emplacement sur la carte (`dig`).
+
+### La fonction de hachage {#hash-function}
+
+C'est la fonction qui calcule le hachage d'une carte. Nous allons parcourir ce code ligne par ligne.
+
+```
+import "hashes/poseidon/poseidon.zok" as poseidon;
+import "utils/pack/bool/pack128.zok" as pack128;
+```
+
+Ces deux lignes importent deux fonctions de la [bibliothèque standard de Zokrates](https://zokrates.github.io/toolbox/stdlib.html). [La première fonction](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/hashes/poseidon/poseidon.zok) est un [hachage Poseidon](https://www.poseidon-hash.info/). Elle prend un tableau d'éléments [`field`](https://zokrates.github.io/language/types.html#field) et renvoie un `field`.
+
+L'élément field dans Zokrates est généralement inférieur à 256 bits, mais pas de beaucoup. Pour simplifier le code, nous limitons la carte à 512 bits et nous hachons un tableau de quatre champs, et dans chaque champ, nous n'utilisons que 128 bits. La fonction [`pack128`](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok) transforme un tableau de 128 bits en un `field` à cet effet.
+
+```
+        def hashMap(bool[${width+2}][${height+2}] map) -> field {
+```
+
+Cette ligne commence une définition de fonction. `hashMap` reçoit un seul paramètre appelé `map`, un tableau `bool`(éen) à deux dimensions. La taille de la carte est de `width+2` par `height+2` pour des raisons qui sont [expliquées ci-dessous](#why-map-border).
+
+Nous pouvons utiliser `${width+2}` et `${height+2}` car les programmes Zokrates sont stockés dans cette application sous forme de [modèles de chaînes de caractères](https://www.w3schools.com/js/js_string_templates.asp). Le code entre `${` et `}` est évalué par JavaScript, et de cette manière, le programme peut être utilisé pour différentes tailles de carte. Le paramètre map a une bordure d'un emplacement de large tout autour sans aucune bombe, c'est la raison pour laquelle nous devons ajouter deux à la largeur et à la hauteur.
+
+La valeur de retour est un `field` qui contient le hachage.
+
+```
+   bool[512] mut map1d = [false; 512];
+```
+
+La carte est bidimensionnelle. Cependant, la fonction `pack128` ne fonctionne pas avec des tableaux bidimensionnels. Nous aplatissons donc d'abord la carte en un tableau de 512 octets, en utilisant `map1d`. Par défaut, les variables Zokrates sont des constantes, mais nous devons assigner des valeurs à ce tableau dans une boucle, nous le définissons donc comme [`mut`](https://zokrates.github.io/language/variables.html#mutability).
+
+Nous devons initialiser le tableau car Zokrates n'a pas de `undefined`. L'expression `[false; 512]` signifie [un tableau de 512 valeurs `false`](https://zokrates.github.io/language/types.html#declaration-and-initialization).
+
+```
+   u32 mut counter = 0;
+```
+
+Nous avons également besoin d'un compteur pour distinguer les bits que nous avons déjà remplis dans `map1d` de ceux que nous n'avons pas encore remplis.
+
+```
+   for u32 x in 0..${width+2} {
+```
+
+Voici comment déclarer une boucle [`for`](https://zokrates.github.io/language/control_flow.html#for-loops) en Zokrates. Une boucle `for` de Zokrates doit avoir des limites fixes, car bien qu'elle semble être une boucle, le compilateur la « déroule » en réalité. L'expression `${width+2}` est une constante de temps de compilation car `width` est définie par le code TypeScript avant d'appeler le compilateur.
+
+```
+      for u32 y in 0..${height+2} {
+         map1d[counter] = map[x][y];
+         counter = counter+1;
+      }
+   }
+```
+
+Pour chaque emplacement de la carte, mettez cette valeur dans le tableau `map1d` et incrémentez le compteur.
+
+```
+    field[4] hashMe = [
+        pack128(map1d[0..128]),
+        pack128(map1d[128..256]),
+        pack128(map1d[256..384]),
+        pack128(map1d[384..512])
+    ];
+```
+
+Le `pack128` pour créer un tableau de quatre valeurs `field` à partir de `map1d`. En Zokrates, `array[a..b]` signifie la tranche du tableau qui commence à `a` et se termine à `b-1`.
+
+```
+    return poseidon(hashMe);
+}
+```
+
+Utilisez `poseidon` pour convertir ce tableau en un hachage.
+
+### Le programme de hachage {#hash-program}
+
+Le serveur doit appeler `hashMap` directement pour créer des identifiants de jeu. Cependant, Zokrates ne peut appeler que la fonction `main` d'un programme pour démarrer, nous créons donc un programme avec une fonction `main` qui appelle la fonction de hachage.
+
+```
+${hashFragment}
+
+def main(bool[${width+2}][${height+2}] map) -> field {
+    return hashMap(map);
+}
+```
+
+### Le programme de creusage {#dig-program}
+
+C'est le cœur de la partie preuve à divulgation nulle de connaissance de l'application, où nous produisons les preuves qui sont utilisées pour vérifier les résultats des creusages.
+
+```
+${hashFragment}
+
+// Le nombre de mines à l'emplacement (x,y)
+def map2mineCount(bool[${width+2}][${height+2}] map, u32 x, u32 y) -> u8 {
+   return if map[x+1][y+1] { 1 } else { 0 };
+}
+```
+
+#### Pourquoi une bordure de carte {#why-map-border}
+
+Les preuves à divulgation nulle de connaissance utilisent des [circuits arithmétiques](https://medium.com/web3studio/simple-explanations-of-arithmetic-circuits-and-zero-knowledge-proofs-806e59a79785), qui n'ont pas d'équivalent facile à une instruction `if`. Au lieu de cela, ils utilisent l'équivalent de l'[opérateur conditionnel](https://en.wikipedia.org/wiki/Ternary_conditional_operator). Si `a` peut être soit zéro soit un, vous pouvez calculer `if a { b } else { c }` comme `ab+(1-a)c`.
+
+Pour cette raison, une instruction `if` de Zokrates évalue toujours les deux branches. Par exemple, si vous avez ce code :
+
+```
+bool[5] arr = [false; 5];
+u32 index=10;
+return if index>4 { 0 } else { arr[index] }
+```
+
+Il générera une erreur, car il a besoin de calculer `arr[10]`, même si cette valeur sera plus tard multipliée par zéro.
+
+C'est la raison pour laquelle nous avons besoin d'une bordure d'un emplacement de large tout autour de la carte. Nous devons calculer le nombre total de mines autour d'un emplacement, ce qui signifie que nous devons voir l'emplacement une ligne au-dessus et en dessous, à gauche et à droite de l'emplacement où nous creusons. Ce qui signifie que ces emplacements doivent exister dans le tableau de la carte qui est fourni à Zokrates.
+
+```
+def main(private bool[${width+2}][${height+2}] map, u32 x, u32 y) -> (field, u8) {
+```
+
+Par défaut, les preuves Zokrates incluent leurs entrées. Il est inutile de savoir qu'il y a cinq mines autour d'un endroit si vous ne savez pas réellement de quel endroit il s'agit (et vous ne pouvez pas simplement le faire correspondre à votre demande, car le prouveur pourrait alors utiliser des valeurs différentes sans vous en informer). Cependant, nous devons garder la carte secrète, tout en la fournissant à Zokrates. La solution est d'utiliser un paramètre `private`, un paramètre qui n'est _pas_ révélé par la preuve.
+
+Cela ouvre une autre voie d'abus. Le prouveur pourrait utiliser les bonnes coordonnées, mais créer une carte avec un nombre quelconque de mines autour de l'emplacement, et éventuellement à l'emplacement même. Pour empêcher cet abus, nous faisons en sorte que la preuve à divulgation nulle de connaissance inclue le hachage de la carte, qui est l'identifiant de la partie.
+
+```
+   return (hashMap(map),
+```
+
+La valeur de retour ici est un tuple qui inclut le tableau de hachage de la carte ainsi que le résultat du creusage.
+
+```
+         if map2mineCount(map, x, y) > 0 { 0xFF } else {
+```
+
+Nous utilisons 255 comme valeur spéciale au cas où l'emplacement lui-même contiendrait une bombe.
+
+```
+            map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +
+            map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +
+            map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)
+         }
+   );
+}
+```
+
+Si le joueur n'a pas touché de mine, ajoutez les nombres de mines pour la zone autour de l'emplacement et retournez ce résultat.
+
+### Utiliser Zokrates depuis TypeScript {#using-zokrates-from-typescript}
+
+Zokrates a une interface en ligne de commande, mais dans ce programme, nous l'utilisons dans le [code TypeScript](https://zokrates.github.io/toolbox/zokrates_js.html).
+
+La bibliothèque qui contient les définitions de Zokrates s'appelle [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts).
+
+```typescript
+import { initialize as zokratesInitialize } from "zokrates-js"
+```
+
+Importer les [liaisons JavaScript de Zokrates](https://zokrates.github.io/toolbox/zokrates_js.html). Nous n'avons besoin que de la fonction [`initialize`](https://zokrates.github.io/toolbox/zokrates_js.html#initialize) car elle renvoie une promesse qui se résout en toutes les définitions de Zokrates.
+
+```typescript
+export const zkFunctions = async (width: number, height: number) : Promise<any> => {
+```
+
+Similaire à Zokrates lui-même, nous n'exportons qu'une seule fonction, qui est également [asynchrone](https://www.w3schools.com/js/js_async.asp). Lorsqu'elle finit par retourner un résultat, elle fournit plusieurs fonctions comme nous le verrons ci-dessous.
+
+```typescript
+const zokrates = await zokratesInitialize()
+```
+
+Initialiser Zokrates, obtenir tout ce dont nous avons besoin de la bibliothèque.
+
+```typescript
+const hashFragment = `
+        import "utils/pack/bool/pack128.zok" as pack128;
+        import "hashes/poseidon/poseidon.zok" as poseidon;
+            .
+            .
+            .
+        }
+    `
+
+const hashProgram = `
+        ${hashFragment}
+            .
+            .
+            .
+    `
+
+const digProgram = `
+        ${hashFragment}
+            .
+            .
+            .
+    `
+```
+
+Ensuite, nous avons la fonction de hachage et les deux programmes Zokrates que nous avons vus ci-dessus.
+
+```typescript
+const digCompiled = zokrates.compile(digProgram)
+const hashCompiled = zokrates.compile(hashProgram)
+```
+
+Ici, nous compilons ces programmes.
+
+```typescript
+// Créez les clés pour la vérification à divulgation nulle de connaissance.
+// Sur un système de production, vous voudriez utiliser une cérémonie de configuration.
+// (https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony).
+const keySetupResults = zokrates.setup(digCompiled.program, "")
+const verifierKey = keySetupResults.vk
+const proverKey = keySetupResults.pk
+```
+
+Sur un système de production, nous pourrions utiliser une [cérémonie de configuration](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony) plus compliquée, mais cela suffit pour une démonstration. Ce n'est pas un problème que les utilisateurs puissent connaître la clé du prouveur - ils ne peuvent toujours pas l'utiliser pour prouver des choses à moins qu'elles ne soient vraies. Parce que nous spécifions l'entropie (le deuxième paramètre, `""`), les résultats seront toujours les mêmes.
+
+**Note :** La compilation des programmes Zokrates et la création des clés sont des processus lents. Il n'est pas nécessaire de les répéter à chaque fois, seulement lorsque la taille de la carte change. Sur un système de production, vous le feriez une fois, puis stockeriez le résultat. La seule raison pour laquelle je ne le fais pas ici est par souci de simplicité.
+
+#### `calculateMapHash` {#calculateMapHash}
+
+```typescript
+const calculateMapHash = function (hashMe: boolean[][]): string {
+  return (
+    "0x" +
+    BigInt(zokrates.computeWitness(hashCompiled, [hashMe]).output.slice(1, -1))
+      .toString(16)
+      .padStart(64, "0")
+  )
+}
+```
+
+La fonction [`computeWitness`](https://zokrates.github.io/toolbox/zokrates_js.html#computewitnessartifacts-args-options) exécute réellement le programme Zokrates. Elle retourne une structure avec deux champs : `output`, qui est la sortie du programme sous forme de chaîne JSON, et `witness`, qui est l'information nécessaire pour créer une preuve à divulgation nulle de connaissance du résultat. Ici, nous avons juste besoin de la sortie.
+
+La sortie est une chaîne de caractères de la forme `"31337"`, un nombre décimal entre guillemets. Mais la sortie dont nous avons besoin pour `viem` est un nombre hexadécimal de la forme `0x60A7`. Donc, nous utilisons `.slice(1,-1)` pour supprimer les guillemets, puis `BigInt` pour transformer la chaîne restante, qui est un nombre décimal, en un [`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt). `.toString(16)` convertit ce `BigInt` en une chaîne hexadécimale, et `"0x"+` ajoute le marqueur pour les nombres hexadécimaux.
+
+```typescript
+// Creuser et retourner une preuve à divulgation nulle de connaissance du résultat
+// (code côté serveur)
+```
+
+La preuve à divulgation nulle de connaissance inclut les entrées publiques (`x` et `y`) et les résultats (hachage de la carte et nombre de bombes).
+
+```typescript
+    const zkDig = function(map: boolean[][], x: number, y: number) : any {
+        if (x<0 || x>=width || y<0 || y>=height)
+            throw new Error("Trying to dig outside the map")
+```
+
+C'est un problème de vérifier si un index est hors limites dans Zokrates, alors nous le faisons ici.
+
+```typescript
+const runResults = zokrates.computeWitness(digCompiled, [map, `${x}`, `${y}`])
+```
+
+Exécutez le programme de creusage.
+
+```typescript
+        const proof = zokrates.generateProof(
+            digCompiled.program,
+            runResults.witness,
+            proverKey)
+
+        return proof
+    }
+```
+
+Utilisez [`generateProof`](https://zokrates.github.io/toolbox/zokrates_js.html#generateproofprogram-witness-provingkey-entropy) et retournez la preuve.
+
+```typescript
+const solidityVerifier = `
+        // Map size: ${width} x ${height}
+        \n${zokrates.exportSolidityVerifier(verifierKey)}
+        `
+```
+
+Un vérificateur Solidity, un contrat intelligent que nous pouvons déployer sur la blockchain et utiliser pour vérifier les preuves générées par `digCompiled.program`.
+
+```typescript
+    return {
+        zkDig,
+        calculateMapHash,
+        solidityVerifier,
+    }
+}
+```
+
+Enfin, retournez tout ce dont d'autres codes pourraient avoir besoin.
+
+## Tests de sécurité {#security-tests}
+
+Les tests de sécurité sont importants car un bug de fonctionnalité finira par se révéler. Mais si l'application n'est pas sécurisée, cela risque de rester caché pendant longtemps avant d'être révélé par quelqu'un qui triche et s'empare de ressources appartenant à d'autres.
+
+### Permissions {#permissions}
+
+Il y a une entité privilégiée dans ce jeu, le serveur. C'est le seul utilisateur autorisé à appeler les fonctions dans [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol). Nous pouvons utiliser [`cast`](https://book.getfoundry.sh/cast/) pour vérifier que les appels aux fonctions à permission sont autorisés uniquement en tant que compte serveur.
+
+[La clé privée du serveur se trouve dans `setupNetwork.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/mud/setupNetwork.ts#L52).
+
+1. Sur l'ordinateur qui exécute `anvil` (la blockchain), définissez ces variables d'environnement.
+
+   ```sh copy
+   WORLD_ADDRESS=0x8d8b6b8414e1e3dcfd4168561b9be6bd3bf6ec4b
+   UNAUTHORIZED_KEY=0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a
+   AUTHORIZED_KEY=0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d
+   ```
+
+2. Utilisez `cast` pour tenter de définir l'adresse du vérificateur en tant qu'adresse non autorisée.
+
+   ```sh copy
+   cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $UNAUTHORIZED_KEY
+   ```
+
+   Non seulement `cast` signale un échec, mais vous pouvez ouvrir les **Outils de développement MUD** dans le jeu sur le navigateur, cliquer sur **Tables** et sélectionner **app\_\_VerifierAddress**. Vous voyez que l'adresse n'est pas zéro.
+
+3. Définissez l'adresse du vérificateur comme l'adresse du serveur.
+
+   ```sh copy
+   cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $AUTHORIZED_KEY
+   ```
+
+   L'adresse dans **app\_\_VerifiedAddress** devrait maintenant être à zéro.
+
+Toutes les fonctions MUD dans le même `System` passent par le même contrôle d'accès, donc je considère ce test suffisant. Si vous n'êtes pas d'accord, vous pouvez vérifier les autres fonctions dans [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol).
+
+### Abus de la preuve à divulgation nulle de connaissance {#zero-knowledge-abuses}
+
+La mathématique pour vérifier Zokrates dépasse le cadre de ce tutoriel (et mes capacités). Cependant, nous pouvons exécuter diverses vérifications sur le code de preuve à divulgation nulle de connaissance pour vérifier que s'il n'est pas fait correctement, il échoue. Tous ces tests vont nous obliger à modifier [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts) et à redémarrer toute l'application. Il ne suffit pas de redémarrer le processus du serveur, car cela met l'application dans un état impossible (le joueur a une partie en cours, mais la partie n'est plus disponible pour le serveur).
+
+#### Mauvaise réponse {#wrong-answer}
+
+La possibilité la plus simple est de fournir la mauvaise réponse dans la preuve à divulgation nulle de connaissance. Pour ce faire, nous allons dans `zkDig` et [modifions la ligne 91](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L91) :
+
+```ts
+proof.inputs[3] = "0x" + "1".padStart(64, "0")
+```
+
+Cela signifie que nous prétendrons toujours qu'il y a une bombe, quelle que soit la bonne réponse. Essayez de jouer avec cette version, et vous verrez dans l'onglet **server** de l'écran `pnpm dev` cette erreur :
+
+```
+      cause: {
+        code: 3,
+        message: 'execution reverted: revert: Zero knowledge verification fail',
+        data: '0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000
+00000000000000000000000000000000000000000000000205a65726f206b6e6f776c6564676520766572696669636174696f6
+e206661696c'
+      },
+```
+
+Donc, ce genre de triche échoue.
+
+#### Mauvaise preuve {#wrong-proof}
+
+Que se passe-t-il si nous fournissons les bonnes informations, mais que les données de la preuve sont incorrectes ? Maintenant, remplacez la ligne 91 par :
+
+```ts
+proof.proof = {
+  a: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+  b: [
+    ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+    ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+  ],
+  c: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+}
+```
+
+Cela échoue toujours, mais maintenant cela échoue sans raison car cela se produit pendant l'appel du vérificateur.
+
+### Comment un utilisateur peut-il vérifier le code de confiance zéro ? {#user-verify-zero-trust}
+
+Les contrats intelligents sont relativement faciles à vérifier. Généralement, le développeur publie le code source sur un explorateur de blocs, et l'explorateur de blocs vérifie que le code source se compile bien en le code dans la [transaction de déploiement du contrat](/developers/docs/smart-contracts/deploying/). Dans le cas des `System` MUD, c'est [légèrement plus compliqué](https://mud.dev/cli/verify), mais pas de beaucoup.
+
+C'est plus difficile avec la preuve à divulgation nulle de connaissance. Le vérificateur inclut quelques constantes et exécute des calculs sur celles-ci. Cela ne vous dit pas ce qui est prouvé.
+
+```solidity
+    function verifyingKey() pure internal returns (VerifyingKey memory vk) {
+        vk.alpha = Pairing.G1Point(uint256(0x0f43f4fe7b5c2326fed4ac6ed2f4003ab9ab4ea6f667c2bdd77afb068617ee16), uint256(0x25a77832283f9726935219b5f4678842cda465631e72dbb24708a97ba5d0ce6f));
+        vk.beta = Pairing.G2Point([uint256(0x2cebd0fbd21aca01910581537b21ae4fed46bc0e524c055059aa164ba0a6b62b), uint256(0x18fd4a7bc386cf03a95af7163d5359165acc4e7961cb46519e6d9ee4a1e2b7e9)], [uint256(0x11449dee0199ef6d8eebfe43b548e875c69e7ce37705ee9a00c81fe52f11a009), uint256(0x066d0c83b32800d3f335bb9e8ed5e2924cf00e77e6ec28178592eac9898e1a00)]);
+```
+
+La solution, du moins jusqu'à ce que les explorateurs de blocs ajoutent la vérification Zokrates à leurs interfaces utilisateur, est que les développeurs d'applications mettent à disposition les programmes Zokrates, et qu'au moins certains utilisateurs les compilent eux-mêmes avec la clé de vérification appropriée.
+
+Pour ce faire :
+
+1. [Installez Zokrates](https://zokrates.github.io/gettingstarted.html).
+
+2. Créez un fichier, `dig.zok`, avec le programme Zokrates. Le code ci-dessous suppose que vous avez conservé la taille de carte originale, 10x5.
+
+   ```zokrates
+    import "utils/pack/bool/pack128.zok" as pack128;
+    import "hashes/poseidon/poseidon.zok" as poseidon;
+
+    def hashMap(bool[12][7] map) -> field {
+        bool[512] mut map1d = [false; 512];
+        u32 mut counter = 0;
+
+        for u32 x in 0..12 {
+            for u32 y in 0..7 {
+                map1d[counter] = map[x][y];
+                counter = counter+1;
+            }
+        }
+
+        field[4] hashMe = [
+            pack128(map1d[0..128]),
+            pack128(map1d[128..256]),
+            pack128(map1d[256..384]),
+            pack128(map1d[384..512])
+        ];
+
+        return poseidon(hashMe);
+    }
+
+
+    // Le nombre de mines à l'emplacement (x,y)
+    def map2mineCount(bool[12][7] map, u32 x, u32 y) -> u8 {
+        return if map[x+1][y+1] { 1 } else { 0 };
+    }
+
+    def main(private bool[12][7] map, u32 x, u32 y) -> (field, u8) {
+        return (hashMap(map) ,
+            if map2mineCount(map, x, y) > 0 { 0xFF } else {
+                map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +
+                map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +
+                map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)
+            }
+        );
+    }
+   ```
+
+3. Compilez le code Zokrates et créez la clé de vérification. La clé de vérification doit être créée avec la même entropie utilisée dans le serveur d'origine, [dans ce cas une chaîne vide](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L67).
+
+   ```sh copy
+   zokrates compile --input dig.zok
+   zokrates setup -e ""
+   ```
+
+4. Créez le vérificateur Solidity par vous-même, et vérifiez qu'il est fonctionnellement identique à celui sur la blockchain (le serveur ajoute un commentaire, mais ce n'est pas important).
+
+   ```sh copy
+   zokrates export-verifier
+   diff verifier.sol ~/20240901-secret-state/packages/contracts/src/verifier.sol
+   ```
+
+## Décisions de conception {#design}
+
+Dans toute application suffisamment complexe, il existe des objectifs de conception concurrents qui nécessitent des compromis. Examinons certains des compromis et pourquoi la solution actuelle est préférable à d'autres options.
+
+### Pourquoi la preuve à divulgation nulle de connaissance {#why-zero-knowledge}
+
+Pour un démineur, vous n'avez pas vraiment besoin de la preuve à divulgation nulle de connaissance. Le serveur peut toujours conserver la carte, puis simplement la révéler entièrement lorsque la partie est terminée. Ensuite, à la fin de la partie, le contrat intelligent peut calculer le hachage de la carte, vérifier qu'il correspond, et s'il ne correspond pas, pénaliser le serveur ou ignorer complètement la partie.
+
+Je n'ai pas utilisé cette solution plus simple car elle ne fonctionne que pour les jeux courts avec un état final bien défini. Quand un jeu est potentiellement infini (comme dans le cas des [mondes autonomes](https://0xparc.org/blog/autonomous-worlds)), vous avez besoin d'une solution qui prouve l'état _sans_ le révéler.
+
+En tant que tutoriel, cet article avait besoin d'un jeu court et facile à comprendre, mais cette technique est plus utile pour les jeux plus longs.
+
+### Pourquoi Zokrates ? {#why-zokrates}
+
+[Zokrates](https://zokrates.github.io/) n'est pas la seule bibliothèque de preuve à divulgation nulle de connaissance disponible, mais il est similaire à un langage de programmation normal et [impératif](https://en.wikipedia.org/wiki/Imperative_programming) et prend en charge les variables booléennes.
+
+Pour votre application, avec des exigences différentes, vous pourriez préférer utiliser [Circum](https://docs.circom.io/getting-started/installation/) ou [Cairo](https://www.cairo-lang.org/tutorials/getting-started-with-cairo/).
+
+### Quand compiler Zokrates {#when-compile-zokrates}
+
+Dans ce programme, nous compilons les programmes Zokrates [à chaque démarrage du serveur](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L60-L61). Il s'agit clairement d'un gaspillage de ressources, mais c'est un tutoriel, optimisé pour la simplicité.
+
+Si j'écrivais une application de niveau production, je vérifierais si j'ai un fichier avec les programmes Zokrates compilés pour cette taille de champ de mines, et si c'est le cas, je l'utiliserais. Il en va de même pour le déploiement d'un contrat de vérificateur en chaîne.
+
+### Création des clés de vérificateur et de prouveur {#key-creation}
+
+La [création de clés](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L63-L69) est un autre calcul pur qui n'a pas besoin d'être fait plus d'une fois pour une taille de champ de mines donnée. Encore une fois, cela n'est fait qu'une seule fois par souci de simplicité.
+
+De plus, nous pourrions utiliser [une cérémonie de configuration](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony). L'avantage d'une cérémonie de configuration est qu'il faut soit l'entropie, soit un résultat intermédiaire de chaque participant pour tricher sur la preuve à divulgation nulle de connaissance. Si au moins un participant à la cérémonie est honnête et supprime cette information, les preuves à divulgation nulle de connaissance sont à l'abri de certaines attaques. Cependant, il n'y a _aucun mécanisme_ pour vérifier que l'information a été supprimée de partout. Si les preuves à divulgation nulle de connaissance sont d'une importance capitale, vous voudrez participer à la cérémonie de configuration.
+
+Ici, nous nous appuyons sur les [pouvoirs perpétuels de tau](https://github.com/privacy-scaling-explorations/perpetualpowersoftau), qui ont eu des dizaines de participants. C'est probablement assez sûr, et beaucoup plus simple. Nous n'ajoutons pas non plus d'entropie lors de la création des clés, ce qui facilite la [vérification de la configuration de preuve à divulgation nulle de connaissance](#user-verify-zero-trust) par les utilisateurs.
+
+### Où vérifier {#where-verification}
+
+Nous pouvons vérifier les preuves à divulgation nulle de connaissance soit en chaîne (ce qui coûte du gaz), soit dans le client (en utilisant [`verify`](https://zokrates.github.io/toolbox/zokrates_js.html#verifyverificationkey-proof)). J'ai choisi la première option, car cela permet de [vérifier le vérificateur](#user-verify-zero-trust) une fois pour toutes, puis de faire confiance au fait qu'il ne change pas tant que l'adresse du contrat reste la même. Si la vérification était effectuée sur le client, vous devriez vérifier le code que vous recevez à chaque fois que vous téléchargez le client.
+
+De plus, bien que ce jeu soit solo, beaucoup de jeux sur la blockchain sont multijoueurs. La vérification en chaîne signifie que vous ne vérifiez la preuve à divulgation nulle de connaissance qu'une seule fois. Le faire dans le client exigerait que chaque client vérifie indépendamment.
+
+### Aplatir la carte en TypeScript ou en Zokrates ? {#where-flatten}
+
+En général, lorsque le traitement peut être effectué soit en TypeScript soit en Zokrates, il est préférable de le faire en TypeScript, qui est beaucoup plus rapide et ne nécessite pas de preuves à divulgation nulle de connaissance. C'est la raison, par exemple, pour laquelle nous ne fournissons pas à Zokrates le hachage pour qu'il vérifie qu'il est correct. Le hachage doit être fait à l'intérieur de Zokrates, mais la correspondance entre le hachage retourné et le hachage en chaîne peut se faire en dehors.
+
+Cependant, nous [aplatissons toujours la carte dans Zokrates](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L15-L20), alors que nous aurions pu le faire en TypeScript. La raison est que les autres options sont, à mon avis, pires.
+
+- Fournir un tableau unidimensionnel de booléens au code Zokrates, et utiliser une expression telle que `x*(height+2)
+  +y` pour obtenir la carte bidimensionnelle. Cela rendrait [le code](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L44-L47) quelque peu plus compliqué, j'ai donc décidé que le gain de performance ne valait pas la peine pour un tutoriel.
+
+- Envoyer à Zokrates à la fois le tableau unidimensionnel et le tableau bidimensionnel. Cependant, cette solution ne nous apporte rien. Le code Zokrates devrait vérifier que le tableau unidimensionnel qui lui est fourni est bien la représentation correcte du tableau bidimensionnel. Il n'y aurait donc aucun gain de performance.
+
+- Aplatir le tableau à deux dimensions dans Zokrates. C'est l'option la plus simple, donc je l'ai choisie.
+
+### Où stocker les cartes {#where-store-maps}
+
+Dans cette application, [`gamesInProgress`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L20) est simplement une variable en mémoire. Cela signifie que si votre serveur tombe en panne et doit être redémarré, toutes les informations qu'il stockait sont perdues. Non seulement les joueurs sont incapables de continuer leur partie, mais ils ne peuvent même pas en commencer une nouvelle car le composant en chaîne pense qu'ils ont toujours une partie en cours.
+
+C'est clairement une mauvaise conception pour un système de production, dans lequel vous stockeriez ces informations dans une base de données. La seule raison pour laquelle j'ai utilisé une variable ici est que c'est un tutoriel et que la simplicité est la principale considération.
+
+## Conclusion : Dans quelles conditions cette technique est-elle appropriée ? {#conclusion}
+
+Donc, vous savez maintenant comment écrire un jeu avec un serveur qui stocke un état secret qui n'a pas sa place sur la chaîne. Mais dans quels cas devriez-vous le faire ? Il y a deux considérations principales.
+
+- _Jeu de longue durée_ : [Comme mentionné ci-dessus](#why-zero-knowledge), dans un jeu court, vous pouvez simplement publier l'état une fois la partie terminée et faire tout vérifier à ce moment-là. Mais ce n'est pas une option lorsque le jeu dure longtemps ou indéfiniment, et que l'état doit rester secret.
+
+- _Une certaine centralisation acceptable_ : les preuves à divulgation nulle de connaissance peuvent vérifier l'intégrité, qu'une entité ne falsifie pas les résultats. Ce qu'ils ne peuvent pas faire, c'est garantir que l'entité sera toujours disponible et répondra aux messages. Dans les situations où la disponibilité doit également être décentralisée, les preuves à divulgation nulle de connaissance ne sont pas une solution suffisante, et vous avez besoin du [calcul multipartite](https://en.wikipedia.org/wiki/Secure_multi-party_computation).
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
+
+### Remerciements {#acknowledgements}
+
+- Alvaro Alonso a lu une ébauche de cet article et a clarifié certaines de mes incompréhensions sur Zokrates.
+
+Toute erreur restante est de ma responsabilité.
diff --git a/public/content/translations/fr/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/fr/developers/tutorials/secure-development-workflow/index.md
index 5cf6f987b11..1c543c13e95 100644
--- a/public/content/translations/fr/developers/tutorials/secure-development-workflow/index.md
+++ b/public/content/translations/fr/developers/tutorials/secure-development-workflow/index.md
@@ -1,15 +1,12 @@
 ---
-title: Liste de contrôle de sécurité des contrats intelligents
-description: Un flux de travail suggéré pour la rédaction de contrats intelligents sécurisés
+title: "Liste de contrôle de sécurité des contrats intelligents"
+description: "Un flux de travail suggéré pour la rédaction de contrats intelligents sécurisés"
 author: "Trailofbits"
-tags:
-  - "contrats intelligents"
-  - "sécurité"
-  - "solidity"
+tags: [ "contrats intelligents", "sécurité", "Solidity" ]
 skill: intermediate
 lang: fr
 published: 2020-09-07
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
 ---
 
@@ -19,26 +16,25 @@ Voici un processus de haut niveau que nous vous recommandons de suivre lors de l
 
 Recherchez les vulnérabilités connues :
 
-- Vérifiez vos contrats avec [Slither](https://github.com/crytic/slither). Cet outil intègre plus de 40 détecteurs pour les vulnérabilités connues. Exécutez-le à chaque enregistrement d'un nouveau code et assurez-vous que son rapport soit positif (ou utilisez le mode triage pour mettre sous silence certains problèmes).
-- Vérifiez vos contrats avec [Crytic](https://crytic.io/). Il vérifie 50 vulnérabilités que Slither ne détecte pas. Cryptic peut également aider votre équipe à rester le maître du jeu en faisant apparaître facilement les problèmes de sécurité dans les Pull Requests sur GitHub.
+- Examinez vos contrats avec [Slither](https://github.com/crytic/slither). Cet outil intègre plus de 40 détecteurs pour les vulnérabilités connues. Exécutez-le à chaque enregistrement d'un nouveau code et assurez-vous que son rapport soit positif (ou utilisez le mode triage pour mettre sous silence certains problèmes).
+- Examinez vos contrats avec [Crytic](https://crytic.io/). Il vérifie 50 vulnérabilités que Slither ne détecte pas. Cryptic peut également aider votre équipe à rester le maître du jeu en faisant apparaître facilement les problèmes de sécurité dans les Pull Requests sur GitHub.
 
 Considérez les caractéristiques spéciales de votre contrat :
 
-- Vos contrats sont-ils évolutifs ? Vérifiez votre code de mise à niveau pour les défauts avec [`slither-check-upgradeability`](https://github.com/crytic/slither/wiki/Upgradeability-Checks) ou [Crytic](https://blog.trailofbits.com/2020/06/12/upgradeable-contracts-made-safer-with-crytic/). Nous avons documenté 17 façons dont les mises à niveau peuvent mal tourner.
+- Vos contrats sont-ils évolutifs ? Examinez votre code de mise à niveau pour y déceler des failles avec [`slither-check-upgradeability`](https://github.com/crytic/slither/wiki/Upgradeability-Checks) ou [Crytic](https://blog.trailofbits.com/2020/06/12/upgradeable-contracts-made-safer-with-crytic/). Nous avons documenté 17 façons dont les mises à niveau peuvent mal tourner.
 - Est-ce que vos contrats doivent se conformer aux ERC? Vérifiez-les avec [`slither-check-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance). Cet outil identifie instantanément les écarts de six spécifications courantes.
-- Avez-vous des tests unitaires dans Truffe ? Enrichissez-les avec [`slither-prop`](https://github.com/crytic/slither/wiki/Property-generation). Il génère automatiquement une suite de propriétés de sécurité robustes pour les fonctionnalités de l'ERC20 en fonction de votre code spécifique.
-- Intégrez-vous des jetons tiers ? Consultez notre [liste de contrôle d'intégration de jetons](/developers/tutorials/token-integration-checklist/) avant de vous fier à des contrats externes.
+- Intégrez-vous des jetons tiers ? Examinez notre [liste de contrôle d'intégration de jetons](/developers/tutorials/token-integration-checklist/) avant de dépendre de contrats externes.
 
 Inspectez visuellement les fonctions de sécurité critiques de votre code :
 
-- Examinez l'afficheur [inheritance-graph](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) de Slither. Évitez les surcharges involontaires et les problèmes de linéarisation C3.
-- Examinez l'afficheur [résumé de fonction](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) de Slither. Il signale la visibilité des fonctions et les contrôles d'accès.
-- Examinez l'afficheur [variables et accès](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) de Slither. Il signale les contrôles d'accès aux variables d'état.
+- Examinez l'imprimante [inheritance-graph](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) de Slither. Évitez les surcharges involontaires et les problèmes de linéarisation C3.
+- Examinez l'imprimante [function-summary](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) de Slither. Il signale la visibilité des fonctions et les contrôles d'accès.
+- Examinez l'imprimante [vars-and-auth](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) de Slither. Il signale les contrôles d'accès aux variables d'état.
 
 Documentez les propriétés critiques de sécurité et utilisez des générateurs de tests automatisés pour les évaluer :
 
 - Apprenez à [documenter les propriétés de sécurité de votre code](/developers/tutorials/guide-to-smart-contract-security-tools/). C'est difficile au départ, mais c'est l'activité la plus importante pour obtenir un bon résultat. C'est également un prérequis à l'utilisation des techniques avancées de ce tutoriel.
-- Definissez les propriétés de sécurité en Solidity, pour les utiliser avec [Echidna](https://github.com/crytic/echidna) et [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html). Concentrez-vous sur votre automate, les contrôles d'accès, les opérations arithmétiques, les interactions externes et la conformité aux normes.
+- Définissez les propriétés de sécurité dans Solidity, pour les utiliser avec [Echidna](https://github.com/crytic/echidna) et [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html). Concentrez-vous sur votre automate, les contrôles d'accès, les opérations arithmétiques, les interactions externes et la conformité aux normes.
 - Définissez les propriétés de sécurité avec [l'API Python de Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/). Concentrez-vous sur l'héritage, les dépendances des variables, les contrôles d'accès et d'autres problèmes structurels.
 - Exécutez vos tests de propriété sur chaque commit avec [Crytic](https://crytic.io). Crytic peut consommer et évaluer les tests de propriétés de sécurité pour que tout le monde dans votre équipe puisse facilement voir qu'ils passent sur GitHub. Les tests en échec peuvent bloquer les commits.
 
@@ -51,6 +47,6 @@ Enfin, soyez attentifs aux problèmes que les outils automatisés ne peuvent pas
 
 ## Demandez de l'aide {#ask-for-help}
 
-[Les heures de bureau d'Ethereum](https://calendly.com/dan-trailofbits/office-hours) se déroulent tous les mardis après-midi. Ces sessions en tête à tête sont l'occasion de nous poser toutes vos questions sur la sécurité, de dépannage à l'aide de nos outils et d'obtenir des commentaires d'experts sur votre approche actuelle. Nous vous aiderons à travailler à travers ce guide.
+Les [heures de permanence Ethereum](https://calendly.com/dan-trailofbits/office-hours) ont lieu tous les mardis après-midi. Ces sessions en tête à tête sont l'occasion de nous poser toutes vos questions sur la sécurité, de dépannage à l'aide de nos outils et d'obtenir des commentaires d'experts sur votre approche actuelle. Nous vous aiderons à travailler à travers ce guide.
 
 Rejoignez notre Slack : [Empire Hacking](https://join.slack.com/t/empirehacking/shared_invite/zt-h97bbrj8-1jwuiU33nnzg67JcvIciUw). Nous sommes toujours disponibles dans les canaux #crytic et #ethereum si vous avez des questions.
diff --git a/public/content/translations/fr/developers/tutorials/send-token-ethersjs/index.md b/public/content/translations/fr/developers/tutorials/send-token-ethersjs/index.md
index 8352a365b03..985479e5f4e 100644
--- a/public/content/translations/fr/developers/tutorials/send-token-ethersjs/index.md
+++ b/public/content/translations/fr/developers/tutorials/send-token-ethersjs/index.md
@@ -1,27 +1,25 @@
 ---
-title: Envoyer des jetons avec ethers.js
-description: Guide à l'intention des débutants sur l'envoi de jetons à l'aide d'ether.js.
+title: "Envoyer des jetons à l'aide d'ethers.js"
+description: "Guide pour débutants sur l'envoi de jetons à l'aide d'ethers.js."
 author: Kim YongJun
-tags:
-  - "ETHERS.JS"
-  - "ERC-20"
-  - "JETONS"
+tags: [ "ETHERS.JS", "ERC-20", "JETONS" ]
 skill: beginner
 lang: fr
 published: 2021-04-06
 ---
 
-## Envoyer un jeton avec ethers.js (5.0) {#send-token}
+## Envoyer un jeton avec ethers.js(5.0) {#send-token}
 
-### Dans ce tutoriel, vous allez apprendre à {#you-learn-about}
+### Dans ce tutoriel, vous apprendrez comment {#you-learn-about}
 
 - Importer ethers.js
 - Transférer un jeton
-- Définir le prix du gaz en fonction de l'état du trafic réseau
+- Définir le prix du gaz en fonction de l'état du trafic du réseau
 
 ### Pour commencer {#to-get-started}
 
-Pour commencer, nous devons d'abord importer la bibliothèque ethers.js dans notre JavaScript en intégrant ethers.js (5.0)
+Pour commencer, nous devons d'abord importer la bibliothèque ethers.js dans notre JavaScript.
+Inclure ethers.js(5.0)
 
 ### Installation {#install-ethersjs}
 
@@ -29,16 +27,16 @@ Pour commencer, nous devons d'abord importer la bibliothèque ethers.js dans not
 /home/ricmoo> npm install --save ethers
 ```
 
-ES6 dans le navigateur :
+ES6 dans le navigateur
 
 ```html
 <script type="module">
   import { ethers } from "https://cdn.ethers.io/lib/ethers-5.0.esm.min.js"
-  // Your code here...
+  // Votre code ici...
 </script>
 ```
 
-ES3 (UMD) dans le navigateur :
+ES3 (UMD) dans le navigateur
 
 ```html
 <script
@@ -49,19 +47,19 @@ ES3 (UMD) dans le navigateur :
 
 ### Paramètres {#param}
 
-1. **`contract_address`** : l'adresse du contrat du jeton (l'adresse du contrat est nécessaire lorsque le jeton que vous voulez transférer n'est pas de l'ether)
-2. **`send_token_amount`** : le montant que vous désirez envoyer au destinataire
+1. **`contract_address`** : adresse du contrat de jeton (l'adresse du contrat est nécessaire lorsque le jeton que vous voulez transférer n'est pas de l'ether)
+2. **`send_token_amount`** : le montant que vous souhaitez envoyer au destinataire
 3. **`to_address`** : l'adresse du destinataire
 4. **`send_account`** : l'adresse de l'expéditeur
-5. **`private_key`** : clé privée de l'expéditeur afin de signer la transaction et de transférer véritablement les jetons
+5. **`private_key`** : clé privée de l'expéditeur pour signer la transaction et transférer les jetons
 
 ## Remarque {#notice}
 
-`signTransaction(tx)` est retiré car `sendTransaction()` le fait en interne.
+`signTransaction(tx)` est supprimé car `sendTransaction()` s'en charge en interne.
 
 ## Procédure d'envoi {#procedure}
 
-### 1. Se connecter au réseau (testnet) {#connect-to-network}
+### 1. Se connecter au réseau (réseau de test) {#connect-to-network}
 
 #### Définir le fournisseur (Infura) {#set-provider}
 
@@ -91,17 +89,17 @@ window.ethersProvider.getGasPrice() // gasPrice
 
 ### 5. Définir la transaction {#define-transaction}
 
-Les variables définies ci-dessous sont dépendantes de `send_token()`
+Les variables définies ci-dessous dépendent de `send_token()`
 
-### Paramètres de la transaction {#transaction-params}
+### Paramètres de transaction {#transaction-params}
 
 1. **`send_account`** : adresse de l'expéditeur du jeton
 2. **`to_address`** : adresse du destinataire du jeton
-3. **`send_token_amount`** : nombre de jetons à envoyer
+3. **`send_token_amount`** : le montant de jetons à envoyer
 4. **`gas_limit`** : limite de gaz
 5. **`gas_price`** : prix du gaz
 
-[Voir ci-dessous pour savoir comment les utiliser](#how-to-use)
+[Voir ci-dessous pour savoir comment l'utiliser](#how-to-use)
 
 ```javascript
 const tx = {
@@ -114,16 +112,16 @@ const tx = {
 }
 ```
 
-### 6. Transférer {#transfer}
+### 6. Transfert {#transfer}
 
 ```javascript
 walletSigner.sendTransaction(tx).then((transaction) => {
   console.dir(transaction)
-  alert("Send finished!")
+  alert("Envoi terminé !")
 })
 ```
 
-## Comment l’utiliser  {#how-to-use}
+## Comment l'utiliser {#how-to-use}
 
 ```javascript
 let private_key =
@@ -146,9 +144,9 @@ send_token(
 )
 ```
 
-### Réussi ! {#success}
+### Succès ! {#success}
 
-![image de la transaction effectuée avec succès](./successful-transaction.png)
+![image d'une transaction effectuée avec succès](./successful-transaction.png)
 
 ## send_token() {#send-token-method}
 
@@ -168,23 +166,23 @@ function send_token(
     console.log(`gas_price: ${gas_price}`)
 
     if (contract_address) {
-      // general token send
+      // envoi de jeton générique
       let contract = new ethers.Contract(
         contract_address,
         send_abi,
         walletSigner
       )
 
-      // How many tokens?
+      // Combien de jetons ?
       let numberOfTokens = ethers.utils.parseUnits(send_token_amount, 18)
       console.log(`numberOfTokens: ${numberOfTokens}`)
 
-      // Send tokens
+      // Envoyer des jetons
       contract.transfer(to_address, numberOfTokens).then((transferResult) => {
         console.dir(transferResult)
-        alert("sent token")
+        alert("jeton envoyé")
       })
-    } // ether send
+    } // envoi d'ether
     else {
       const tx = {
         from: send_account,
@@ -201,10 +199,10 @@ function send_token(
       try {
         walletSigner.sendTransaction(tx).then((transaction) => {
           console.dir(transaction)
-          alert("Send finished!")
+          alert("Envoi terminé !")
         })
       } catch (error) {
-        alert("failed to send!!")
+        alert("échec de l'envoi !!")
       }
     }
   })
diff --git a/public/content/translations/fr/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md b/public/content/translations/fr/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
index 500ad8c7eb4..d33c58e4040 100644
--- a/public/content/translations/fr/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
+++ b/public/content/translations/fr/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
@@ -1,117 +1,114 @@
 ---
-title: Envoyer des transactions en utilisant le Web3
-description: "Voici un guide à l'attention des débutants qui explique comment envoyer des transactions Ethereum en utilisant le Web3. Il y a trois étapes principales pour envoyer une transaction sur la blockchain Ethereum : créer, signer et diffuser. Nous allons passer en revue les trois."
+title: Envoyer des transactions en utilisant Web3
+description: "Voici un guide pour débutants expliquant comment envoyer des transactions Ethereum à l'aide de Web3. Il y a trois étapes principales pour envoyer une transaction à la blockchain Ethereum : la création, la signature et la diffusion. Nous allons passer en revue les trois."
 author: "Elan Halpern"
-tags:
-  - "transactions"
-  - "web3.js"
-  - "alchemy"
+tags: [ "transactions", "web3.js", "Alchemy" ]
 skill: beginner
 lang: fr
 published: 2020-11-04
-source: Documentation Alchemy
+source: Alchemy docs
 sourceUrl: https://www.alchemy.com/docs/how-to-send-transactions-on-ethereum
 ---
 
-Voici un guide à l'attention des débutants qui explique comment envoyer des transactions Ethereum en utilisant le Web3. Il y a trois étapes principales pour envoyer une transaction sur la blockchain Ethereum : créer, signer et diffuser. Nous allons passer en revue les trois en espérant répondre à toutes les questions que vous pourriez vous poser ! Dans ce tutoriel, nous utiliserons [Alchemy](https://www.alchemy.com/) pour envoyer nos transactions sur la chaîne Ethereum. Vous pouvez [créer gratuitement un compte sur Alchemy ici](https://auth.alchemyapi.io/signup).
+Voici un guide pour débutants expliquant comment envoyer des transactions Ethereum à l'aide de Web3. Il y a trois étapes principales pour envoyer une transaction à la blockchain Ethereum : la création, la signature et la diffusion. Nous allons passer en revue les trois, en espérant répondre à toutes les questions que vous pourriez avoir ! Dans ce tutoriel, nous utiliserons [Alchemy](https://www.alchemy.com/) pour envoyer nos transactions sur la chaîne Ethereum. Vous pouvez [créer un compte Alchemy gratuit ici](https://auth.alchemyapi.io/signup).
 
-**NOTE :** Ce guide est destiné à signer vos transactions sur le _backend_ de votre application. Si vous voulez intégrer la signature de vos transactions en frontend, consultez l'intégration de [Web3 avec un fournisseur de navigateur](https://docs.alchemy.com/reference/api-overview#with-a-browser-provider).
+**REMARQUE :** Ce guide concerne la signature de vos transactions sur le _backend_ de votre application. Si vous souhaitez intégrer la signature de vos transactions sur le frontend, consultez l'intégration de [Web3 avec un fournisseur de navigateur](https://docs.alchemy.com/reference/api-overview#with-a-browser-provider).
 
 ## Les bases {#the-basics}
 
-Comme la plupart des développeurs blockchain débutants, vous avez peut-être fait des recherches sur la façon d'envoyer une transaction (ce qui devrait être assez simple ) et vous êtes tombé sur une pléthore de guides, chacun décrivant des choses différentes, vous laissant quelque peu dépassé et désorienté. Si vous êtes dans ce cas, ne vous inquiétez pas, nous l'avons tous été à un moment ou à un autre ! Donc, avant de commencer, mettons certaines choses au clair :
+Comme la plupart des développeurs de blockchain à leurs débuts, vous avez peut-être fait des recherches sur la façon d'envoyer une transaction (ce qui devrait être assez simple) et vous êtes tombé sur une pléthore de guides, chacun disant des choses différentes et vous laissant un peu dépassé et confus. Si vous êtes dans ce cas, ne vous inquiétez pas, nous y sommes tous passés à un moment ou à un autre ! Donc, avant de commencer, mettons les choses au clair :
 
-### 1\. Alchemy ne stocke pas vos clés privées {#alchemy-does-not-store-your-private-keys}
+### 1. Alchemy ne stocke pas vos clés privées {#alchemy-does-not-store-your-private-keys}
 
-- Cela signifie qu'Alchemy ne peut pas signer et envoyer des transactions en votre nom. Ceci pour  des raisons de sécurité. Alchemy ne vous demandera jamais de partager votre clé privée, et vous ne devriez jamais partager votre clé privée avec un nœud hébergé (ni avec quiconque d'ailleurs).
-- Vous pouvez lire sur la blockchain en utilisant l'API Alchemy, mais pour y écrire vous devrez utiliser quelque chose d'autre afin de signer vos transactions par le biais d'Alchemy (c'est le cas pour tous les [services d'accès à la blockchain](/developers/docs/nodes-and-clients/nodes-as-a-service/)).
+- Cela signifie qu'Alchemy ne peut pas signer et envoyer de transactions en votre nom. Ceci pour des raisons de sécurité. Alchemy ne vous demandera jamais de partager votre clé privée, et vous ne devriez jamais la partager avec un nœud hébergé (ni avec qui que ce soit d'autre).
+- Vous pouvez lire sur la blockchain à l'aide de l'API de base d'Alchemy, mais pour y écrire, vous devrez utiliser autre chose pour signer vos transactions avant de les envoyer via Alchemy (il en va de même pour tout autre [service de nœud](/developers/docs/nodes-and-clients/nodes-as-a-service/)).
 
-### 2\. Qu'est-ce qu'un « signataire » ? {#what-is-a-signer}
+### 2. Qu'est-ce qu'un « signataire » ? {#what-is-a-signer}
 
-- Les signataires signeront pour vous les transactions en utilisant votre clé privée. Dans ce tutoriel, nous utiliserons [Alchemy web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3) pour signer notre transaction, mais vous pouvez également utiliser n'importe quelle autre bibliothèque web3.
-- En frontend, un bon exemple de signataire serait [MetaMask](https://metamask.io/), qui signera et enverra des transactions en votre nom.
+- Les signataires signeront les transactions pour vous à l'aide de votre clé privée. Dans ce tutoriel, nous utiliserons [Alchemy web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3) pour signer notre transaction, mais vous pourriez également utiliser n'importe quelle autre bibliothèque web3.
+- Sur le frontend, un bon exemple de signataire serait [MetaMask](https://metamask.io/), qui signera et enverra des transactions en votre nom.
 
-### 3\. Pourquoi dois-je signer mes transactions? {#why-do-i-need-to-sign-my-transactions}
+### 3. Pourquoi dois-je signer mes transactions ? {#why-do-i-need-to-sign-my-transactions}
 
-- Chaque utilisateur souhaitant envoyer une transaction sur le réseau Ethereum doit signer la transaction (à l'aide de sa clé privée), afin de valider que l'origine de la transaction est bien celle qu'elle prétend être.
-- Il est très important de protéger cette clé privée, car le fait d'y avoir accès vous donne le contrôle total de votre compte Ethereum, ce qui vous permet (ou à quiconque y ayant accès) d'effectuer des transactions en votre nom.
+- Chaque utilisateur qui souhaite envoyer une transaction sur le réseau Ethereum doit signer la transaction (en utilisant sa clé privée), afin de valider que l'origine de la transaction est bien celle qu'il prétend être.
+- Il est très important de protéger cette clé privée, car y avoir accès accorde un contrôle total sur votre compte Ethereum, vous permettant (ou à toute personne y ayant accès) d'effectuer des transactions en votre nom.
 
-### 4\. Comment protéger ma clé privée ? {#how-do-i-protect-my-private-key}
+### 4. Comment protéger ma clé privée ? {#how-do-i-protect-my-private-key}
 
-- Il existe de nombreuses façons de protéger votre clé privée et de l'utiliser pour envoyer des transactions. Dans ce tutoriel, nous allons utiliser un fichier `.env`. Cependant, vous pouvez également faire appel à un autre fournisseur qui stocke les clés privées, utiliser un fichier keystore, ou d'autres options.
+- Il existe de nombreuses façons de protéger votre clé privée et de l'utiliser pour envoyer des transactions. Dans ce tutoriel, nous utiliserons un fichier `.env`. Cependant, vous pouvez également utiliser un fournisseur distinct qui stocke les clés privées, utiliser un fichier keystore ou d'autres options.
 
-### 5\. Quelle est la différence entre `eth_sendTransaction` et `eth_sendRawTransaction` ? {#difference-between-send-and-send-raw}
+### 5. Quelle est la différence entre `eth_sendTransaction` et `eth_sendRawTransaction` ? {#difference-between-send-and-send-raw}
 
-`eth_sendTransaction` et `eth_sendRawTransaction` sont des fonctions API Ethereum qui diffusent une transaction sur le réseau Ethereum afin qu'elle soit ajoutée à un bloc futur. Elles diffèrent dans la façon dont elles gèrent la signature des transactions.
+`eth_sendTransaction` et `eth_sendRawTransaction` sont toutes deux des fonctions de l'API Ethereum qui diffusent une transaction sur le réseau Ethereum afin qu'elle soit ajoutée à un bloc futur. Elles diffèrent par la manière dont elles gèrent la signature des transactions.
 
-- [`eth_sendTransaction`](https://docs.web3js.org/api/web3-eth/function/sendTransaction) est utilisée pour envoyer des transactions _non signées_, ce qui signifie que le nœud auquel vous envoyez la transaction doit gérer votre clé privée pour pouvoir signer la transaction avant de la transmettre à la chaîne. Puisqu'Alchemy ne possède pas les clés privées de l'utilisateur, il ne prend pas en charge cette méthode.
-- [`eth_sendRawTransaction`](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction) est utilisée pour propager des transactions qui ont déjà été signées. Cela signifie que vous devez d'abord utiliser [`signTransaction(tx, private_key)`](https://docs.web3js.org/api/web3-eth-accounts/function/signTransaction), puis passer le résultat dans `eth_sendRawTransaction`.
+- [`eth_sendTransaction`](https://docs.web3js.org/api/web3-eth/function/sendTransaction) est utilisé pour envoyer des transactions _non signées_, ce qui signifie que le nœud auquel vous les envoyez doit gérer votre clé privée afin de pouvoir signer la transaction avant de la diffuser sur la chaîne. Étant donné qu'Alchemy ne conserve pas les clés privées des utilisateurs, cette méthode n'est pas prise en charge.
+- [`eth_sendRawTransaction`](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction) est utilisé pour diffuser les transactions qui ont déjà été signées. Cela signifie que vous devez d'abord utiliser [`signTransaction(tx, private_key)`](https://docs.web3js.org/api/web3-eth-accounts/function/signTransaction), puis passer le résultat dans `eth_sendRawTransaction`.
 
 Lorsque vous utilisez web3, `eth_sendRawTransaction` est accessible en appelant la fonction [web3.eth.sendSignedTransaction](https://docs.web3js.org/api/web3-eth/function/sendSignedTransaction).
 
-C'est ce que nous utiliserons dans notre tutoriel.
+C'est ce que nous utiliserons dans ce tutoriel.
 
-### 6\. Qu'est-ce que la bibliothèque web3 ? {#what-is-the-web3-library}
+### 6. Qu'est-ce que la bibliothèque web3 ? {#what-is-the-web3-library}
 
-- Web3.js est une bibliothèque de wrapper autour des appels standard JSON-RPC qui est couramment utilisée dans le développement Ethereum.
-- Il existe de nombreuses bibliothèques web3 pour différents langages de programmation. Dans ce tutoriel, nous utiliserons [Alchemy Web3](https://docs.alchemy.com/reference/api-overview), écrit en JavaScript. Vous pouvez explorer d'autres options [ici](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries), telles que [ethers.js](https://docs.ethers.org/v5/).
+- Web3.js est une bibliothèque wrapper qui s'articule autour des appels JSON-RPC standards et qui est couramment utilisée dans le développement sur Ethereum.
+- Il existe de nombreuses bibliothèques web3 pour différents langages de programmation. Dans ce tutoriel, nous utiliserons [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) qui est écrit en JavaScript. Vous pouvez consulter d'autres options [ici](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) comme [ethers.js](https://docs.ethers.org/v5/).
 
-Bon, maintenant que nous avons clarifié ces points, passons au tutoriel. N'hésitez pas à poser des questions à tout moment sur le [discord](https://discord.gg/gWuC7zB) d'Alchemy !
+Maintenant que nous avons répondu à quelques-unes de ces questions, passons au tutoriel. N'hésitez pas à poser des questions à tout moment dans le [discord](https://discord.gg/gWuC7zB) d'Alchemy !
 
-### 7\. Comment envoyer des transactions sécurisées, optimisées en termes de gaz et privées ? {#how-to-send-secure-gas-optimized-and-private-transactions}
+### 7. Comment envoyer des transactions sécurisées, optimisées en gaz et privées ? {#how-to-send-secure-gas-optimized-and-private-transactions}
 
-- [Alchemy propose une suite d'APIs de transaction.](https://docs.alchemy.com/reference/transact-api-quickstart). Vous pouvez les utiliser pour envoyer des transactions renforcées, simuler des transactions avant qu'elles ne se produisent, envoyer des transactions privées et d'autres optimisées en termes de gaz
-- Vous pouvez également utiliser l'[API Notify](https://docs.alchemy.com/docs/alchemy-notify) pour être alerté lorsque votre transaction est retirée du mempool et ajoutée à la chaîne
+- [Alchemy dispose d'une suite d'API Transact](https://docs.alchemy.com/reference/transact-api-quickstart). Vous pouvez les utiliser pour envoyer des transactions renforcées, simuler des transactions avant qu'elles ne se produisent, envoyer des transactions privées et envoyer des transactions optimisées en gaz
+- Vous pouvez également utiliser l'[API Notify](https://docs.alchemy.com/docs/alchemy-notify) pour être alerté lorsque votre transaction est extraite de la mempool et ajoutée à la chaîne
 
-**NOTE :** Ce guide nécessite un compte Alchemy, une adresse Ethereum ou un portefeuille MetaMask, ainsi que l'installation de NodeJs et npm. Si ce n’est pas le cas, procédez comme suit :
+**REMARQUE :** Ce guide nécessite un compte Alchemy, une adresse Ethereum ou un portefeuille MetaMask, ainsi que l'installation de NodeJs et de npm. Si ce n'est pas le cas, suivez ces étapes :
 
-1.  [Créez un compte Alchemy gratuitement](https://auth.alchemyapi.io/signup)
-2.  [Créez un compte Metamask](https://metamask.io/) (ou obtenez une adresse Ethereum)
-3.  [Suivez ces étapes pour installer NodeJs et NPM](https://docs.alchemy.com/alchemy/guides/alchemy-for-macs)
+1. [Créer un compte Alchemy gratuit](https://auth.alchemyapi.io/signup)
+2. [Créer un compte MetaMask](https://metamask.io/) (ou obtenir une adresse Ethereum)
+3. [Suivez ces étapes pour installer NodeJs et NPM](https://docs.alchemy.com/alchemy/guides/alchemy-for-macs)
 
 ## Étapes pour envoyer votre transaction {#steps-to-sending-your-transaction}
 
-### 1\. Créer une application Alchemy sur le réseau de test Sepolia {#create-an-alchemy-app-on-the-sepolia-testnet}
+### 1. Créer une application Alchemy sur le réseau de test Sepolia {#create-an-alchemy-app-on-the-sepolia-testnet}
 
-Naviguez vers votre [tableau de bord d'Alchemy](https://dashboard.alchemyapi.io/) et créez une nouvelle application, en choisissant Sepolia (ou tout autre réseau de test) comme réseau.
+Accédez à votre [tableau de bord Alchemy](https://dashboard.alchemyapi.io/) et créez une nouvelle application, en choisissant Sepolia (ou tout autre réseau de test) pour votre réseau.
 
-### 2\. Demander de l'ETH via le robinet Sepolia {#request-eth-from-sepolia-faucet}
+### 2. Demander des ETH au robinet Sepolia {#request-eth-from-sepolia-faucet}
 
-Suivez les instructions sur le robinet [Alchemy Sepolia](https://www.sepoliafaucet.com/) pour recevoir de l'ETH. Assurez-vous d'inclure votre adresse Ethereum **Sepolia** (depuis MetaMask) et non celle d'un autre réseau. Après avoir suivi les instructions, vérifiez que vous avez reçu l'ETH dans votre portefeuille.
+Suivez les instructions sur le [robinet Sepolia d'Alchemy](https://www.sepoliafaucet.com/) pour recevoir des ETH. Assurez-vous d'inclure votre adresse Ethereum **Sepolia** (de MetaMask) et non celle d'un autre réseau. Après avoir suivi les instructions, vérifiez bien que vous avez reçu les ETH dans votre portefeuille.
 
-### 3\. Créez un nouveau répertoire de projet et placez-y un `cd` {#create-a-new-project-direction}
+### 3. Créer un nouveau répertoire de projet et y accéder {#create-a-new-project-direction}
 
-Créez un nouveau répertoire de projet à partir de la ligne de commande (terminal pour macs) et naviguez dans celui-ci :
+Créez un nouveau répertoire de projet à partir de la ligne de commande (Terminal pour Mac) et naviguez dans celui-ci :
 
 ```
 mkdir sendtx-example
 cd sendtx-example
 ```
 
-### 4\. Installer Alchemy Web3 (ou n'importe quelle autre bibliothèque web3) {#install-alchemy-web3}
+### 4. Installer Alchemy Web3 (ou toute autre bibliothèque web3) {#install-alchemy-web3}
 
-Exécutez la commande suivante dans votre dossier projet pour installer [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) :
+Exécutez la commande suivante dans votre répertoire de projet pour installer [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) :
 
-Notez que si vous souhaitez utiliser la bibliothèque ethers.js, [suivez les instructions ici](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum).
+Remarque : si vous souhaitez utiliser la bibliothèque ethers.js, [suivez les instructions ici](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum).
 
 ```
 npm install @alch/alchemy-web3
 ```
 
-### 5\. Installer dotenv {#install-dotenv}
+### 5. Installer dotenv {#install-dotenv}
 
-Nous utiliserons un fichier `.env` pour stocker en toute sécurité notre clé API et notre clé privée.
+Nous utiliserons un fichier `.env` pour stocker en toute sécurité notre clé d'API et notre clé privée.
 
 ```
 npm install dotenv --save
 ```
 
-### 6\. Créer le fichier `.env` {#create-the-dotenv-file}
+### 6. Créer le fichier `.env` {#create-the-dotenv-file}
 
-Créez un fichier `.env` dans votre répertoire de projet et ajoutez les éléments suivants (en remplaçant «` your-api-URL `» et « `your-private-key` »)
+Créez un fichier `.env` dans votre répertoire de projet et ajoutez le contenu suivant (en remplaçant « `your-api-url` » et « `your-private-key` »)
 
-- Pour trouver l’URL de votre API Alchemy, accédez à la page des détails de l’application que vous venez de créer sur votre tableau de bord, cliquez sur « View Key » (Voir clé) dans le coin supérieur droit et saisissez l’URL HTTP.
-- Pour trouver votre clé privée sur MetaMask, consultez ce [guide](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key).
+- Pour trouver l'URL de votre API Alchemy, accédez à la page des détails de l'application que vous venez de créer sur votre tableau de bord, cliquez sur « View Key » dans le coin supérieur droit et récupérez l'URL HTTP.
+- Pour trouver votre clé privée à l'aide de MetaMask, consultez ce [guide](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key).
 
 ```
 API_URL = "your-api-url"
@@ -121,16 +118,16 @@ PRIVATE_KEY = "your-private-key"
 <Alert variant="warning">
 <AlertContent>
 <AlertDescription>
-Ne propagez pas le fichier <code>.env</code> ! Assurez-vous de ne jamais partager ou exposer votre fichier <code>.env</code> avec quiconque, car vous compromettez vos secrets en le faisant. Si vous utilisez le contrôle de version, ajoutez votre <code>.env</code> à un fichier <a href="https://git-scm.com/docs/gitignore">gitignore</a>.
+Ne commitez pas le fichier <code>.env</code> ! Veillez à ne jamais partager ou exposer votre fichier <code>.env</code> avec quiconque, car vous compromettez vos secrets en le faisant. Si vous utilisez un système de contrôle de version, ajoutez votre fichier <code>.env</code> à un fichier <a href="https://git-scm.com/docs/gitignore">gitignore</a>.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
-### 7\. Créer le fichier `sendTx.js` {#create-sendtx-js}
+### 7. Créer le fichier `sendTx.js` {#create-sendtx-js}
 
-Super, maintenant que nous avons protégé nos données sensibles dans un fichier `.env`, commençons à coder. Pour notre exemple d'envoi de transaction, nous renverrons l'ETH via le robinet Sepolia.
+Super, maintenant que nos données sensibles sont protégées dans un fichier `.env`, commençons à coder. Pour notre exemple d'envoi de transaction, nous allons renvoyer des ETH au robinet Sepolia.
 
-Créez un fichier `sendTx.js`, dans lequel nous allons configurer et envoyer notre exemple de transaction et ajoutez-y les lignes de code suivantes :
+Créez un fichier `sendTx.js`, dans lequel nous allons configurer et envoyer notre exemple de transaction, et ajoutez-y les lignes de code suivantes :
 
 ```
 async function main() {
@@ -138,25 +135,25 @@ async function main() {
     const { API_URL, PRIVATE_KEY } = process.env;
     const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
     const web3 = createAlchemyWeb3(API_URL);
-    const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: replace this address with your own public address
+    const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: remplacez cette adresse par votre propre adresse publique
 
-    const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // nonce starts counting from 0
+    const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // le nonce commence à compter à partir de 0
 
     const transaction = {
-     'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // faucet address to return eth
+     'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // adresse du robinet pour retourner les ETH
      'value': 1000000000000000000, // 1 ETH
      'gas': 30000,
      'nonce': nonce,
-     // optional data field to send message or execute smart contract
+     // champ de données facultatif pour envoyer un message ou exécuter un contrat intelligent
     };
 
     const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);
 
     web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(error, hash) {
     if (!error) {
-      console.log("🎉 The hash of your transaction is: ", hash, "\n Check Alchemy's Mempool to view the status of your transaction!");
+      console.log("🎉 Le hachage de votre transaction est : ", hash, "\n Consultez le Mempool d'Alchemy pour voir le statut de votre transaction !");
     } else {
-      console.log("❗Something went wrong while submitting your transaction:", error)
+      console.log("❗Quelque chose s'est mal passé lors de la soumission de votre transaction :", error)
     }
    });
 }
@@ -164,47 +161,48 @@ async function main() {
 main();
 ```
 
-Veillez à remplacer l'adresse sur la **ligne 6** par votre propre adresse publique.
+Veillez à remplacer l'adresse de la **ligne 6** par votre propre adresse publique.
 
-Avant de nous lancer dans l’exécution de ce code, parlons ici de certains de ses composants.
+Maintenant, avant de nous lancer dans l'exécution de ce code, parlons de certains des composants.
 
-- `nonce` : La spécification nonce est utilisée pour garder une trace du nombre de transactions envoyées depuis votre adresse. Nous en avons besoin pour des raisons de sécurité et pour éviter [les attaques par répétition](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce). Pour obtenir le nombre de transactions envoyées à partir de votre adresse, nous utilisons [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
-- `transaction` : L'objet de la transaction présente quelques aspects que nous devons spécifier
-  - `to` : C'est l'adresse à laquelle nous voulons envoyer l'ETH. Dans notre cas, nous renvoyons l'ETH au robinet [Sepolia](https://sepoliafaucet.com/) auquel nous avons initialement fait la demande.
-  - `value` : C'est le montant que nous souhaitons envoyer, spécifié en Wei où 10^18 Wei = 1 ETH.
-  - `gas` : Il existe plusieurs façons de déterminer la bonne quantité de gaz à inclure dans votre transaction. Alchemy dispose même d'un [lien de rappel du prix du gaz](https://docs.alchemyapi.io/guides/alchemy-notify#address-activity-1) pour vous avertir lorsque le prix du gaz tombe sous un certain seuil. Pour les transactions sur le réseau principal, il est bon de recourir à un estimateur de gaz comme [ETH Gas Station](https://ethgasstation.info/) pour déterminer la bonne quantité de gaz à intégrer. 21 000 est la quantité minimale de gaz qu'une opération sur Ethereum va utiliser. Ainsi, pour s'assurer que notre transaction sera exécutée, nous utiliserons ici 30 000 unités.
-  - `nonce` : voir la définition de nonce ci-dessus. Nonce commence à compter à partir de zéro.
-  - [OPTIONAL] données : Utilisé pour envoyer des informations supplémentaires avec votre transfert ou pour appeler un contrat intelligent. Non requis pour les transferts de solde. Consultez la note ci-dessous.
-- `signedTx` : Pour signer l'objet de notre transaction nous utiliserons la méthode `signTransaction` avec notre `PRIVATE_KEY`
-- `sendSignedTransaction` : Une fois que nous disposons d'une transaction signée, nous pouvons l'envoyer pour être intégrée dans un bloc ultérieur en utilisant `sendSignedTransaction`.
+- `nonce` : La spécification du nonce est utilisée pour suivre le nombre de transactions envoyées depuis votre adresse. Nous en avons besoin pour des raisons de sécurité et pour prévenir les [attaques par rejeu](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce). Pour obtenir le nombre de transactions envoyées depuis votre adresse, nous utilisons [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
+- `transaction` : L'objet de transaction comporte quelques aspects que nous devons spécifier
+  - `to` : C'est l'adresse à laquelle nous voulons envoyer des ETH. Dans ce cas, nous renvoyons des ETH au [robinet Sepolia](https://sepoliafaucet.com/) que nous avons utilisé au départ.
+  - `value` : Il s'agit du montant que nous souhaitons envoyer, spécifié en Wei, où 10^18 Wei = 1 ETH
+  - `gas` : Il existe de nombreuses façons de déterminer la bonne quantité de gaz à inclure dans votre transaction. Alchemy dispose même d'un [webhook de prix du gaz](https://docs.alchemyapi.io/guides/alchemy-notify#address-activity-1) pour vous avertir lorsque le prix du gaz tombe en dessous d'un certain seuil. Pour les transactions sur le réseau principal, il est de bonne pratique de consulter un estimateur de gaz comme [ETH Gas Station](https://ethgasstation.info/) pour déterminer la quantité de gaz appropriée à inclure. 21000 est la quantité minimale de gaz qu'une opération sur Ethereum utilisera. Pour nous assurer que notre transaction sera exécutée, nous mettons donc 30000 ici.
+  - `nonce` : voir la définition du nonce ci-dessus. Le nonce commence à compter à partir de zéro.
+  - [FACULTATIF] data : Utilisé pour envoyer des informations supplémentaires avec votre transfert ou pour appeler un contrat intelligent. Non requis pour les transferts de solde. Consultez la note ci-dessous.
+- `signedTx` : Pour signer notre objet de transaction, nous utiliserons la méthode `signTransaction` avec notre `PRIVATE_KEY`
+- `sendSignedTransaction` : Une fois que nous avons une transaction signée, nous pouvons l'envoyer pour qu'elle soit incluse dans un bloc ultérieur en utilisant `sendSignedTransaction`
 
-**Remarque concernant les données** Il existe deux types principaux de transactions qui peuvent être envoyées sur Ethereum.
+**Remarque sur les données**
+Il existe deux principaux types de transactions qui peuvent être envoyées sur Ethereum.
 
-- Transfert du solde : Envoyer des ETH d'une adresse à une autre. Aucun champ de données n'est requis. Cependant, si vous souhaitez envoyer des informations supplémentaires avec votre transaction, vous pouvez inclure ces informations au format HEX dans ce champ.
-  - Imaginons par exemple que nous souhaitions écrire le hachage d'un document IPFS dans la chaîne Ethereum afin de lui donner un horodatage immuable. Notre champ de données devrait alors ressembler à des données : `web3.utils.toHex(‘IPFS hash‘)`. Et maintenant, toute personne peut interroger la chaîne et voir quand ce document a été ajouté.
-- Transaction de contrat intelligent : Exécuter le code d'un contrat intelligent sur la chaîne. Dans ce cas, le champ de données doit contenir la fonction intelligente que vous souhaitez exécuter, ainsi que tout paramètre.
-  - Pour un exemple pratique, consultez l'Étape 8 de ce [Tutoriel Hello World](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#step-8-create-the-transaction).
+- Transfert de solde : Envoyez des ETH d'une adresse à une autre. Aucun champ de données n'est requis. Cependant, si vous souhaitez envoyer des informations supplémentaires avec votre transaction, vous pouvez inclure ces informations au format HEX dans ce champ.
+  - Par exemple, supposons que nous voulions écrire le hachage d'un document IPFS sur la chaîne Ethereum afin de lui donner un horodatage immuable. Notre champ de données devrait alors ressembler à : `data: web3.utils.toHex('hachage IPFS')`. Et maintenant, n'importe qui peut interroger la chaîne et voir quand ce document a été ajouté.
+- Transaction de contrat intelligent : Exécutez du code de contrat intelligent sur la chaîne. Dans ce cas, le champ de données doit contenir la fonction intelligente que vous souhaitez exécuter, ainsi que tous les paramètres.
+  - Pour un exemple pratique, consultez l'étape 8 de ce [Tutoriel Hello World](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#step-8-create-the-transaction).
 
-### 8\. Exécuter le code en utilisant `node sendTx.js` {#run-the-code-using-node-sendtx-js}
+### 8. Exécuter le code avec `node sendTx.js` {#run-the-code-using-node-sendtx-js}
 
-Retournez à votre terminal ou votre invite de ligne de commande et exécutez :
+Retournez à votre terminal ou à votre ligne de commande et exécutez :
 
 ```
 node sendTx.js
 ```
 
-### 9\. Consulter votre transaction dans le Mempool {#see-your-transaction-in-the-mempool}
+### 9. Voir votre transaction dans le Mempool {#see-your-transaction-in-the-mempool}
 
-Ouvrez la page [Mempool](https://dashboard.alchemyapi.io/mempool) dans votre tableau de bord Alchemy et filtrez avec l'application que vous avez créée pour trouver votre transaction. C'est là que nous pouvons observer le passage de l'état de notre transaction de l'état en attente à l'état miné (si la transaction a abouti) ou à l'état abandonné en cas d'échec. Veillez à opter pour « All » (Tous) afin de visualiser les transactions « mined » (minées), « pending » (en attente) et « dropped » (abandonnées). Vous pouvez également trouver votre transaction en recherchant les transactions envoyées à l'adresse `0x31b98d14007bdee637298086988a0bbd31184523`.
+Ouvrez la [page Mempool](https://dashboard.alchemyapi.io/mempool) dans votre tableau de bord Alchemy et filtrez par l'application que vous avez créée pour trouver votre transaction. C'est là que nous pouvons observer le passage de notre transaction de l'état « en attente » à l'état « minée » (si réussie) ou à l'état « abandonnée » (en cas d'échec). Veillez à le laisser sur « All » (Tous) afin de capturer les transactions « mined » (minées), « pending » (en attente) et « dropped » (abandonnées). Vous pouvez également rechercher votre transaction en cherchant les transactions envoyées à l'adresse `0x31b98d14007bdee637298086988a0bbd31184523` .
 
-Pour afficher les détails de votre transaction une fois que vous l'avez trouvée, sélectionnez le hachage tx, qui devrait vous amener à une vue qui ressemble à ceci :
+Pour afficher les détails de votre transaction une fois que vous l'avez trouvée, sélectionnez le hachage de la transaction (tx hash), ce qui devrait vous amener à une vue qui ressemble à ceci :
 
-![Capture d'écran Mempool watcher](./mempool.png)
+![Capture d'écran de l'observateur de la mempool](./mempool.png)
 
-À partir de là, vous pouvez visualiser votre transaction sur Etherscan en cliquant sur l'icône cerclée en rouge !
+De là, vous pouvez voir votre transaction sur Etherscan en cliquant sur l'icône entourée en rouge !
 
-**Youpi ! Vous venez d’envoyer votre première transaction Ethereum en utilisant Alchemy 🎉**
+**Youpi !** Vous venez d'envoyer votre première transaction Ethereum avec Alchemy 🎉\*\*
 
-_Pour des commentaires et des suggestions sur ce guide, veuillez envoyer un message à Elan sur le [Discord d'Alchemy](https://discord.gg/A39JVCM) !_
+_Pour tout commentaire ou suggestion concernant ce guide, veuillez envoyer un message à Elan sur le [discord](https://discord.gg/A39JVCM) d'Alchemy !_
 
-_Publié à l’origine sur [https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy](https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy)_
+_Publié à l'origine sur [https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy](https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy)_
diff --git a/public/content/translations/fr/developers/tutorials/server-components/index.md b/public/content/translations/fr/developers/tutorials/server-components/index.md
new file mode 100644
index 00000000000..2c99c0e9447
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/server-components/index.md
@@ -0,0 +1,295 @@
+---
+title: "Composants de serveur et agents pour les applications web3"
+description: "Après avoir lu ce tutoriel, vous serez en mesure d'écrire des serveurs TypeScript qui écoutent les événements sur une blockchain et y répondent en conséquence avec leurs propres transactions. Cela vous permettra d'écrire des applications centralisées (car le serveur est un point de défaillance unique), mais qui peuvent interagir avec des entités web3. Les mêmes techniques peuvent également être utilisées pour écrire un agent qui répond aux événements en chaîne sans intervention humaine."
+
+author: Ori Pomerantz
+lang: fr
+tags: [ "agent", "serveur", "hors-chaîne" ]
+skill: beginner
+published: 2024-07-15
+---
+
+## Introduction {#introduction}
+
+Dans la plupart des cas, une application décentralisée (dapp) utilise un serveur pour distribuer le logiciel, mais toute l'interaction réelle se produit entre le client (généralement un navigateur Web) et la blockchain.
+
+![Interaction normale entre le serveur Web, le client et la blockchain](./fig-1.svg)
+
+Cependant, il existe des cas où une application bénéficierait d'un composant serveur qui s'exécute de manière indépendante. Un tel serveur serait capable de répondre à des événements et à des requêtes provenant d'autres sources, comme une API, en émettant des transactions.
+
+![L'interaction avec l'ajout d'un serveur](./fig-2.svg)
+
+Il y a plusieurs tâches possibles qu'un tel serveur pourrait accomplir.
+
+- Détenteur d'état secret. Dans les jeux, il est souvent utile de ne pas mettre à la disposition des joueurs toutes les informations que le jeu connaît. Cependant, _il n'y a pas de secrets sur la blockchain_, toute information qui s'y trouve est facile à découvrir pour n'importe qui. Par conséquent, si une partie de l'état du jeu doit rester secrète, elle doit être stockée ailleurs (et éventuellement faire vérifier les effets de cet état à l'aide de [preuves à divulgation nulle de connaissance](/zero-knowledge-proofs)).
+
+- Oracle centralisé. Si les enjeux sont suffisamment faibles, un serveur externe qui lit des informations en ligne puis les publie sur la chaîne peut être suffisant pour être utilisé comme un [oracle](/developers/docs/oracles/).
+
+- Agent. Rien ne se passe sur la blockchain sans une transaction pour l'activer. Un serveur peut agir au nom d'un utilisateur pour effectuer des actions telles que l'[arbitrage](/developers/docs/mev/#mev-examples-dex-arbitrage) lorsque l'occasion se présente.
+
+## Exemple de programme {#sample-program}
+
+Vous pouvez voir un exemple de serveur [sur github](https://github.com/qbzzt/20240715-server-component). Ce serveur écoute les événements provenant de [ce contrat](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=contract_code), une version modifiée du Greeter de Hardhat. Lorsque le message de bienvenue est modifié, il le rétablit.
+
+Pour l'exécuter :
+
+1. Cloner le dépôt.
+
+   ```sh copy
+   git clone https://github.com/qbzzt/20240715-server-component.git
+   cd 20240715-server-component
+   ```
+
+2. Installez les paquets nécessaires. Si vous ne l'avez pas déjà, [installez d'abord Node](https://nodejs.org/en/download/package-manager).
+
+   ```sh copy
+   npm install
+   ```
+
+3. Modifiez `.env` pour spécifier la clé privée d'un compte qui possède des ETH sur le réseau de test Holesky. Si vous n'avez pas d'ETH sur Holesky, vous pouvez [utiliser ce faucet](https://holesky-faucet.pk910.de/).
+
+   ```sh filename=".env" copy
+   PRIVATE_KEY=0x <la clé privée va ici>
+   ```
+
+4. Démarrer le serveur.
+
+   ```sh copy
+   npm start
+   ```
+
+5. Allez sur [un explorateur de blocs](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=write_contract), et en utilisant une adresse différente de celle qui a la clé privée, modifiez le message de bienvenue. Voyez que le message de bienvenue est automatiquement rétabli.
+
+### Comment ça marche ? {#how-it-works}
+
+La manière la plus simple de comprendre comment écrire un composant serveur est de parcourir l'exemple ligne par ligne.
+
+#### `src/app.ts` {#src-app-ts}
+
+La grande majorité du programme est contenue dans [`src/app.ts`](https://github.com/qbzzt/20240715-server-component/blob/main/src/app.ts).
+
+##### Création des objets prérequis
+
+```typescript
+import {
+  createPublicClient,
+  createWalletClient,
+  getContract,
+  http,
+  Address,
+} from "viem"
+```
+
+Ce sont les entités [Viem](https://viem.sh/) dont nous avons besoin, les fonctions et [le type `Address`](https://viem.sh/docs/glossary/types#address). Ce serveur est écrit en [TypeScript](https://www.typescriptlang.org/), qui est une extension de JavaScript qui le rend [fortement typé](https://en.wikipedia.org/wiki/Strong_and_weak_typing).
+
+```typescript
+import { privateKeyToAccount } from "viem/accounts"
+```
+
+[Cette fonction](https://viem.sh/docs/accounts/privateKey) nous permet de générer les informations du portefeuille, y compris l'adresse, correspondant à une clé privée.
+
+```typescript
+import { holesky } from "viem/chains"
+```
+
+Pour utiliser une blockchain dans Viem, vous devez importer sa définition. Dans ce cas, nous voulons nous connecter à la blockchain de test [Holesky](https://github.com/eth-clients/holesky).
+
+```typescript
+// C'est ainsi que nous ajoutons les définitions dans .env à process.env.
+import * as dotenv from "dotenv"
+dotenv.config()
+```
+
+C'est ainsi que nous lisons `.env` dans l'environnement. Nous en avons besoin pour la clé privée (voir plus loin).
+
+```typescript
+const greeterAddress : Address = "0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6"
+const greeterABI = [
+    {
+        "inputs": [
+            {
+                "internalType": "string",
+                "name": "_greeting",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+         .
+         .
+         .
+    {
+        "inputs": [
+            {
+                "internalType": "string",
+                "name": "_greeting",
+                "type": "string"
+            }
+        ],
+        "name": "setGreeting",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+] as const
+```
+
+Pour utiliser un contrat, nous avons besoin de son adresse et de son [ABI](/glossary/#abi). Nous fournissons les deux ici.
+
+En JavaScript (et donc en TypeScript), vous ne pouvez pas attribuer une nouvelle valeur à une constante, mais vous _pouvez_ modifier l'objet qui y est stocké. En utilisant le suffixe `as const`, nous indiquons à TypeScript que la liste elle-même est constante et ne peut pas être modifiée.
+
+```typescript
+const publicClient = createPublicClient({
+  chain: holesky,
+  transport: http(),
+})
+```
+
+Créer un [client public](https://viem.sh/docs/clients/public.html) Viem. Les clients publics n'ont pas de clé privée attachée et ne peuvent donc pas envoyer de transactions. Ils peuvent appeler des [fonctions `view`](https://www.tutorialspoint.com/solidity/solidity_view_functions.htm), lire les soldes des comptes, etc.
+
+```typescript
+const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
+```
+
+Les variables d'environnement sont disponibles dans [`process.env`](https://www.totaltypescript.com/how-to-strongly-type-process-env). Cependant, TypeScript est fortement typé. Une variable d'environnement peut être n'importe quelle chaîne de caractères, ou vide, donc le type d'une variable d'environnement est `string | undefined`. Cependant, une clé est définie dans Viem comme `0x${string}` (`0x` suivi d'une chaîne de caractères). Ici, nous indiquons à TypeScript que la variable d'environnement `PRIVATE_KEY` sera de ce type. Si ce n'est pas le cas, nous obtiendrons une erreur d'exécution.
+
+La fonction [`privateKeyToAccount`](https://viem.sh/docs/accounts/privateKey) utilise ensuite cette clé privée pour créer un objet de compte complet.
+
+```typescript
+const walletClient = createWalletClient({
+  account,
+  chain: holesky,
+  transport: http(),
+})
+```
+
+Ensuite, nous utilisons l'objet de compte pour créer un [client de portefeuille](https://viem.sh/docs/clients/wallet). Ce client a une clé privée et une adresse, il peut donc être utilisé pour envoyer des transactions.
+
+```typescript
+const greeter = getContract({
+  address: greeterAddress,
+  abi: greeterABI,
+  client: { public: publicClient, wallet: walletClient },
+})
+```
+
+Maintenant que nous avons tous les prérequis, nous pouvons enfin créer une [instance de contrat](https://viem.sh/docs/contract/getContract). Nous utiliserons cette instance de contrat pour communiquer avec le contrat en chaîne.
+
+##### Lecture depuis la blockchain
+
+```typescript
+console.log(`Message de bienvenue actuel :`, await greeter.read.greet())
+```
+
+Les fonctions de contrat qui sont en lecture seule ([`view`](https://www.tutorialspoint.com/solidity/solidity_view_functions.htm) et [`pure`](https://www.tutorialspoint.com/solidity/solidity_pure_functions.htm)) sont disponibles sous `read`. Dans ce cas, nous l'utilisons pour accéder à la fonction [`greet`](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=read_contract#cfae3217), qui renvoie le message de bienvenue.
+
+JavaScript est monothread, donc lorsque nous lançons un processus de longue durée, nous devons [spécifier que nous le faisons de manière asynchrone](https://eloquentjavascript.net/11_async.html#h-XvLsfAhtsE). L'appel à la blockchain, même pour une opération en lecture seule, nécessite un aller-retour entre l'ordinateur et un nœud de la blockchain. C'est la raison pour laquelle nous spécifions ici que le code doit `await` le résultat.
+
+Si vous êtes intéressé par son fonctionnement, vous pouvez [en lire plus ici](https://www.w3schools.com/js/js_promise.asp), mais en pratique, tout ce que vous devez savoir, c'est que vous devez `await` les résultats si vous lancez une opération qui prend beaucoup de temps, et que toute fonction qui le fait doit être déclarée `async`.
+
+##### Émission de transactions
+
+```typescript
+const setGreeting = async (greeting: string): Promise<any> => {
+```
+
+C'est la fonction que vous appelez pour émettre une transaction qui modifie le message de bienvenue. Comme il s'agit d'une opération longue, la fonction est déclarée comme `async`. En raison de l'implémentation interne, toute fonction `async` doit retourner un objet `Promise`. Dans ce cas, `Promise<any>` signifie que nous ne spécifions pas ce qui sera exactement retourné dans la `Promise`.
+
+```typescript
+const txHash = await greeter.write.setGreeting([greeting])
+```
+
+Le champ `write` de l'instance du contrat contient toutes les fonctions qui écrivent dans l'état de la blockchain (celles qui nécessitent l'envoi d'une transaction), telles que [`setGreeting`](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=write_contract#a4136862). Les paramètres, s'il y en a, sont fournis sous forme de liste, et la fonction renvoie le hachage de la transaction.
+
+```typescript
+    console.log(`Correction en cours, voir https://eth-holesky.blockscout.com/tx/${txHash}`)
+
+    return txHash
+}
+```
+
+Signaler le hachage de la transaction (dans le cadre d'une URL vers l'explorateur de blocs pour la visualiser) et le renvoyer.
+
+##### Répondre aux événements
+
+```typescript
+greeter.watchEvent.SetGreeting({
+```
+
+[La fonction `watchEvent`](https://viem.sh/docs/actions/public/watchEvent) vous permet de spécifier qu'une fonction doit s'exécuter lorsqu'un événement est émis. Si vous ne vous souciez que d'un seul type d'événement (dans ce cas, `SetGreeting`), vous pouvez utiliser cette syntaxe pour vous limiter à ce type d'événement.
+
+```typescript
+    onLogs: logs => {
+```
+
+La fonction `onLogs` est appelée lorsqu'il y a des entrées de journal. Dans Ethereum, « log » et « événement » sont généralement interchangeables.
+
+```typescript
+console.log(
+  `L'adresse ${logs[0].args.sender} a changé le message de bienvenue en ${logs[0].args.greeting}`
+)
+```
+
+Il pourrait y avoir plusieurs événements, mais par souci de simplicité, nous ne nous intéressons qu'au premier. `logs[0].args` sont les arguments de l'événement, dans ce cas `sender` et `greeting`.
+
+```typescript
+        if (logs[0].args.sender != account.address)
+            setGreeting(`${account.address} insiste pour que ce soit Hello!`)
+    }
+})
+```
+
+Si l'expéditeur n'est _pas_ ce serveur, utilisez `setGreeting` pour changer le message de bienvenue.
+
+#### `package.json` {#package-json}
+
+[Ce fichier](https://github.com/qbzzt/20240715-server-component/blob/main/package.json) contrôle la configuration de [Node.js](https://nodejs.org/en). Cet article n'explique que les définitions importantes.
+
+```json
+{
+  "main": "dist/index.js",
+```
+
+Cette définition spécifie quel fichier JavaScript exécuter.
+
+```json
+  "scripts": {
+    "start": "tsc && node dist/app.js",
+  },
+```
+
+Les scripts sont diverses actions de l'application. Dans ce cas, le seul que nous ayons est `start`, qui compile puis exécute le serveur. La commande `tsc` fait partie du package `typescript` et compile TypeScript en JavaScript. Si vous voulez l'exécuter manuellement, il se trouve dans `node_modules/.bin`. La deuxième commande exécute le serveur.
+
+```json
+  "type": "module",
+```
+
+Il existe plusieurs types d'applications Node JavaScript. Le type `module` nous permet d'avoir `await` dans le code de premier niveau, ce qui est important lorsque vous effectuez des opérations lentes (et donc asynchrones).
+
+```json
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  },
+```
+
+Ce sont des packages qui ne sont requis que pour le développement. Ici, nous avons besoin de `typescript` et comme nous l'utilisons avec Node.js, nous obtenons également les types pour les variables et les objets de Node, tels que `process`. [La notation `^<version>`](https://github.com/npm/node-semver?tab=readme-ov-file#caret-ranges-123-025-004) signifie cette version ou une version supérieure qui n'apporte pas de changements cassants. Voir [ici](https://semver.org) pour plus d'informations sur la signification des numéros de version.
+
+```json
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "viem": "2.14.1"
+  }
+}
+```
+
+Ce sont des packages qui sont requis à l'exécution, lors de l'exécution de `dist/app.js`.
+
+## Conclusion {#conclusion}
+
+Le serveur centralisé que nous avons créé ici fait son travail, qui est d'agir en tant qu'agent pour un utilisateur. Toute autre personne qui souhaite que la dapp continue de fonctionner et qui est prête à dépenser le gaz peut exécuter une nouvelle instance du serveur avec sa propre adresse.
+
+Cependant, cela ne fonctionne que lorsque les actions du serveur centralisé peuvent être facilement vérifiées. Si le serveur centralisé possède des informations d'état secrètes ou exécute des calculs difficiles, c'est une entité centralisée à laquelle vous devez faire confiance pour utiliser l'application, ce qui est exactement ce que les blockchains essaient d'éviter. Dans un futur article, je prévois de montrer comment utiliser les [preuves à divulgation nulle de connaissance](/zero-knowledge-proofs) pour contourner ce problème.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md b/public/content/translations/fr/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
index 9aaea59cb8a..d92eebbc7a8 100644
--- a/public/content/translations/fr/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
+++ b/public/content/translations/fr/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
@@ -1,10 +1,8 @@
 ---
 title: Configurer web3.js pour utiliser la blockchain Ethereum en JavaScript
-description: Comment utiliser un contrat intelligent pour interagir avec un jeton en utilisant le langage Solidity
+description: "Apprenez à mettre en place et à configurer la bibliothèque web3.js pour interagir avec la blockchain Ethereum à partir d'applications JavaScript."
 author: "jdourlens"
-tags:
-  - "web3.js"
-  - "javascript"
+tags: [ "web3.js", "JavaScript" ]
 skill: beginner
 lang: fr
 published: 2020-04-11
@@ -15,7 +13,7 @@ address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 
 Dans ce tutoriel, nous allons voir comment débuter avec [web3.js](https://web3js.readthedocs.io/) pour interagir avec la blockchain Ethereum. Web3.js peut être utilisé à la fois en front-end et en back-end pour lire les données de la blockchain, effectuer des transactions et même déployer des contrats intelligents.
 
-La première étape consiste à inclure web3.js dans votre projet. Pour l'utiliser dans une page web, vous pouvez importer la bibliothèque en utilisant un CDN comme JSDeliver.
+La première étape consiste à inclure web3.js dans votre projet. Pour l'utiliser dans une page web, vous pouvez importer la bibliothèque directement en utilisant un CDN comme JSDeliver.
 
 ```html
 <script src="https://cdn.jsdelivr.net/npm/web3@latest/dist/web3.min.js"></script>
@@ -27,19 +25,19 @@ Si vous préférez installer la bibliothèque pour l'utiliser dans votre back-en
 npm install web3 --save
 ```
 
-Ensuite, pour importer Web3.js dans un script Node.js ou un projet frontend, vous pouvez utiliser l'instruction JavaScript suivante :
+Ensuite, pour importer Web3.js dans un script Node.js ou un projet frontend Browserify, vous pouvez utiliser la ligne JavaScript suivante :
 
 ```js
 const Web3 = require("web3")
 ```
 
-Maintenant que nous avons importé la bibliothèque au sein du projet, nous devons l'initialiser. Notre projet doit être en mesure de communiquer avec la blockchain. La plupart des librairies Ethereum communiquent avec un [nœud](/developers/docs/nodes-and-clients/) via des appels RPC. Pour lancer notre fournisseur Web3, nous instancierons une instance Web3 en passant comme constructeur l'URL du fournisseur. Si vous disposez d'un nœud ou [d'une instance Ganache qui s'exécute sur votre ordinateur](https://ethereumdev.io/testing-your-smart-contract-with-existing-protocols-ganache-fork/) cela ressemblera à ça :
+Maintenant que nous avons inclus la bibliothèque dans le projet, nous devons l'initialiser. Votre projet doit pouvoir communiquer avec la blockchain. La plupart des bibliothèques Ethereum communiquent avec un [nœud](/developers/docs/nodes-and-clients/) via des appels RPC. Pour lancer notre fournisseur Web3, nous instancierons une instance Web3 en passant comme constructeur l'URL du fournisseur. Si vous avez un nœud ou une [instance de ganache qui s'exécute sur votre ordinateur](https://ethereumdev.io/testing-your-smart-contract-with-existing-protocols-ganache-fork/), cela ressemblera à ceci :
 
 ```js
 const web3 = new Web3("http://localhost:8545")
 ```
 
-Si vous souhaitez accéder directement à un nœud hébergé, vous pouvez utiliser Infura. Vous pouvez également utiliser les programmes gratuits fournis par [Cloudflare](https://cloudflare-eth.com/), [Moralis](https://moralis.io), ou [Alchimie](https://alchemy.com/ethereum):
+Si vous souhaitez accéder directement à un nœud hébergé, vous trouverez des options sur les [nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service).
 
 ```js
 const web3 = new Web3("https://cloudflare-eth.com")
@@ -56,7 +54,7 @@ web3.eth.getBlockNumber(function (error, result) {
 })
 ```
 
-Si vous exécutez ce programme, il affichera simplement le dernier numéro de bloc : le haut de la blockchain. Vous pouvez également utiliser les appels de fonctions `await/async` pour éviter d'imbriquer les rappels dans votre code :
+Si vous exécutez ce programme, il affichera simplement le dernier numéro de bloc : le sommet de la blockchain. Vous pouvez également utiliser les appels de fonction `await/async` pour éviter d'imbriquer des callbacks dans votre code :
 
 ```js
 async function getBlockNumber() {
@@ -68,27 +66,27 @@ async function getBlockNumber() {
 getBlockNumber()
 ```
 
-Vous pouvez consulter toutes les fonctions disponibles sur l'instance Web3 dans la [documentation officielle de Web3.js](https://docs.web3js.org/).
+Vous pouvez voir toutes les fonctions disponibles sur l'instance Web3 dans [la documentation officielle de web3.js](https://docs.web3js.org/).
 
-La plupart des bibliothèques Web3 sont asynchrones parce qu'en arrière-plan, la bibliothèque fait appel au serveur JSON RPC pour accéder au noeud qui renvoie le résultat.
+La plupart des bibliothèques Web3 sont asynchrones car, en arrière-plan, la bibliothèque effectue des appels JSON-RPC au nœud qui renvoie le résultat.
 
 <Divider />
 
 Si vous travaillez dans le navigateur, certains portefeuilles injectent directement une instance Web3 et vous devriez essayer de l'utiliser dans la mesure du possible, surtout si vous prévoyez d'interagir avec l'adresse Ethereum de l'utilisateur pour effectuer des transactions.
 
-Voici le snippet pour détecter si un portefeuille MetaMask est disponible et si c'est le cas, tenter de l'activer. Cela vous permettra plus tard de lire le solde de l'utilisateur et de valider les transactions que vous souhaitez faire sur la blockchain Ethereum :
+Voici l'extrait de code pour détecter si un portefeuille MetaMask est disponible et essayer de l'activer si c'est le cas. Cela vous permettra par la suite de lire le solde de l'utilisateur et de lui permettre de valider les transactions que vous souhaitez lui faire effectuer sur la blockchain Ethereum :
 
 ```js
 if (window.ethereum != null) {
   state.web3 = new Web3(window.ethereum)
   try {
-    // Request account access if needed
+    // Demander l'accès au compte si nécessaire
     await window.ethereum.enable()
-    // Accounts now exposed
+    // Comptes maintenant exposés
   } catch (error) {
-    // User denied account access...
+    // L'utilisateur a refusé l'accès au compte...
   }
 }
 ```
 
-Des alternatives aux web3.js comme [Ethers.js](https://docs.ethers.io/) existent et sont également couramment utilisées. Dans le prochain tutoriel, nous verrons [comment prendre en charge facilement les nouveaux blocs entrants sur la blockchain et voir ce qu'ils contiennent](https://ethereumdev.io/listening-to-new-transactions-happening-on-the-blockchain/).
+Des alternatives à web3.js comme [Ethers.js](https://docs.ethers.io/) existent et sont également couramment utilisées. Dans le prochain tutoriel, nous verrons [comment écouter facilement les nouveaux blocs entrants sur la blockchain et voir ce qu'ils contiennent](https://ethereumdev.io/listening-to-new-transactions-happening-on-the-blockchain/).
diff --git a/public/content/translations/fr/developers/tutorials/short-abi/index.md b/public/content/translations/fr/developers/tutorials/short-abi/index.md
index 1d49f96f1bc..3e8966bc61c 100644
--- a/public/content/translations/fr/developers/tutorials/short-abi/index.md
+++ b/public/content/translations/fr/developers/tutorials/short-abi/index.md
@@ -1,85 +1,106 @@
 ---
-title: "Minimiser les ABIs pour l'optimisation des données d'appel"
-description: Optimisation des contrats intelligents pour les Rollups optimistes
+title: "ABI courtes pour l'optimisation des données d'appel"
+description: Optimisation des contrats intelligents pour les rollups optimistes
 author: Ori Pomerantz
 lang: fr
-tags:
-  - "Couche 2"
+tags: [ "couche 2" ]
 skill: intermediate
 published: 2022-04-01
 ---
 
 ## Introduction {#introduction}
 
-Dans cet article, vous en apprendrez plus sur les [Rollups optimistes](/developers/docs/scaling/optimistic-rollups), le coût des transactions qui leur est appliqué, et comment la structure de coûts distincte nous oblige à optimiser différents éléments sur le réseau principal Ethereum. Vous apprendrez également à implémenter cette optimisation.
+Dans cet article, vous en apprendrez plus sur les [rollups optimistes](/developers/docs/scaling/optimistic-rollups), le coût des transactions qui leur est appliqué et la manière dont cette structure de coûts différente nous oblige à optimiser pour des éléments différents de ceux du réseau principal d'Ethereum.
+Vous apprendrez également comment mettre en œuvre cette optimisation.
 
-### Devoir de transparence {#full-disclosure}
+### Transparence totale {#full-disclosure}
 
-Je suis un employé à temps plein chez [Optimism](https://www.optimism.io/), les exemples illustrant cet article seront donc exécutés sur Optimism. Cependant, la technique expliquée ici devrait aussi bien fonctionner pour d'autres rollups.
+Je suis un employé à temps plein d'[Optimism](https://www.optimism.io/), les exemples de cet article seront donc exécutés sur Optimism.
+Cependant, la technique expliquée ici devrait aussi bien fonctionner pour d'autres rollups.
 
 ### Terminologie {#terminology}
 
-Lorsque l'on parle des rollups, le terme 'Couche 1' (L1) est généralement utilisé pour le réseau principal, le réseau Ethereum de production. Le terme 'Couche 2' (L2) est utilisé pour les rollups ou tout autre système qui se base sur L1 pour la sécurité, mais qui réalise son traitement hors chaîne.
+Lorsque l'on parle des rollups, le terme « couche 1 » (L1) est utilisé pour le réseau principal, le réseau de production Ethereum.
+Le terme « couche 2 » (L2) est utilisé pour le rollup ou tout autre système qui s'appuie sur L1 pour la sécurité, mais qui effectue la plupart de son traitement hors chaîne.
 
-## Comment pouvons-nous encore réduire le coût des transactions L2 ? {#how-can-we-further-reduce-the-cost-of-L2-transactions}
+## Comment pouvons-nous réduire davantage le coût des transactions L2 ? {#how-can-we-further-reduce-the-cost-of-L2-transactions}
 
-[Les Rollups optimistes](/developers/docs/scaling/optimistic-rollups) doivent conserver un registre de chaque historique de transaction afin que toute personne qui le souhaite puisse le passer en revue et vérifier que l'état actuel est correct. La façon la plus économique de récupérer des données sur le réseau principal Ethereum est de les écrire en tant que données d'appel. Cette solution a été choisie à la fois par [Optimism](https://help.optimism.io/hc/en-us/articles/4413163242779-What-is-a-rollup-) et [Arbitrum](https://developer.offchainlabs.com/docs/rollup_basics#intro-to-rollups).
+Les [rollups optimistes](/developers/docs/scaling/optimistic-rollups) doivent conserver un enregistrement de chaque transaction historique afin que n'importe qui puisse les parcourir et vérifier que l'état actuel est correct.
+Le moyen le plus économique d'inscrire des données sur le réseau principal d'Ethereum est de les écrire en tant que données d'appel.
+Cette solution a été choisie à la fois par [Optimism](https://help.optimism.io/hc/en-us/articles/4413163242779-What-is-a-rollup-) et [Arbitrum](https://developer.offchainlabs.com/docs/rollup_basics#intro-to-rollups).
 
 ### Coût des transactions L2 {#cost-of-l2-transactions}
 
-Le coût des transactions L2 est composé de deux éléments :
+Le coût des transactions L2 se compose de deux éléments :
 
 1. Le traitement L2, qui est généralement extrêmement bon marché
-2. Le stockage L1, lié aux coûts de gaz du réseau principal
+2. Le stockage L1, qui est lié aux coûts de gaz du réseau principal
 
-Au moment d'écrire cet article, le coût de gaz L2 sur Optimism est de 0,001 [Gwei](/developers/docs/gas/#pre-london) Le coût de gaz L1, en revanche, est d'environ 40 gwei. [Vous pouvez voir les prix actuels ici](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m).
+Au moment où j'écris ces lignes, sur Optimism, le coût du gaz L2 est de 0,001 [Gwei](/developers/docs/gas/#pre-london).
+Le coût du gaz L1, en revanche, est d'environ 40 gwei.
+[Vous pouvez voir les prix actuels ici](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m).
 
-Un octet de données d'appel coûte soit 4 gaz (s'il est nul) soit 16 gaz (s'il s'agit d'une autre valeur). L'une des opérations les plus coûteuses de l'EVM est d'écrire sur le stockage. Le coût maximum d'écriture d'un mot de 32 octets pour un stockage sur L2 est de 22 100 gaz. Soit actuellement 22,1 gwei. Si nous parvenons à sauvegarder un seul octet zéro de données d'appel, nous pourrons écrire environ 200 octets de stockage et sortir gagnants de l'opération.
+Un octet de données d'appel coûte soit 4 gaz (s'il est nul), soit 16 gaz (s'il s'agit de n'importe quelle autre valeur).
+L'une des opérations les plus coûteuses sur l'EVM est l'écriture sur le stockage.
+Le coût maximum de l'écriture d'un mot de 32 octets sur le stockage en L2 est de 22 100 gaz. Actuellement, cela représente 22,1 gwei.
+Ainsi, si nous pouvons économiser un seul octet nul de données d'appel, nous pourrons écrire environ 200 octets sur le stockage et être tout de même gagnants.
 
 ### L'ABI {#the-abi}
 
-La grande majorité des transactions accèdent à un contrat provenant d'un compte externe. La plupart des contrats sont écrits en Solidity et interprètent leur champ de données conformément à l'[interface binaire d'application (ABI)](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding).
+La grande majorité des transactions accèdent à un contrat provenant d'un compte externe.
+La plupart des contrats sont écrits en Solidity et interprètent leur champ de données selon [l'interface binaire de l'application (ABI)](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding).
 
-Cependant, l'ABI a été conçu pour L1, où un octet de données d'appels coûte approximativement la même chose que quatre opérations arithmétiques, et non pas pour L2 où un octet de données d'appel coûte plus de mille opérations arithmétiques. Par exemple, [voici une transaction de transfert ERC-20](https://kovan-optimistic.etherscan.io/tx/0x7ce4c144ebfce157b4de99d8ad53a352ae91b57b3fa06d8a1c79439df6bfa998). Les données d'appel sont divisées ainsi :
+Cependant, l'ABI a été conçue pour L1, où un octet de données d'appel coûte approximativement la même chose que quatre opérations arithmétiques, et non pour L2 où un octet de données d'appel coûte plus de mille opérations arithmétiques.
+Les données d'appel sont divisées comme suit :
 
-| Section                | Longueur | Bytes | Octets gaspillés | Gaz gaspillé | Octets nécessaires | Gaz nécessaire |
-| ---------------------- | -------: | ----: | ---------------: | -----------: | -----------------: | -------------: |
-| Sélecteur de fonction  |        4 |   0-3 |                3 |           48 |                  1 |             16 |
-| Zéros                  |       12 |  4-15 |               12 |           48 |                  0 |              0 |
-| Adresse de destination |       20 | 16-35 |                0 |            0 |                 20 |            320 |
-| Montant                |       32 | 36-67 |               17 |           64 |                 15 |            240 |
-| Total                  |       68 |       |                  |          160 |                    |            576 |
+| Section                | Longueur | Octets | Octets gaspillés | Gaz gaspillé | Octets nécessaires | Gaz nécessaire |
+| ---------------------- | -------: | -----: | ---------------: | -----------: | -----------------: | -------------: |
+| Sélecteur de fonction  |        4 |    0-3 |                3 |           48 |                  1 |             16 |
+| Zéros                  |       12 |   4-15 |               12 |           48 |                  0 |              0 |
+| Adresse de destination |       20 |  16-35 |                0 |            0 |                 20 |            320 |
+| Montant                |       32 |  36-67 |               17 |           64 |                 15 |            240 |
+| Total                  |       68 |        |                  |          160 |                    |            576 |
 
-Explication :
+Explication :
 
-- **Sélecteur de fonction** : Le contrat a moins de 256 fonctions, nous pouvons donc les caractériser avec un seul octet. Ces octets sont typiquement non nuls et [coûtent donc seize gaz](https://eips.ethereum.org/EIPS/eip-2028).
-- **Zéros** : Ces octets sont toujours nuls car une adresse de vingt-quatre octets ne nécessite pas un mot de trente-deux octets pour la contenir. Les octets qui contiennent la valeur zéro ont un coût de quatre gaz ([voir le Livre Jaune](https://ethereum.github.io/yellowpaper/paper.pdf), Annexe G, p. 27, la valeur de `G`<sub>`txdatazero`</sub>).
-- **Montant** : Si nous supposons que dans ce contrat `les décimales` sont de dix-huit (la valeur normale) et que le nombre maximum de jetons que nous transférons sera de 10<sup>18</sup>, nous obtenons un montant maximum de 10<sup>36</sup>. 256<sup>15</sup> &gt; 10<sup>36</sup>, donc 15 octets suffisent.
+- **Sélecteur de fonction** : Le contrat a moins de 256 fonctions, nous pouvons donc les distinguer avec un seul octet.
+  Ces octets sont généralement non nuls et [coûtent donc seize gaz](https://eips.ethereum.org/EIPS/eip-2028).
+- **Zéros** : Ces octets sont toujours nuls car une adresse de vingt octets ne nécessite pas un mot de trente-deux octets pour la contenir.
+  Les octets qui contiennent la valeur zéro coûtent quatre gaz ([voir le Livre Jaune](https://ethereum.github.io/yellowpaper/paper.pdf), Annexe G,
+  p. 27, la valeur pour `G`<sub>`txdatazero`</sub>).
+- **Montant** : Si nous supposons que dans ce contrat `decimals` est de dix-huit (la valeur normale) et que le montant maximum de jetons que nous transférons sera de 10<sup>18</sup>, nous obtenons un montant maximum de 10<sup>36</sup>.
+  256<sup>15</sup> &gt; 10<sup>36</sup>, donc quinze octets suffisent.
 
-Le gaspillage de 160 gaz sur L1 est normalement négligeable. Une transaction coûte un minimum de [21 000 gaz](https://yakkomajuri.medium.com/blockchain-definition-of-the-week-ethereum-gas-2f976af774ed), ainsi, un supplément de 0,8 % n'a pas grande importance. Cependant, sur L2, les choses sont différentes. La quasi-totalité du coût de la transaction consiste à l'écrire sur L1. En plus des données d'appel de la transaction, il y a 109 octets d'en-tête de la transaction (adresse de destination, signature, etc.). Le coût total est donc `109*16+576+160=2480`, et nous en gaspillons environ 6,5%.
+Un gaspillage de 160 gaz sur L1 est normalement négligeable. Une transaction coûte au moins [21 000 gaz](https://yakkomajuri.medium.com/blockchain-definition-of-the-week-ethereum-gas-2f976af774ed), donc 0,8 % supplémentaires n'ont pas d'importance.
+Cependant, sur L2, les choses sont différentes. La quasi-totalité du coût de la transaction consiste à l'écrire sur L1.
+En plus des données d'appel de la transaction, il y a 109 octets d'en-tête de transaction (adresse de destination, signature, etc.).
+Le coût total est donc `109*16+576+160=2480`, et nous en gaspillons environ 6,5 %.
 
 ## Réduire les coûts lorsque vous ne contrôlez pas la destination {#reducing-costs-when-you-dont-control-the-destination}
 
-En supposant que vous n'ayez pas de contrôle sur le contrat de destination, vous pouvez toujours utiliser une solution similaire à [celle-ci](https://github.com/qbzzt/ethereum.org-20220330-shortABI). Passons en revue les fichiers pertinents.
+En supposant que vous n'ayez pas le contrôle sur le contrat de destination, vous pouvez toujours utiliser une solution similaire à [celle-ci](https://github.com/qbzzt/ethereum.org-20220330-shortABI).
+Passons en revue les fichiers pertinents.
 
 ### Token.sol {#token-sol}
 
-[Ceci est le contrat de destination](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/Token.sol). Il s'agit d'un contrat standard ERC-20, avec une fonction supplémentaire. Cette fonction `faucet` permet à n'importe quel utilisateur d'obtenir un jeton à utiliser. Elle rendrait inutile la création d'un contrat ERC-20, mais elle facilite la vie quand un ERC-20 existe uniquement pour faciliter les tests.
+[Ceci est le contrat de destination](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/Token.sol).
+Il s'agit d'un contrat standard ERC-20, avec une fonction supplémentaire.
+Cette fonction `faucet` permet à n'importe quel utilisateur d'obtenir un jeton à utiliser.
+Elle rendrait inutile la création d'un contrat ERC-20, mais elle facilite la vie quand un ERC-20 existe uniquement pour faciliter les tests.
 
 ```solidity
     /**
-     * @dev Gives the caller 1000 tokens to play with
+     * @dev Donne à l'appelant 1000 jetons avec lesquels jouer
      */
     function faucet() external {
         _mint(msg.sender, 1000);
     }   // function faucet
 ```
 
-[Vous pouvez voir un exemple de ce contrat en cours de déploiement ici](https://kovan-optimistic.etherscan.io/address/0x950c753c0edbde44a74d3793db738a318e9c8ce8).
-
 ### CalldataInterpreter.sol {#calldatainterpreter-sol}
 
-[Ceci est le contrat que les transactions sont censées appeler au moyen de données d'appel plus courtes](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/CalldataInterpreter.sol). Revenons dessus ligne par ligne.
+[Ceci est le contrat que les transactions sont censées appeler avec des données d'appel plus courtes](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/CalldataInterpreter.sol).
+Revenons dessus ligne par ligne.
 
 ```solidity
 //SPDX-License-Identifier: Unlicense
@@ -89,7 +110,7 @@ pragma solidity ^0.8.0;
 import { OrisUselessToken } from "./Token.sol";
 ```
 
-Nous avons besoin de savoir comment appeler la fonction token.
+Nous avons besoin de la fonction du jeton pour savoir comment l'appeler.
 
 ```solidity
 contract CalldataInterpreter {
@@ -97,19 +118,19 @@ contract CalldataInterpreter {
     OrisUselessToken public immutable token;
 ```
 
-L'adresse du jeton pour lequel nous sommes un proxy.
+L'adresse du jeton pour lequel nous sommes un mandataire (proxy).
 
 ```solidity
 
     /**
-     * @dev Specify the token address
-     * @param tokenAddr_ ERC-20 contract address
+     * @dev Spécifier l'adresse du jeton
+     * @param tokenAddr_ Adresse du contrat ERC-20
      */
     constructor(
         address tokenAddr_
     )  {
         token = OrisUselessToken(tokenAddr_);
-    }   // constructor
+    }   // constructeur
 ```
 
 L'adresse du jeton est le seul paramètre que nous devons spécifier.
@@ -119,19 +140,21 @@ L'adresse du jeton est le seul paramètre que nous devons spécifier.
         private pure returns (uint) {
 ```
 
-Lire une valeur dans les données d'appel.
+Lire une valeur à partir des données d'appel.
 
 ```solidity
         uint _retVal;
 
         require(length < 0x21,
-            "calldataVal length limit is 32 bytes");
+            "La limite de longueur de calldataVal est de 32 octets");
 
         require(length + startByte <= msg.data.length,
-            "calldataVal trying to read beyond calldatasize");
+            "calldataVal essaie de lire au-delà de calldatasize");
 ```
 
-Nous allons charger en mémoire un unique mot de 32 octets (256 bits) et supprimer les octets qui ne font pas partie du champ souhaité. Cet algorithme ne fonctionne pas pour des valeurs de plus de 32 octets, et bien sûr nous ne pouvons lire au-delà de la fin des données d'appel. Sur L1, il serait pertinent de ne pas réaliser ces tests pour économiser du gaz, mais sur L2, le gaz est extrêmement bon marché, ce qui permet de réaliser toutes les vérifications possibles.
+Nous allons charger un unique mot de 32 octets (256 bits) en mémoire et supprimer les octets qui ne font pas partie du champ que nous voulons.
+Cet algorithme ne fonctionne pas pour des valeurs de plus de 32 octets, et bien sûr nous ne pouvons pas lire au-delà de la fin des données d'appel.
+Sur L1, il peut être nécessaire d'ignorer ces tests pour économiser du gaz, mais sur L2, le gaz est extrêmement bon marché, ce qui permet toutes les vérifications de cohérence auxquelles nous pouvons penser.
 
 ```solidity
         assembly {
@@ -141,14 +164,16 @@ Nous allons charger en mémoire un unique mot de 32 octets (256 bits) et supprim
 
 Nous aurions pu copier les données de l'appel à `fallback()` (voir ci-dessous), mais il est plus facile d'utiliser [Yul](https://docs.soliditylang.org/en/v0.8.12/yul.html), le langage d'assemblage de l'EVM.
 
-Nous utilisons ici [l'opcode CALLDATALOAD](https://www.evm.codes/#35) pour lire les octets `startByte` à `startByte+31` dans la pile. En général, la syntaxe d'un opcode dans Yul est `<opcode name>(<first stack value, if any>,<second stack value, if any>...)`.
+Ici, nous utilisons [l'opcode CALLDATALOAD](https://www.evm.codes/#35) pour lire les octets `startByte` à `startByte+31` dans la pile.
+En général, la syntaxe d'un opcode dans Yul est `<nom de l'opcode>(<première valeur de la pile, le cas échéant>,<deuxième valeur de la pile, le cas échéant>...)`.
 
 ```solidity
 
         _retVal = _retVal >> (256-length*8);
 ```
 
-Seuls les octets de `longueur` les plus significatives font partie du champ, donc nous [décalons vers la droite](https://en.wikipedia.org/wiki/Logical_shift) pour nous débarrasser des autres valeurs. Ceci présente l'avantage supplémentaire de déplacer la valeur à droite du champ, il s'agit donc de la valeur elle-même plutôt que la valeur multipliée par 256<sup>quelque chose</sup>.
+Seuls les octets de `longueur` les plus significatifs font partie du champ, donc nous effectuons un [décalage à droite](https://en.wikipedia.org/wiki/Logical_shift) pour nous débarrasser des autres valeurs.
+Ceci présente l'avantage supplémentaire de déplacer la valeur à droite du champ, il s'agit donc de la valeur elle-même plutôt que la valeur multipliée par 256<sup>quelque chose</sup>.
 
 ```solidity
 
@@ -159,7 +184,8 @@ Seuls les octets de `longueur` les plus significatives font partie du champ, don
     fallback() external {
 ```
 
-Lorsqu'un appel à un contrat Solidity ne correspond à aucune des signatures de fonction, il appelle [la fonction `fallback()`](https://docs.soliditylang.org/en/v0.8.12/contracts.html#fallback-function) (en supposant qu'il y en ait une). Dans le cas de `CalldataInterpreter`, _tous les appels_ arrivent ici car il n'y a pas d'autres fonctions `external` ou `public`.
+Lorsqu'un appel à un contrat Solidity ne correspond à aucune des signatures de fonction, il appelle [la fonction `fallback()`](https://docs.soliditylang.org/en/v0.8.12/contracts.html#fallback-function) (en supposant qu'il y en ait une).
+Dans le cas de `CalldataInterpreter`, n'importe quel appel arrive ici car il n'y a pas d'autres fonctions `external` ou `public`.
 
 ```solidity
         uint _func;
@@ -167,23 +193,27 @@ Lorsqu'un appel à un contrat Solidity ne correspond à aucune des signatures de
         _func = calldataVal(0, 1);
 ```
 
-Lit le premier octet des données d'appel, qui nous indique la fonction. Il y a deux raisons pour lesquelles une fonction ne serait pas disponible ici :
+Lit le premier octet des données d'appel, qui nous indique la fonction.
+Il y a deux raisons pour lesquelles une fonction ne serait pas disponible ici :
 
-1. Les fonctions `pure` ou `view` ne changent pas l'état et ne coûtent pas de gaz (lorsqu'elles sont appelées hors chaîne). Essayer de réduire leur coût en gaz n'a aucun sens.
-2. Les fonctions reposent sur [`msg.sender`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#block-and-transaction-properties). La valeur de `msg.sender` va être l'adresse du `CalldataInterpreter`, pas celle de l'appelant.
+1. Les fonctions `pure` ou `view` ne modifient pas l'état et ne coûtent pas de gaz (lorsqu'elles sont appelées hors chaîne).
+   Essayer de réduire leur coût en gaz n'a aucun sens.
+2. Fonctions qui s'appuient sur [`msg.sender`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#block-and-transaction-properties).
+   La valeur de `msg.sender` sera l'adresse de `CalldataInterpreter`, et non celle de l'appelant.
 
-Malheureusement, [au regard des spécifications ERC-20](https://eips.ethereum.org/EIPS/eip-20), cela ne laisse qu'une seule fonction, `transfer`. Cela nous laisse avec uniquement deux fonctions : `transfer` (parce que nous pouvons appeler `transferFrom`) et `faucet` (parce que nous pouvons retourner les jetons à celui qui nous a appelés).
+Malheureusement, [en examinant les spécifications ERC-20](https://eips.ethereum.org/EIPS/eip-20), cela ne laisse qu'une seule fonction, `transfer`.
+Cela nous laisse avec uniquement deux fonctions : `transfer` (parce que nous pouvons appeler `transferFrom`) et `faucet` (parce que nous pouvons retourner les jetons à celui qui nous a appelés).
 
 ```solidity
 
-        // Call the state changing methods of token using
-        // information from the calldata
+        // Appeler les méthodes de changement d'état du jeton en utilisant
+        // les informations des données d'appel
 
         // faucet
         if (_func == 1) {
 ```
 
-Un appel à la fonction `faucet()`, qui n'a pas de paramètres.
+Un appel à `faucet()`, qui n'a pas de paramètres.
 
 ```solidity
             token.faucet();
@@ -192,10 +222,12 @@ Un appel à la fonction `faucet()`, qui n'a pas de paramètres.
         }
 ```
 
-Après avoir appelé `token.faucet()`, nous obtenons des jetons. Cependant, comme pour le contrat proxy, nous n'avons pas **besoin** des jetons. L'EOA (compte détenu en externe) ou le contrat qui nous appelait en a besoin. Nous transférons donc tous nos jetons à ceux qui nous ont appelés.
+Après avoir appelé `token.faucet()`, nous obtenons des jetons. Cependant, en tant que contrat mandataire, nous n'avons pas **besoin** de jetons.
+L'EOA (compte détenu en externe) ou le contrat qui nous a appelés en a besoin.
+Nous transférons donc tous nos jetons à ceux qui nous ont appelés.
 
 ```solidity
-        // transfer (assume we have an allowance for it)
+        // transfer (supposons que nous ayons une allocation pour cela)
         if (_func == 2) {
 ```
 
@@ -212,26 +244,27 @@ Nous autorisons uniquement les appelants à transférer les jetons qu'ils possè
                 address(uint160(calldataVal(1, 20))),
 ```
 
-L'adresse de destination commence à l'octet #1 (l'octet #0 est la fonction). En tant qu'adresse, elle fait 20 octets de long.
+L'adresse de destination commence à l'octet n° 1 (l'octet n° 0 est la fonction).
+En tant qu'adresse, elle fait 20 octets de long.
 
 ```solidity
                 calldataVal(21, 2)
 ```
 
-Pour ce contrat particulier, nous supposons que le nombre maximum de jetons que n'importe qui voudra transférer tiendra dans deux octets (moins de 65536).
+Pour ce contrat particulier, nous supposons que le nombre maximum de jetons que n'importe qui voudra transférer tiendra dans deux octets (moins de 65 536).
 
 ```solidity
             );
         }
 ```
 
-Dans l'ensemble, un transfert prend 35 octets de données d'appel :
+Dans l'ensemble, un transfert prend 35 octets de données d'appel :
 
-| Section                | Longueur | Bytes |
-| ---------------------- | -------: | ----: |
-| Sélecteur de fonction  |        1 |     0 |
-| Adresse de destination |       32 |  1-32 |
-| Montant                |        2 | 33-34 |
+| Section                | Longueur | Octets |
+| ---------------------- | -------: | -----: |
+| Sélecteur de fonction  |        1 |      0 |
+| Adresse de destination |       32 |   1-32 |
+| Montant                |        2 |  33-34 |
 
 ```solidity
     }   // fallback
@@ -241,22 +274,23 @@ Dans l'ensemble, un transfert prend 35 octets de données d'appel :
 
 ### test.js {#test-js}
 
-[Ce test unitaire JavaScript](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/test/test.js) nous montre comment utiliser ce mécanisme (et comment vérifier qu'il fonctionne correctement). Je vais supposer que vous comprenez [chai](https://www.chaijs.com/) et [ethers](https://docs.ethers.io/v5/) et uniquement vous expliquer les parties applicables spécifiquement au contrat.
+[Ce test unitaire JavaScript](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/test/test.js) nous montre comment utiliser ce mécanisme (et comment vérifier qu'il fonctionne correctement).
+Je vais supposer que vous comprenez [chai](https://www.chaijs.com/) et [ethers](https://docs.ethers.io/v5/) et que je n'expliquerai que les parties qui s'appliquent spécifiquement au contrat.
 
 ```js
 const { expect } = require("chai");
 
 describe("CalldataInterpreter", function () {
-  it("Should let us use tokens", async function () {
+  it("Devrait nous permettre d'utiliser des jetons", async function () {
     const Token = await ethers.getContractFactory("OrisUselessToken")
     const token = await Token.deploy()
     await token.deployed()
-    console.log("Token addr:", token.address)
+    console.log("Adresse du jeton :", token.address)
 
     const Cdi = await ethers.getContractFactory("CalldataInterpreter")
     const cdi = await Cdi.deploy(token.address)
     await cdi.deployed()
-    console.log("CalldataInterpreter addr:", cdi.address)
+    console.log("Adresse CalldataInterpreter :", cdi.address)
 
     const signer = await ethers.getSigner()
 ```
@@ -264,21 +298,24 @@ describe("CalldataInterpreter", function () {
 Nous commençons par déployer les deux contrats.
 
 ```javascript
-    // Get tokens to play with
+    // Obtenir des jetons pour jouer avec
     const faucetTx = {
 ```
 
-Nous ne pouvons pas utiliser les fonctions de haut niveau que nous utiliserions normalement (comme `token.faucet()`) pour créer des transactions, car nous ne suivons pas l'ABI. Au lieu de cela, nous devons construire nous-mêmes la transaction et ensuite l'envoyer.
+Nous ne pouvons pas utiliser les fonctions de haut niveau que nous utiliserions normalement (telles que `token.faucet()`) pour créer des transactions, car nous ne suivons pas l'ABI.
+Au lieu de cela, nous devons construire nous-mêmes la transaction et ensuite l'envoyer.
 
 ```javascript
       to: cdi.address,
       data: "0x01"
 ```
 
-Nous devons fournir deux paramètres pour la transaction :
+Nous devons fournir deux paramètres pour la transaction :
 
-1. `to`, l'adresse de destination. Il s'agit de l'interpréteur des données d'appel du contrat.
-2. `data`, les données d'appel à envoyer. Dans le cas d'un appel faucet, les données sont un octet unique, `0x01`.
+1. `to`, l'adresse de destination.
+   Il s'agit du contrat d'interprétation des données d'appel.
+2. `data`, les données d'appel à envoyer.
+   Dans le cas d'un appel au faucet, les données sont un octet unique, `0x01`.
 
 ```javascript
 
@@ -286,26 +323,27 @@ Nous devons fournir deux paramètres pour la transaction :
     await (await signer.sendTransaction(faucetTx)).wait()
 ```
 
-Nous appelons la [méthode du signataire `sendTransaction`](https://docs.ethers.io/v5/api/signer/#Signer-sendTransaction) car nous avons déjà spécifié la destination (`faucetTx.to`) et nous avons besoin que la transaction soit signée.
+Nous appelons la méthode `sendTransaction` [du signataire](https://docs.ethers.io/v5/api/signer/#Signer-sendTransaction) car nous avons déjà spécifié la destination (`faucetTx.to`) et nous avons besoin que la transaction soit signée.
 
 ```javascript
-// Check the faucet provides the tokens correctly
+// Vérifier que le faucet fournit les jetons correctement
 expect(await token.balanceOf(signer.address)).to.equal(1000)
 ```
 
-Ici, nous vérifions le solde. Il n'est pas nécessaire d'économiser du gaz pour les fonctions `view`, nous les exécutons donc normalement.
+Ici, nous vérifions le solde.
+Il n'est pas nécessaire d'économiser du gaz sur les fonctions de `vue`, nous les exécutons donc normalement.
 
 ```javascript
-// Give the CDI an allowance (approvals cannot be proxied)
+// Donner une allocation au CDI (les approbations ne peuvent pas être mandatées)
 const approveTX = await token.approve(cdi.address, 10000)
 await approveTX.wait()
 expect(await token.allowance(signer.address, cdi.address)).to.equal(10000)
 ```
 
-Donner à l'interprète des données d'appel une allocation pour pouvoir effectuer des transferts.
+Donner à l'interprète de données d'appel une allocation pour pouvoir effectuer des transferts.
 
 ```javascript
-// Transfer tokens
+// Transférer des jetons
 const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
 const transferTx = {
   to: cdi.address,
@@ -313,53 +351,50 @@ const transferTx = {
 }
 ```
 
-Créer une transaction de transfert. Le premier octet est "0x02", suivi de l'adresse de destination, et enfin du montant (0x0100, qui est de 256 décimal).
+Créer une transaction de transfert. Le premier octet est « 0x02 », suivi de l'adresse de destination, et enfin du montant (0x0100, qui correspond à 256 en décimal).
 
 ```javascript
     await (await signer.sendTransaction(transferTx)).wait()
 
-    // Check that we have 256 tokens less
+    // Vérifier que nous avons 256 jetons en moins
     expect (await token.balanceOf(signer.address)).to.equal(1000-256)
 
-    // And that our destination got them
+    // Et que notre destination les a reçus
     expect (await token.balanceOf(destAddr)).to.equal(256)
   })    // it
 })      // describe
 ```
 
-### Exemple {#example}
-
-Si vous souhiatez voir ces fichiers en action sans les exécuter vous-même, suivez ces liens :
-
-1. [Déploiement de `OrisUselessToken`](https://kovan-optimistic.etherscan.io/tx/1410744) sur l'[adresse `0x950c753c0edbde44a74d3793db738a318e9c8ce8`](https://kovan-optimistic.etherscan.io/address/0x950c753c0edbde44a74d3793db738a318e9c8ce8).
-2. [Déploiement de `CalldataInterpreter`](https://kovan-optimistic.etherscan.io/tx/1410745) sur l'[adresse `0x16617fea670aefe3b9051096c0eb4aeb4b3a5f55`](https://kovan-optimistic.etherscan.io/address/0x16617fea670aefe3b9051096c0eb4aeb4b3a5f55).
-3. [Appel de `faucet()`](https://kovan-optimistic.etherscan.io/tx/1410746).
-4. [Appel de `OrisUselessToken.approve()`](https://kovan-optimistic.etherscan.io/tx/1410747). Cet appel doit aller directement au contrat de jeton car le traitement repose sur `msg.sender`.
-5. [Appel de `transfer()`](https://kovan-optimistic.etherscan.io/tx/1410748).
-
-## Réduire les coûts lorsque vous contrôlez le contrat de destination {#reducing-the-cost-when-you-do-control-the-destination-contract}
+## Réduire le coût lorsque vous contrôlez le contrat de destination {#reducing-the-cost-when-you-do-control-the-destination-contract}
 
-Si vous avez le contrôle sur le contrat de destination, vous pouvez créer des fonctions qui contournent la vérification `msg.sender` dans la mesure où elles font confiance à l'interpréteur des données d'appel. [Vous pouvez voir un exemple de comment cela fonctionne ici, dans la branche `control-contract`](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract).
+Si vous avez le contrôle sur le contrat de destination, vous pouvez créer des fonctions qui contournent la vérification de `msg.sender` dans la mesure où elles font confiance à l'interpréteur des données d'appel.
+[Vous pouvez voir un exemple de la façon dont cela fonctionne ici, dans la branche `control-contract`](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract).
 
-Si le contrat ne répondait qu'à des transactions externes, nous pourrions nous contenter d'un seul contrat. Cependant, cela casserait [la composabilité](/developers/docs/smart-contracts/composability/). Il est préférable d'avoir un contrat capable de répondre aux appels traditionnels ERC-20 et un autre contrat destiné aux transactions avec de courts appels de données.
+Si le contrat ne répondait qu'à des transactions externes, nous pourrions nous contenter d'un seul contrat.
+Cependant, cela briserait [la composabilité](/developers/docs/smart-contracts/composability/).
+Il est préférable d'avoir un contrat qui répond aux appels ERC-20 normaux, et un autre contrat qui répond aux transactions avec des données d'appel courtes.
 
 ### Token.sol {#token-sol-2}
 
-Dans cet exemple, nous pouvons modifier `Token.sol`. Cela nous permet d'avoir un certain nombre de fonctions que seul le proxy peut appeler. Voici les nouveaux éléments :
+Dans cet exemple, nous pouvons modifier `Token.sol`.
+Cela nous permet d'avoir un certain nombre de fonctions que seul le mandataire peut appeler.
+Voici les nouvelles parties :
 
 ```solidity
-    // The only address allowed to specify the CalldataInterpreter address
+    // La seule adresse autorisée à spécifier l'adresse CalldataInterpreter
     address owner;
 
-    // The CalldataInterpreter address
+    // L'adresse CalldataInterpreter
     address proxy = address(0);
 ```
 
-Le contrat ERC-20 doit connaître l'identité du proxy autorisé. Cependant, nous ne pouvons pas définir cette variable dans le constructeur, car nous n'en connaissons pas encore la valeur. Ce contrat est instauré en premier car le proxy attend l'adresse du jeton dans son constructeur.
+Le contrat ERC-20 doit connaître l'identité du mandataire autorisé.
+Cependant, nous ne pouvons pas définir cette variable dans le constructeur, car nous n'en connaissons pas encore la valeur.
+Ce contrat est instancié en premier car le mandataire attend l'adresse du jeton dans son constructeur.
 
 ```solidity
     /**
-     * @dev Calls the ERC20 constructor.
+     * @dev Appelle le constructeur ERC20.
      */
     constructor(
     ) ERC20("Oris useless token-2", "OUT-2") {
@@ -367,47 +402,50 @@ Le contrat ERC-20 doit connaître l'identité du proxy autorisé. Cependant, nou
     }
 ```
 
-L'adresse du créateur (appelé `owner`) est stockée ici car c'est la seule adresse autorisée à définir le proxy.
+L'adresse du créateur (appelé `propriétaire`) est stockée ici car c'est la seule adresse autorisée à définir le mandataire.
 
 ```solidity
     /**
-     * @dev set the address for the proxy (the CalldataInterpreter).
-     * Can only be called once by the owner
+     * @dev définit l'adresse pour le mandataire (le CalldataInterpreter).
+     * Ne peut être appelé qu'une seule fois par le propriétaire
      */
     function setProxy(address _proxy) external {
-        require(msg.sender == owner, "Can only be called by owner");
-        require(proxy == address(0), "Proxy is already set");
+        require(msg.sender == owner, "Ne peut être appelé que par le propriétaire");
+        require(proxy == address(0), "Le mandataire est déjà défini");
 
         proxy = _proxy;
     }    // function setProxy
 ```
 
-Le proxy dispose d'un accès privilégié, car il peut contourner les contrôles de sécurité. Pour être sûr de pouvoir faire confiance au proxy, nous ne laissons que `le propriétaire` appeler cette fonction, et qu'une seule fois. Une fois que le `proxy` dispose d'une valeur réelle (pas zéro), cette valeur ne peut pas changer, donc même si le propriétaire décide de jouer au voyou, ou si l'élément mnémonique est révélé, nous restons en sécurité.
+Le mandataire dispose d'un accès privilégié, car il peut contourner les contrôles de sécurité.
+Pour être sûr de pouvoir faire confiance au mandataire, nous ne laissons que le `propriétaire` appeler cette fonction, et une seule fois.
+Une fois que `proxy` a une valeur réelle (non nulle), cette valeur ne peut pas changer, donc même si le propriétaire décide de devenir malveillant, ou si la mnémonique pour celui-ci est révélée, nous sommes toujours en sécurité.
 
 ```solidity
     /**
-     * @dev Some functions may only be called by the proxy.
+     * @dev Certaines fonctions ne peuvent être appelées que par le mandataire.
      */
     modifier onlyProxy {
 ```
 
-Ceci est une [fonction `modifier`](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm), qui modifie la façon dont les autres fonctions marchent.
+Ceci est une [fonction `modificatrice`](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm), elle modifie le fonctionnement des autres fonctions.
 
 ```solidity
       require(msg.sender == proxy);
 ```
 
-Tout d'abord, vérifier que nous avons été appelés par le proxy et personne d'autre. Dans le cas contraire, `annuler`.
+Tout d'abord, vérifiez que nous avons été appelés par le mandataire et personne d'autre.
+Sinon, `revert`.
 
 ```solidity
       _;
     }
 ```
 
-Si c'est le cas, exécuter la fonction que nous modifions.
+Si c'est le cas, exécutez la fonction que nous modifions.
 
 ```solidity
-   /* Functions that allow the proxy to actually proxy for accounts */
+   /* Fonctions qui permettent au mandataire de servir de mandataire pour les comptes */
 
     function transferProxy(address from, address to, uint256 amount)
         public virtual onlyProxy() returns (bool)
@@ -436,17 +474,18 @@ Si c'est le cas, exécuter la fonction que nous modifions.
     }
 ```
 
-Il s'agit de trois opérations pour lesquelles le message doit normalement provenir directement de l'entité qui transfère les jetons ou approuve une allocation. Nous avons ici une version proxy de ces opérations qui :
+Il s'agit de trois opérations qui nécessitent normalement que le message provienne directement de l'entité qui transfère les jetons ou qui approuve une allocation.
+Nous avons ici une version mandataire de ces opérations qui :
 
-1. Est modifiée par `onlyProxy()` afin que personne d'autre ne soit autorisé à les contrôler.
+1. est modifiée par `onlyProxy()` afin que personne d'autre ne soit autorisé à les contrôler.
 2. Récupère l'adresse qui serait normalement `msg.sender` en tant que paramètre supplémentaire.
 
 ### CalldataInterpreter.sol {#calldatainterpreter-sol-2}
 
-L'interpréteur de données d'appel est presque identique à celui ci-dessus, à la différence que les fonctions proxy reçoivent un paramètre `msg.sender` et qu'il n'est pas nécessaire d'effectuer d'allocation pour le `transfert`.
+L'interpréteur de données d'appel est presque identique à celui ci-dessus, à la différence que les fonctions mandatées reçoivent un paramètre `msg.sender` et qu'il n'est pas nécessaire d'effectuer d'allocation pour le `transfert`.
 
 ```solidity
-        // transfer (no need for allowance)
+        // transfert (pas besoin d'allocation)
         if (_func == 2) {
             token.transferProxy(
                 msg.sender,
@@ -455,7 +494,7 @@ L'interpréteur de données d'appel est presque identique à celui ci-dessus, à
             );
         }
 
-        // approve
+        // approbation
         if (_func == 3) {
             token.approveProxy(
                 msg.sender,
@@ -486,21 +525,22 @@ await cdi.deployed()
 await token.setProxy(cdi.address)
 ```
 
-Nous devons indiquer au contrat ERC-20 à quel proxy faire confiance
+Nous devons indiquer au contrat ERC-20 à quel mandataire faire confiance
 
 ```js
-console.log("CalldataInterpreter addr:", cdi.address)
+console.log("Adresse CalldataInterpreter :", cdi.address)
 
-// Need two signers to verify allowances
+// Besoin de deux signataires pour vérifier les allocations
 const signers = await ethers.getSigners()
 const signer = signers[0]
 const poorSigner = signers[1]
 ```
 
-Pour vérifier `approve()` et `transferFrom()`, nous avons besoin d'un second signataire. Nous l'appelons `poorSigner` car il ne récupère aucun de nos jetons (il a bien entendu besoin d'ETH).
+Pour vérifier `approve()` et `transferFrom()`, nous avons besoin d'un second signataire.
+Nous l'appelons `poorSigner` car il ne reçoit aucun de nos jetons (il doit bien sûr avoir de l'ETH).
 
 ```js
-// Transfer tokens
+// Transférer des jetons
 const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
 const transferTx = {
   to: cdi.address,
@@ -509,10 +549,10 @@ const transferTx = {
 await (await signer.sendTransaction(transferTx)).wait()
 ```
 
-Dans la mesure où le contrat ERC-20 fait confiance au proxy (`cdi`), nous n'avons pas besoin d'une allocation pour relayer les transferts.
+Étant donné que le contrat ERC-20 fait confiance au mandataire (`cdi`), nous n'avons pas besoin d'une allocation pour relayer les transferts.
 
 ```js
-// approval and transferFrom
+// approbation et transferFrom
 const approveTx = {
   to: cdi.address,
   data: "0x03" + poorSigner.address.slice(2, 42) + "00FF",
@@ -527,24 +567,19 @@ const transferFromTx = {
 }
 await (await poorSigner.sendTransaction(transferFromTx)).wait()
 
-// Check the approve / transferFrom combo was done correctly
+// Vérifier que la combinaison approbation / transferFrom a été effectuée correctement
 expect(await token.balanceOf(destAddr2)).to.equal(255)
 ```
 
-Tester les deux nouvelles fonctions. Notez que `transferFromTx` nécessite deux paramètres d'adresse : le donneur de l'allocation et le destinataire.
+Tester les deux nouvelles fonctions.
+Notez que `transferFromTx` nécessite deux paramètres d'adresse : le donneur de l'allocation et le destinataire.
 
-### Exemple {#example-2}
-
-Si vous souhiatez voir ces fichiers en action sans les exécuter vous-même, suivez ces liens :
+## Conclusion {#conclusion}
 
-1. [Déploiement de `OrisUselessToken-2`](https://kovan-optimistic.etherscan.io/tx/1475397) à l'adresse [`0xb47c1f550d8af70b339970c673bbdb2594011696`](https://kovan-optimistic.etherscan.io/address/0xb47c1f550d8af70b339970c673bbdb2594011696).
-2. [Déploiement de `CalldataInterpreter`](https://kovan-optimistic.etherscan.io/tx/1475400) à l'adresse [`0x0dccfd03e3aaba2f8c4ea4008487fd0380815892`](https://kovan-optimistic.etherscan.io/address/0x0dccfd03e3aaba2f8c4ea4008487fd0380815892).
-3. [Appel de `setProxy()`](https://kovan-optimistic.etherscan.io/tx/1475402).
-4. [Appel de `faucet()`](https://kovan-optimistic.etherscan.io/tx/1475409).
-5. [Appel de `transferProxy()`](https://kovan-optimistic.etherscan.io/tx/1475416).
-6. [Appel de `approveProxy()`](https://kovan-optimistic.etherscan.io/tx/1475419).
-7. [Appel de `transferProxy()`](https://kovan-optimistic.etherscan.io/tx/1475421). Notez que cet appel provient d'une adresse différente des autres, `poorSigner` au lieu du `signer`.
+[Optimism](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92) et [Arbitrum](https://developer.offchainlabs.com/docs/special_features) cherchent tous deux des moyens de réduire la taille des données d'appel écrites sur L1 et donc le coût des transactions.
+Cependant, en tant que fournisseurs d'infrastructures à la recherche de solutions génériques, nos capacités sont limitées.
+En tant que développeur de dapps, vous avez des connaissances spécifiques à l'application, ce qui vous permet d'optimiser vos données d'appel bien mieux que nous ne pourrions le faire avec une solution générique.
+Nous espérons que cet article vous aidera à trouver la solution idéale pour vos besoins.
 
-## Conclusion {#conclusion}
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
 
-[Optimism](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92) et [Arbitrum](https://developer.offchainlabs.com/docs/special_features) recherchent des moyens de réduire la taille des données d'appel écrites en L1 et donc le coût des transactions. Cependant, en tant que fournisseurs d'infrastructures pour des solutions génériques, nos capacités sont limitées. En tant que développeur dApp, vous avez des connaissances spécifiques concernant l'application, ce qui vous permet d'optimiser vos données d'appel bien mieux que nous ne pourrions le faire avec une solution générique. J'espère que cet article vous aidera à trouver la solution idéale pour vos besoins.
diff --git a/public/content/translations/fr/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/fr/developers/tutorials/smart-contract-security-guidelines/index.md
index b84fbff256d..c0680a213ae 100644
--- a/public/content/translations/fr/developers/tutorials/smart-contract-security-guidelines/index.md
+++ b/public/content/translations/fr/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -1,15 +1,12 @@
 ---
-title: Directives de sécurité pour les contrats intelligents
-description: Une liste de contrôle des consignes de sécurité à prendre en compte lors de la création de votre DApp
+title: "Directives de sécurité pour les contrats intelligents"
+description: "Une liste de contrôle des consignes de sécurité à prendre en compte lors de la création de votre DApp"
 author: "Trailofbits"
-tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "sécurité"
+tags: [ "Solidity", "contrats intelligents", "sécurité" ]
 skill: intermediate
 lang: fr
 published: 2020-09-06
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
 ---
 
@@ -23,72 +20,72 @@ La conception du contrat doit être discutée à l'avance, avant de rédiger une
 
 La documentation peut être écrite à différents niveaux et devrait être mise à jour lors de l'implémentation des contrats :
 
-- **Une description simple du système en anglais**, décrivant ce que font les contrats et toutes hypothèses sur le code base.
-- **Schéma et diagrammes architecturaux**, y compris les interactions contractuelles et la machine d'état du système. [Slither printers](https://github.com/crytic/slither/wiki/Printer-documentation) peut aider à générer ces schémas.
-- **Documentation de code approfondi**, le [format Natspec](https://solidity.readthedocs.io/en/develop/natspec-format.html) peut être utilisé pour Solidity.
+- **Une description simple du système**, décrivant ce que font les contrats et les hypothèses concernant la base de code.
+- **Schémas et diagrammes d'architecture**, incluant les interactions entre contrats et la machine à états du système. [Les imprimantes de Slither](https://github.com/crytic/slither/wiki/Printer-documentation) peuvent vous aider à générer ces schémas.
+- **Documentation de code approfondie**, le format [Natspec](https://docs.soliditylang.org/en/develop/natspec-format.html) peut être utilisé pour Solidity.
 
-### Calcul On-chain vs Off-chain {#on-chain-vs-off-chain-computation}
+### Calcul en chaîne ou hors chaîne {#onchain-vs-offchain-computation}
 
-- **Conserver le plus de code que vous pouvez hors chaîne.** Garder la couche en chaîne petite. Pré-traiter les données avec du code hors chaîne de telle façon que la vérification en chaîne soit simple. Avez-vous besoin d'une liste ordonnée ? Trier la liste hors chaîne, puis ne vérifier que son ordre en chaîne.
+- **Gardez autant de code que possible hors chaîne.** Gardez la couche en chaîne de petite taille. Prétraitez les données avec du code hors chaîne de manière à ce que la vérification en chaîne soit simple. Avez-vous besoin d'une liste ordonnée ? Trier la liste hors chaîne, puis ne vérifier que son ordre en chaîne.
 
-### Mise à jour {#upgradeability}
+### Évolutivité {#upgradeability}
 
-Nous avons discuté des différentes solutions de mise à niveau dans [notre blogpost](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/). Faites un choix délibéré de prendre en charge la possibilité de mise à niveau ou non avant de rédiger un code. La décision influencera la façon dont vous structurerez notre code. En général, nous recommandons :
+Nous avons abordé les différentes solutions d'évolutivité dans [notre article de blog](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/). Faites un choix délibéré de prendre en charge la possibilité de mise à niveau ou non avant de rédiger un code. La décision influencera la façon dont vous structurerez notre code. En général, nous recommandons :
 
-- **Favoriser [la migration de contract](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) plutôt que la mise à niveau.** Le système de migration présente bon nombre des mêmes avantages que l'évolutif, sans ses inconvénients.
-- **Utilisation du modèle de séparation des données par rapport à celui du delegatecallproxy.** Si votre projet a une séparation d'abstraction claire, la possibilité de mise à niveau à l'aide de la séparation des données ne nécessitera que quelques ajustements. Le delegatecallproxy nécessite une expertise EVM et est très exposé aux erreurs.
-- **Documentez la procédure de migration/mise à niveau avant le déploiement.** Si vous devez réagir sous pression sans aucune instructions, vous ferez des erreurs. Écrivez la procédure à suivre à l'avance. Cela devrait inclure :
+- **Privilégiez la [migration de contrat](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) plutôt que l'évolutivité.** Les systèmes de migration présentent bon nombre des mêmes avantages que les systèmes évolutifs, sans leurs inconvénients.
+- **Utilisez le modèle de séparation des données plutôt que celui de delegatecallproxy.** Si votre projet présente une séparation claire de l'abstraction, l'évolutivité utilisant la séparation des données ne nécessitera que quelques ajustements. Le delegatecallproxy nécessite une expertise EVM et est très exposé aux erreurs.
+- **Documentez la procédure de migration/mise à niveau avant le déploiement.** Si vous devez réagir dans l'urgence sans directives, vous ferez des erreurs. Écrivez la procédure à suivre à l'avance. Cela devrait inclure :
   - Les appels qui initient les nouveaux contrats
   - Où sont stockées les clés et comment y accéder
   - Comment vérifier le déploiement ! Développez et testez un script de post-déploiement.
 
-## Directives d'exécution {#implementation-guidelines}
+## Directives d'implémentation {#implementation-guidelines}
 
-**Opter pour la simplicité.** Utilisez toujours la solution la plus simple qui correspond à votre but. Tout membre de votre équipe devrait être en mesure de comprendre votre solution.
+**Recherchez la simplicité.** Utilisez toujours la solution la plus simple et adaptée à votre objectif. Tout membre de votre équipe devrait être en mesure de comprendre votre solution.
 
-### Composition de la fonction {#function-composition}
+### Composition de fonctions {#function-composition}
 
 L'architecture de votre code de base devrait rendre votre code facile à vérifier. Évitez les choix architecturaux qui réduisent la capacité à raisonner sur son exactitude.
 
-- **Séparer la logique de votre système**, soit par des contrats multiples, soit en regroupant des fonctions similaires (par exemple, authentification, arithmétique, ...).
-- **Écrire de petites fonctions, avec un objectif clair.** Cela facilitera la révision et permettra le test de composantes individuelles.
+- **Divisez la logique de votre système**, soit à travers plusieurs contrats, soit en regroupant des fonctions similaires (par exemple, l'authentification, l'arithmétique, etc.).
+- **Écrivez des fonctions courtes avec un objectif clair.** Cela facilitera la revue et permettra de tester les composants individuels.
 
 ### Héritage {#inheritance}
 
-- **Gardez l'héritage gérable.** L'héritage doit être utilisé pour diviser la logique, cependant, votre projet devrait viser à minimiser la profondeur et la largeur de l'arbre d'héritage.
-- **Utilisez l'imprimante [d'héritage de Slither](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph) pour vérifier la hiérarchie des contrats.** L'imprimante d'héritage vous aidera à revoir la taille de la hiérarchie.
+- **Maintenez l'héritage gérable.** L'héritage doit être utilisé pour diviser la logique, cependant, votre projet doit viser à minimiser la profondeur et la largeur de l'arborescence d'héritage.
+- **Utilisez l'[imprimante d'héritage](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph) de Slither pour vérifier la hiérarchie des contrats.** L'imprimante d'héritage vous aidera à examiner la taille de la hiérarchie.
 
 ### Événements {#events}
 
-- **Enregistre toutes les opérations cruciales.** Les événements aideront à déboguer le contrat pendant le développement, et à le surveiller après le déploiement.
+- **Journalisez toutes les opérations cruciales.** Les événements vous aideront à déboguer le contrat pendant le développement et à le surveiller après le déploiement.
 
-### Éviter les pièges connus {#avoid-known-pitfalls}
+### Évitez les pièges connus {#avoid-known-pitfalls}
 
-- **Soyez conscient des problèmes de sécurité les plus courants.** Il existe beaucoup de ressources en ligne à apprendre sur les problèmes communs, tels que [Ethernaut CTF](https://ethernaut.openzeppelin.com/), [Capturez l'Ether](https://capturetheether.com/), ou [Les contrats Not-so-smart](https://github.com/crytic/not-so-smart-contracts/).
-- **Soyez conscient des sections d'avertissements dans la [documentation Solidity](https://solidity.readthedocs.io/en/latest/).** Les sections d'avertissements vous informeront du comportement non-évident du langage.
+- **Soyez conscient des problèmes de sécurité les plus courants.** Il existe de nombreuses ressources en ligne pour en apprendre davantage sur les problèmes courants, telles que [Ethernaut CTF](https://ethernaut.openzeppelin.com/), [Capture the Ether](https://capturetheether.com/) ou [Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/).
+- **Prenez connaissance des sections d'avertissement dans la [documentation de Solidity](https://docs.soliditylang.org/en/latest/).** Les sections d'avertissement vous informeront sur les comportements non évidents du langage.
 
 ### Dépendances {#dependencies}
 
-- **Utilisez des bibliothèques logicielles bien testées.** Importer du code depuis des bibliothèques bien testées réduira la probabilité d'écrire du code bogué. Si vous voulez écrire un contrat ERC20, utilisez [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
-- **Utilisez un dependency manager; évitez le code copier-coller** Si vous comptez sur une source externe, vous devez la tenir à jour avec la source originale.
+- **Utilisez des bibliothèques bien testées.** L'importation de code à partir de bibliothèques bien testées réduira la probabilité d'écrire du code bogué. Si vous voulez écrire un contrat ERC20, utilisez [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
+- **Utilisez un gestionnaire de dépendances ; évitez de copier-coller du code.** Si vous dépendez d'une source externe, vous devez la maintenir à jour par rapport à la source d'origine.
 
-### Tests et vérification {#testing-and-verification}
+### Test et vérification {#testing-and-verification}
 
-- **Écrivez des tests unitaires approfondis.** Une suite de tests étendue est cruciale pour construire des logiciels de haute qualité.
-- **Écrivez [Slither](https://github.com/crytic/slither), [Echidna](https://github.com/crytic/echidna) et [Manticore](https://github.com/trailofbits/manticore) vérifications et propriétés personnalisées.** Des outils automatisés vous aideront à sécuriser votre contrat. Examinez le reste de ce guide pour savoir comment écrire des vérifications et des propriétés efficaces.
-- **Utilisez [crytic.io](https://crytic.io/).** Crytic intégré avec GitHub, fournit un accès aux détecteurs privés de Slither et effectue des vérifications de propriétés personnalisées depuis Echidna.
+- **Rédigez des tests unitaires approfondis.** Une suite de tests complète est essentielle pour créer un logiciel de haute qualité.
+- **Rédigez des vérifications et des propriétés personnalisées pour [Slither](https://github.com/crytic/slither), [Echidna](https://github.com/crytic/echidna) et [Manticore](https://github.com/trailofbits/manticore).** Les outils automatisés vous aideront à garantir la sécurité de votre contrat. Examinez le reste de ce guide pour savoir comment écrire des vérifications et des propriétés efficaces.
+- **Utilisez [crytic.io](https://crytic.io/).** Crytic s'intègre à GitHub, fournit un accès à des détecteurs Slither privés et exécute des vérifications de propriétés personnalisées à partir d'Echidna.
 
 ### Solidity {#solidity}
 
-- **Favoriser Solidity 0.5 plutôt que 0.4 et 0.6.** Selon nous, Solidity 0.5 est plus sécurisée et a de meilleures pratiques intégrées que 0.4. Solidity 0.6 s'est révélée trop instable pour la production et a besoin de temps pour se développer.
-- **Utilisez une version stable pour la compilation ; utilisez la dernière version pour vérifier les avertissements.** Vérifiez que votre code n'a aucun problème rapporté avec la dernière version du compilateur. Cependant, Solidity a un cycle de publication rapide et a un historique de bogues du compilateur, donc nous ne recommandons pas la dernière version pour le déploiement (voir la [recommandation de version solc](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33) de Slither ).
-- **N'utilisez pas d'assemblage Inline.** L'assemblage nécessite une expertise EVM. N'écrivez pas de code EVM si vous n'avez pas maîtrisé _le Livre jaune_.
+- **Privilégiez Solidity 0.5 par rapport aux versions 0.4 et 0.6.** À notre avis, Solidity 0.5 est plus sécurisé et intègre de meilleures pratiques que la version 0.4. Solidity 0.6 s'est révélée trop instable pour la production et a besoin de temps pour se développer.
+- **Utilisez une version stable pour la compilation ; utilisez la dernière version pour vérifier les avertissements.** Vérifiez que votre code ne présente aucun problème signalé avec la dernière version du compilateur. Cependant, Solidity a un cycle de publication rapide et un historique de bogues du compilateur, nous ne recommandons donc pas la dernière version pour le déploiement (voir la [recommandation de version solc](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33) de Slither).
+- **N'utilisez pas l'assembly en ligne.** L'assembly nécessite une expertise de l'EVM. N'écrivez pas de code EVM si vous ne _maîtrisez_ pas le Livre jaune.
 
 ## Directives de déploiement {#deployment-guidelines}
 
 Une fois le contrat développé et déployé :
 
-- **Surveillez vos contrats.** Surveillez les logs et soyez prêt à réagir en cas de contrat ou de portefeuille compromis.
-- **Ajoutez vos informations de contact à [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts).** Cette liste aide des tiers à vous contacter si une faille de sécurité est découverte.
-- **Sécurisez les portefeuilles d'utilisateurs privilégiés.** Suivez nos [meilleures pratiques](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/) si vous stockez des clés dans des hardware wallets.
-- **Ayez une réponse au plan d'incident.** Considérez que vos contrats intelligents peuvent être compromis. Même si vos contrats sont exempts de bogues, un attaquant peut prendre le contrôle des clés du propriétaire du contrat.
+- **Surveillez vos contrats.** Surveillez les journaux et soyez prêt à réagir en cas de compromission d'un contrat ou d'un portefeuille.
+- **Ajoutez vos coordonnées à [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts).** Cette liste aide les tierces parties à vous contacter si une faille de sécurité est découverte.
+- **Sécurisez les portefeuilles des utilisateurs à privilèges.** Suivez nos [meilleures pratiques](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/) si vous stockez des clés dans des portefeuilles matériels.
+- **Ayez un plan d'intervention en cas d'incident.** Tenez compte du fait que vos contrats intelligents peuvent être compromis. Même si vos contrats sont exempts de bogues, un attaquant peut prendre le contrôle des clés du propriétaire du contrat.
diff --git a/public/content/translations/fr/developers/tutorials/stealth-addr/index.md b/public/content/translations/fr/developers/tutorials/stealth-addr/index.md
new file mode 100644
index 00000000000..7799d7ad405
--- /dev/null
+++ b/public/content/translations/fr/developers/tutorials/stealth-addr/index.md
@@ -0,0 +1,443 @@
+---
+title: "Utilisation des adresses furtives"
+description: "Les adresses furtives permettent aux utilisateurs de transférer des actifs de manière anonyme. Après avoir lu cet article, vous serez en mesure de : expliquer ce que sont les adresses furtives et comment elles fonctionnent, comprendre comment utiliser les adresses furtives d'une manière qui préserve l'anonymat et écrire une application web qui utilise des adresses furtives."
+author: Ori Pomerantz
+tags:
+  [
+    "Adresse furtive",
+    "confidentialité",
+    "cryptographie",
+    "Rust",
+    "wasm"
+  ]
+skill: intermediate
+published: 2025-11-30
+lang: fr
+sidebarDepth: 3
+---
+
+Vous êtes Bill. Pour des raisons que nous n'aborderons pas, vous voulez faire un don à la campagne "Alice pour la Reine du Monde" et que Alice sache que vous avez fait un don afin qu'elle vous récompense si elle gagne. Malheureusement, sa victoire n'est pas garantie. Il existe une campagne concurrente, "Carol pour l'Impératrice du Système solaire". Si Carol gagne et qu'elle découvre que vous avez fait un don à Alice, vous aurez des ennuis. Vous ne pouvez donc pas simplement transférer 200 ETH de votre compte à celui d'Alice.
+
+[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564) apporte la solution. Cet ERC explique comment utiliser les [adresses furtives](https://nerolation.github.io/stealth-utils) pour un transfert anonyme.
+
+**Avertissement** : La cryptographie derrière les adresses furtives est, à notre connaissance, solide. Cependant, il existe des attaques potentielles par canal auxiliaire. [Ci-dessous](#go-wrong), vous verrez ce que vous pouvez faire pour réduire ce risque.
+
+## Comment fonctionnent les adresses furtives {#how}
+
+Cet article tentera d'expliquer les adresses furtives de deux manières. La première est [comment les utiliser](#how-use). Cette partie est suffisante pour comprendre le reste de l'article. Ensuite, il y a [une explication des mathématiques sous-jacentes](#how-math). Si la cryptographie vous intéresse, lisez également cette partie.
+
+### La version simple (comment utiliser les adresses furtives) {#how-use}
+
+Alice crée deux clés privées et publie les clés publiques correspondantes (qui peuvent être combinées en une seule méta-adresse de double longueur). Bill crée également une clé privée et publie la clé publique correspondante.
+
+En utilisant la clé publique d'une partie et la clé privée de l'autre, vous pouvez dériver un secret partagé connu uniquement d'Alice et de Bill (il ne peut pas être dérivé des seules clés publiques). À l'aide de ce secret partagé, Bill obtient l'adresse furtive et peut y envoyer des actifs.
+
+Alice obtient également l'adresse à partir du secret partagé, mais comme elle connaît les clés privées des clés publiques qu'elle a publiées, elle peut également obtenir la clé privée qui lui permet de retirer des fonds de cette adresse.
+
+### Les mathématiques (pourquoi les adresses furtives fonctionnent de cette manière) {#how-math}
+
+Les adresses furtives standard utilisent la [cryptographie sur les courbes elliptiques (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor) pour obtenir de meilleures performances avec moins de bits de clé, tout en conservant le même niveau de sécurité. Mais pour la plupart, nous pouvons ignorer cela et prétendre que nous utilisons l'arithmétique ordinaire.
+
+Il y a un nombre que tout le monde connaît, _G_. Vous pouvez multiplier par _G_. Mais en raison de la nature de l'ECC, il est pratiquement impossible de diviser par _G_. La façon dont la cryptographie à clé publique fonctionne généralement dans Ethereum est que vous pouvez utiliser une clé privée, _P<sub>priv</sub>_, pour signer des transactions qui sont ensuite vérifiées par une clé publique, _P<sub>pub</sub> = GP<sub>priv</sub>_.
+
+Alice crée deux clés privées, _K<sub>priv</sub>_ et _V<sub>priv</sub>_. _K<sub>priv</sub>_ sera utilisée pour dépenser l'argent de l'adresse furtive, et _V<sub>priv</sub>_ pour voir les adresses qui appartiennent à Alice. Alice publie ensuite les clés publiques : _K<sub>pub</sub> = GK<sub>priv</sub>_ et _V<sub>pub</sub> = GV<sub>priv</sub>_
+
+Bill crée une troisième clé privée, _R<sub>priv</sub>_, et publie _R<sub>pub</sub> = GR<sub>priv</sub>_ dans un registre central (Bill aurait pu aussi l'envoyer à Alice, mais nous supposons que Carol écoute).
+
+Bill calcule _R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>_, ce qu'il s'attend à ce qu'Alice sache aussi (expliqué ci-dessous). Cette valeur est appelée _S_, le secret partagé. Ceci donne à Bill une clé publique, _P<sub>pub</sub> = K<sub>pub</sub>+G\*hachage(S)_. À partir de cette clé publique, il peut calculer une adresse et y envoyer toutes les ressources qu'il souhaite. À l'avenir, si Alice gagne, Bill peut lui communiquer _R<sub>priv</sub>_ pour prouver que les ressources proviennent de lui.
+
+Alice calcule _R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_. Ceci lui donne le même secret partagé, _S_. Comme elle connaît la clé privée, _K<sub>priv</sub>_, elle peut calculer _P<sub>priv</sub> = K<sub>priv</sub>+hachage(S)_. Cette clé lui permet d'accéder aux actifs dans l'adresse qui résulte de _P<sub>pub</sub> = GP<sub>priv</sub> = GK<sub>priv</sub>+G*hachage(S) = K<sub>pub</sub>+G*hachage(S)_.
+
+Nous avons une clé de visualisation distincte pour permettre à Alice de sous-traiter aux services de campagne de domination mondiale de Dave. Alice est prête à faire connaître à Dave les adresses publiques et à l'informer lorsque plus d'argent est disponible, mais elle ne veut pas qu'il dépense l'argent de sa campagne.
+
+Parce que la visualisation et la dépense utilisent des clés distinctes, Alice peut donner à Dave _V<sub>priv</sub>_. Alors Dave peut calculer _S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ et de cette façon obtenir les clés publiques (_P<sub>pub</sub> = K<sub>pub</sub>+G\*hachage(S)_). Mais sans _K<sub>priv</sub>_, Dave ne peut pas obtenir la clé privée.
+
+Pour résumer, voici les valeurs connues des différents participants.
+
+| Alice                                                                     | Publié            | Bill                                                                      | Dave                                                                        |                                                 |
+| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------- |
+| G                                                                         | G                 | G                                                                         | G                                                                           |                                                 |
+| _K<sub>priv</sub>_                                                        | –                 | –                                                                         | –                                                                           |                                                 |
+| _V<sub>priv</sub>_                                                        | –                 | –                                                                         | _V<sub>priv</sub>_                                                          |                                                 |
+| _K<sub>pub</sub> = GK<sub>priv</sub>_                                     | _K<sub>pub</sub>_ | _K<sub>pub</sub>_                                                         | _K<sub>pub</sub>_                                                           |                                                 |
+| _V<sub>pub</sub> = GV<sub>priv</sub>_                                     | _V<sub>pub</sub>_ | _V<sub>pub</sub>_                                                         | _V<sub>pub</sub>_                                                           |                                                 |
+| –                                                                         | –                 | _R<sub>priv</sub>_                                                        | –                                                                           |                                                 |
+| _R<sub>pub</sub>_                                                         | _R<sub>pub</sub>_ | _R<sub>pub</sub> = GR<sub>priv</sub>_                                     | _R<sub>pub</sub>_                                                           |                                                 |
+| _S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ | –                 | _S = R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ | _S = _R<sub>pub</sub>V<sub>priv</sub>_ = GR<sub>priv</sub>V<sub>priv</sub>_ |                                                 |
+| _P<sub>pub</sub> = K<sub>pub</sub>+G\*hachage(S)_      | –                 | _P<sub>pub</sub> = K<sub>pub</sub>+G\*hachage(S)_      | _P<sub>pub</sub> = K<sub>pub</sub>+G\*hachage(S)_        |                                                 |
+| _Adresse=f(P<sub>pub</sub>)_                           | –                 | _Adresse=f(P<sub>pub</sub>)_                           | _Adresse=f(P<sub>pub</sub>)_                             | _Adresse=f(P<sub>pub</sub>)_ |
+| _P<sub>priv</sub> = K<sub>priv</sub>+hachage(S)_       | –                 | –                                                                         | –                                                                           |                                                 |
+
+## Quand les adresses furtives tournent mal {#go-wrong}
+
+_Il n'y a pas de secrets sur la blockchain_. Bien que les adresses furtives puissent vous offrir une certaine confidentialité, cette confidentialité est sensible à l'analyse du trafic. Pour prendre un exemple trivial, imaginez que Bill finance une adresse et envoie immédiatement une transaction pour publier une valeur _R<sub>pub</sub>_. Sans le _V<sub>priv</sub>_ d'Alice, nous ne pouvons pas être sûrs qu'il s'agit d'une adresse furtive, mais c'est le pari à faire. Ensuite, nous voyons une autre transaction qui transfère tous les ETH de cette adresse vers l'adresse du fonds de campagne d'Alice. Nous ne pourrons peut-être pas le prouver, mais il est probable que Bill vient de faire un don à la campagne d'Alice. Carol le penserait certainement.
+
+Il est facile pour Bill de séparer la publication de _R<sub>pub</sub>_ du financement de l'adresse furtive (en les faisant à des moments différents, à partir d'adresses différentes). Cependant, cela est insuffisant. Le schéma que Carol recherche est que Bill finance une adresse, et qu'ensuite le fonds de campagne d'Alice retire des fonds de celle-ci.
+
+Une solution consiste à ce que la campagne d'Alice ne retire pas l'argent directement, mais l'utilise pour payer un tiers. Si la campagne d'Alice envoie 10 ETH aux services de campagne de domination mondiale de Dave, Carol sait seulement que Bill a fait un don à l'un des clients de Dave. Si Dave a suffisamment de clients, Carol ne serait pas en mesure de savoir si Bill a fait un don à Alice, qui est sa concurrente, ou à Adam, Albert ou Abigail dont Carol se moque. Alice peut inclure une valeur de hachage avec le paiement, puis fournir à Dave la pré-image, pour prouver que c'était bien son don. Alternativement, comme indiqué ci-dessus, si Alice donne à Dave son _V<sub>priv</sub>_, il sait déjà de qui provient le paiement.
+
+Le principal problème de cette solution est qu'elle exige qu'Alice se soucie du secret alors que ce secret profite à Bill. Alice peut vouloir maintenir sa réputation afin que l'ami de Bill, Bob, fasse également un don. Mais il est aussi possible qu'elle n'hésite pas à dénoncer Bill, car il aura alors peur de ce qui arrivera si Carol gagne. Bill pourrait finir par apporter encore plus de soutien à Alice.
+
+### Utilisation de plusieurs couches furtives {#multi-layer}
+
+Au lieu de compter sur Alice pour préserver la vie privée de Bill, Bill peut le faire lui-même. Il peut générer plusieurs méta-adresses pour des personnages de fiction, Bob et Bella. Bill envoie ensuite des ETH à Bob, et « Bob » (qui est en fait Bill) les envoie à Bella. « Bella » (également Bill) les envoie à Alice.
+
+Carol peut toujours faire une analyse du trafic et voir le pipeline Bill-Bob-Bella-Alice. Cependant, si « Bob » et « Bella » utilisent également des ETH à d'autres fins, il n'apparaîtra pas que Bill ait transféré quoi que ce soit à Alice, même si Alice retire immédiatement de l'adresse furtive vers l'adresse connue de sa campagne.
+
+## Écrire une application d'adresse furtive {#write-app}
+
+Cet article explique une application d'adresse furtive [disponible sur GitHub](https://github.com/qbzzt/251022-stealth-addresses.git).
+
+### Outils {#tools}
+
+Il existe [une bibliothèque d'adresses furtives typescript](https://github.com/ScopeLift/stealth-address-sdk) que nous pourrions utiliser. Cependant, les opérations cryptographiques peuvent être gourmandes en ressources de l'unité centrale. Je préfère les implémenter dans un langage compilé, tel que [Rust](https://rust-lang.org/), et utiliser [WASM](https://webassembly.org/) pour exécuter le code dans le navigateur.
+
+Nous allons utiliser [Vite](https://vite.dev/) et [React](https://react.dev/). Ce sont des outils standard de l'industrie ; si vous ne les connaissez pas, vous pouvez utiliser [ce tutoriel](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/). Pour utiliser Vite, nous avons besoin de Node.
+
+### Voir les adresses furtives en action {#in-action}
+
+1. Installez les outils nécessaires : [Rust](https://rust-lang.org/tools/install/) et [Node](https://nodejs.org/en/download).
+
+2. Clonez le dépôt GitHub.
+
+   ```sh
+   git clone https://github.com/qbzzt/251022-stealth-addresses.git
+   cd 251022-stealth-addresses
+   ```
+
+3. Installez les prérequis et compilez le code Rust.
+
+   ```sh
+   cd src/rust-wasm
+   rustup target add wasm32-unknown-unknown   
+   cargo install wasm-pack   
+   wasm-pack build --target web
+   ```
+
+4. Démarrez le serveur web.
+
+   ```sh
+   cd ../..
+   npm install
+   npm run dev
+   ```
+
+5. Accédez à [l'application](http://localhost:5173/). Cette page d'application comporte deux cadres : l'un pour l'interface utilisateur d'Alice et l'autre pour celle de Bill. Les deux cadres ne communiquent pas ; ils ne sont sur la même page que pour des raisons de commodité.
+
+6. En tant qu'Alice, cliquez sur **Generate a Stealth Meta-Address**. Cela affichera la nouvelle adresse furtive et les clés privées correspondantes. Copiez la méta-adresse furtive dans le presse-papiers.
+
+7. En tant que Bill, collez la nouvelle méta-adresse furtive et cliquez sur **Generate an address**. Cela vous donne l'adresse à financer pour Alice.
+
+8. Copiez l'adresse et la clé publique de Bill et collez-les dans la zone "Clé privée pour l'adresse générée par Bill" de l'interface utilisateur d'Alice. Une fois ces champs remplis, vous verrez la clé privée pour accéder aux actifs à cette adresse.
+
+9. Vous pouvez utiliser [un calculateur en ligne](https://iancoleman.net/ethereum-private-key-to-address/) pour vous assurer que la clé privée correspond à l'adresse.
+
+### Comment le programme fonctionne {#how-the-program-works}
+
+#### Le composant WASM {#wasm}
+
+Le code source qui se compile en WASM est écrit en [Rust](https://rust-lang.org/). Vous pouvez le voir dans [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs). Ce code est principalement une interface entre le code JavaScript et [la bibliothèque `eth-stealth-addresses`](https://github.com/kassandraoftroy/eth-stealth-addresses).
+
+**`Cargo.toml`**
+
+[`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) en Rust est analogue à [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) en JavaScript. Il contient les informations sur le paquet, les déclarations de dépendance, etc.
+
+```toml
+[package]
+name = "rust-wasm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+eth-stealth-addresses = "0.1.0"
+hex = "0.4.3"
+wasm-bindgen = "0.2.104"
+getrandom = { version = "0.2", features = ["js"] }
+```
+
+Le paquet [`getrandom`](https://docs.rs/getrandom/latest/getrandom/) doit générer des valeurs aléatoires. Cela ne peut pas être fait par des moyens purement algorithmiques ; cela nécessite l'accès à un processus physique comme source d'entropie. Cette définition spécifie que nous obtiendrons cette entropie en interrogeant le navigateur dans lequel nous nous exécutons.
+
+```toml
+console_error_panic_hook = "0.1.7"
+```
+
+[Cette bibliothèque](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) nous donne des messages d'erreur plus significatifs lorsque le code WASM panique et ne peut pas continuer.
+
+```toml
+[lib]
+crate-type = ["cdylib", "rlib"]
+```
+
+Le type de sortie requis pour produire du code WASM.
+
+**`lib.rs`**
+
+Ceci est le vrai code Rust.
+
+```rust
+use wasm_bindgen::prelude::*;
+```
+
+Les définitions pour créer un paquet WASM à partir de Rust. Elles sont documentées [ici](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html).
+
+```rust
+use eth_stealth_addresses::{
+    generate_stealth_meta_address,
+    generate_stealth_address,
+    compute_stealth_key
+};
+```
+
+Les fonctions dont nous avons besoin de [la bibliothèque `eth-stealth-addresses`](https://github.com/kassandraoftroy/eth-stealth-addresses).
+
+```rust
+use hex::{decode,encode};
+```
+
+Rust utilise généralement des [tableaux](https://doc.rust-lang.org/std/primitive.array.html) d'octets (`[u8; <taille>]`) pour les valeurs. Mais en JavaScript, nous utilisons généralement des chaînes de caractères hexadécimales. [La bibliothèque `hex`](https://docs.rs/hex/latest/hex/) traduit pour nous d'une représentation à l'autre.
+
+```rust
+#[wasm_bindgen]
+```
+
+Générer des liaisons WASM pour pouvoir appeler cette fonction depuis JavaScript.
+
+```rust
+pub fn wasm_generate_stealth_meta_address() -> String {
+```
+
+La manière la plus simple de renvoyer un objet avec plusieurs champs est de renvoyer une chaîne JSON.
+
+```rust
+    let (address, spend_private_key, view_private_key) = 
+        generate_stealth_meta_address();
+```
+
+La [`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) renvoie trois champs :
+
+- La méta-adresse (_K<sub>pub</sub>_ et _V<sub>pub</sub>_)
+- La clé privée de visualisation (_V<sub>priv</sub>_)
+- La clé privée de dépense (_K<sub>priv</sub>_)
+
+La syntaxe [tuple](https://doc.rust-lang.org/std/primitive.tuple.html) nous permet de séparer à nouveau ces valeurs.
+
+```rust
+    format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}",
+        encode(address),
+        encode(view_private_key),
+        encode(spend_private_key)
+    )
+}
+```
+
+Utilisez la macro [`format!`](https://doc.rust-lang.org/std/fmt/index.html) pour générer la chaîne codée en JSON. Utilisez [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html) pour transformer les tableaux en chaînes hexadécimales.
+
+```rust
+fn str_to_array<const N: usize>(s: &str) -> Option<[u8; N]> {
+```
+
+Cette fonction transforme une chaîne hexadécimale (fournie par JavaScript) en un tableau d'octets. Nous l'utilisons pour analyser les valeurs fournies par le code JavaScript. Cette fonction est compliquée en raison de la façon dont Rust gère les tableaux et les vecteurs.
+
+L'expression `<const N: usize>` est appelée une [générique](https://doc.rust-lang.org/book/ch10-01-syntax.html). `N` est un paramètre qui contrôle la longueur du tableau retourné. La fonction est en fait appelée `str_to_array::<n>`, où `n` est la longueur du tableau.
+
+La valeur de retour est `Option<[u8; N]>`, ce qui signifie que le tableau retourné est [facultatif](https://doc.rust-lang.org/std/option/). C'est un modèle typique en Rust pour les fonctions qui peuvent échouer.
+
+Par exemple, si nous appelons `str_to_array::10("bad060a7")`, la fonction est censée renvoyer un tableau de dix valeurs, mais l'entrée n'est que de quatre octets. La fonction doit échouer, et elle le fait en renvoyant `None`. La valeur de retour pour `str_to_array::4("bad060a7")` serait `Some<[0xba, 0xd0, 0x60, 0xa7]>`.
+
+```rust
+    // decode renvoie Result<Vec<u8>, _>
+    let vec = decode(s).ok()?;
+```
+
+La fonction [`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html) renvoie un `Result<Vec<u8>, FromHexError>`. Le type [`Result`](https://doc.rust-lang.org/std/result/) peut contenir soit un résultat réussi (`Ok(valeur)`) soit une erreur (`Err(erreur)`).
+
+La méthode `.ok()` transforme le `Result` en une `Option`, dont la valeur est soit la valeur `Ok()` en cas de succès, soit `None` dans le cas contraire. Enfin, [l'opérateur point d'interrogation](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) interrompt les fonctions actuelles et renvoie un `None` si l'`Option` est vide. Sinon, il déballe la valeur et la renvoie (dans ce cas, pour assigner une valeur à `vec`).
+
+Cela ressemble à une méthode étrangement alambiquée pour gérer les erreurs, mais `Result` et `Option` garantissent que toutes les erreurs sont gérées, d'une manière ou d'une autre.
+
+```rust
+    if vec.len() != N { return None; }
+```
+
+Si le nombre d'octets est incorrect, c'est un échec, et nous retournons `None`.
+
+```rust
+    // try_into consomme vec et tente de créer [u8; N]
+    let array: [u8; N] = vec.try_into().ok()?;
+```
+
+Rust a deux types de tableaux. Les [tableaux](https://doc.rust-lang.org/std/primitive.array.html) ont une taille fixe. Les [vecteurs](https://doc.rust-lang.org/std/vec/index.html) peuvent s'agrandir et se réduire. `hex::decode` renvoie un vecteur, mais la bibliothèque `eth_stealth_addresses` veut recevoir des tableaux. [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) convertit une valeur en un autre type, par exemple, un vecteur en un tableau.
+
+```rust
+    Some(array)
+}
+```
+
+Rust ne vous oblige pas à utiliser le mot-clé [`return`](https://doc.rust-lang.org/std/keyword.return.html) lorsque vous retournez une valeur à la fin d'une fonction.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option<String> {
+```
+
+Cette fonction reçoit une méta-adresse publique, qui inclut à la fois _V<sub>pub</sub>_ et _K<sub>pub</sub>_. Elle renvoie l'adresse furtive, la clé publique à publier (_R<sub>pub</sub>_), et une valeur d'analyse d'un octet qui accélère l'identification des adresses publiées qui peuvent appartenir à Alice.
+
+La valeur de l'analyse fait partie du secret partagé (_S = GR<sub>priv</sub>V<sub>priv</sub>_). Cette valeur est disponible pour Alice, et sa vérification est beaucoup plus rapide que de vérifier si _f(K<sub>pub</sub>+G\*hachage(S))_ est égal à l'adresse publiée.
+
+```rust
+    let (address, r_pub, scan) = 
+        generate_stealth_address(&str_to_array::<66>(stealth_address)?);
+```
+
+Nous utilisons la fonction [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html) de la bibliothèque.
+
+```rust
+    format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}",
+        encode(address),
+        encode(r_pub),
+        encode(&[scan])
+    ).into()
+}
+```
+
+Préparer la chaîne de sortie codée en JSON.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_compute_stealth_key(
+    address: &str, 
+    bill_pub_key: &str, 
+    view_private_key: &str,
+    spend_private_key: &str    
+) -> Option<String> {
+    .
+    .
+    .
+}
+```
+
+Cette fonction utilise la fonction [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html) de la bibliothèque pour calculer la clé privée permettant de retirer des fonds de l'adresse (_R<sub>priv</sub>_). Ce calcul nécessite ces valeurs :
+
+- L'adresse (_Adresse=f(P<sub>pub</sub>)_)
+- La clé publique générée par Bill (_R<sub>pub</sub>_)
+- La clé privée de visualisation (_V<sub>priv</sub>_)
+- La clé privée de dépense (_K<sub>priv</sub>_)
+
+```rust
+#[wasm_bindgen(start)]
+```
+
+[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) spécifie que la fonction est exécutée lorsque le code WASM est initialisé.
+
+```rust
+pub fn main() {
+    console_error_panic_hook::set_once();
+}
+```
+
+Ce code spécifie que la sortie de la panique soit envoyée à la console JavaScript. Pour le voir en action, utilisez l'application et donnez à Bill une méta-adresse invalide (il suffit de changer un chiffre hexadécimal). Vous verrez cette erreur dans la console JavaScript :
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9:
+assertion `left == right` failed
+  left: 0
+ right: 1
+```
+
+Suivi d'une trace de la pile d'exécution. Donnez ensuite à Bill la méta-adresse valide, et à Alice une adresse ou une clé publique invalide. Vous verrez cette erreur :
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9:
+keys do not generate stealth address
+```
+
+Encore une fois, suivi d'une trace de pile.
+
+#### L'interface utilisateur {#ui}
+
+L'interface utilisateur est écrite en utilisant [React](https://react.dev/) et servie par [Vite](https://vite.dev/). Vous pouvez en apprendre davantage sur eux en utilisant [ce tutoriel](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/). Il n'y a pas besoin de [WAGMI](https://wagmi.sh/) ici car nous n'interagissons pas directement avec une blockchain ou un portefeuille.
+
+La seule partie non évidente de l'interface utilisateur est la connectivité WASM. Voici comment ça marche.
+
+**`vite.config.js`**
+
+Ce fichier contient [la configuration de Vite](https://vite.dev/config/).
+
+```js
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import wasm from "vite-plugin-wasm";
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), wasm()],
+})
+```
+
+Nous avons besoin de deux plugins Vite : [react](https://www.npmjs.com/package/@vitejs/plugin-react) et [wasm](https://github.com/Menci/vite-plugin-wasm#readme).
+
+**`App.jsx`**
+
+Ce fichier est le composant principal de l'application. C'est un conteneur qui inclut deux composants : `Alice` et `Bill`, les interfaces utilisateur pour ces utilisateurs. La partie pertinente pour WASM est le code d'initialisation.
+
+```jsx
+import init from './rust-wasm/pkg/rust_wasm.js'
+```
+
+Lorsque nous utilisons [`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/), il crée deux fichiers que nous utilisons ici : un fichier wasm avec le code réel (ici, `src/rust-wasm/pkg/rust_wasm_bg.wasm`) et un fichier JavaScript avec les définitions pour l'utiliser (ici, `src/rust_wasm/pkg/rust_wasm.js`). L'exportation par défaut de ce fichier JavaScript est le code qui doit être exécuté pour initialiser WASM.
+
+```jsx
+function App() {
+    .
+    .
+    .
+  useEffect(() => {
+    const loadWasm = async () => {
+      try {
+        await init();
+        setWasmReady(true)
+      } catch (err) {
+        console.error('Error loading wasm:', err)
+        alert("Wasm error: " + err)
+      }
+    }
+
+    loadWasm()
+    }, []
+  )
+```
+
+Le [hook `useEffect`](https://react.dev/reference/react/useEffect) vous permet de spécifier une fonction qui s'exécute lorsque les variables d'état changent. Ici, la liste des variables d'état est vide (`[]`), donc cette fonction n'est exécutée qu'une seule fois lorsque la page se charge.
+
+La fonction d'effet doit retourner immédiatement. Pour utiliser du code asynchrone, tel que le `init` de WASM (qui doit charger le fichier `.wasm` et prend donc du temps), nous définissons une fonction interne [`async`](https://en.wikipedia.org/wiki/Async/await) et l'exécutons sans `await`.
+
+**`Bill.jsx`**
+
+C'est l'interface utilisateur pour Bill. Elle a une seule action, créer une adresse basée sur la méta-adresse furtive fournie par Alice.
+
+```jsx
+import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js'
+```
+
+En plus de l'exportation par défaut, le code JavaScript généré par `wasm-pack` exporte une fonction pour chaque fonction dans le code WASM.
+
+```jsx
+            <button onClick={() => {
+              setPublicAddress(JSON.parse(wasm_generate_stealth_address(stealthMetaAddress)))
+            }}>
+```
+
+Pour appeler les fonctions WASM, il suffit d'appeler la fonction exportée par le fichier JavaScript créé par `wasm-pack`.
+
+**`Alice.jsx`**
+
+Le code dans `Alice.jsx` est analogue, sauf qu'Alice a deux actions :
+
+- Générer une méta-adresse
+- Obtenir la clé privée pour une adresse publiée par Bill
+
+## Conclusion {#conclusion}
+
+Les adresses furtives ne sont pas la panacée ; elles doivent être [utilisées correctement](#go-wrong). Mais lorsqu'elles sont utilisées correctement, elles peuvent permettre la confidentialité sur une blockchain publique.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
\ No newline at end of file
diff --git a/public/content/translations/fr/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md b/public/content/translations/fr/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md
index 88a567b45fd..3e992f41c33 100644
--- a/public/content/translations/fr/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md
+++ b/public/content/translations/fr/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md
@@ -1,6 +1,6 @@
 ---
 title: Tester les jetons ERC-20 avec Waffle
-description: Découvrez comment tester les contrats intelligents Solidity et utiliser des correspondances de contrats intelligents avec Waffle.
+description: "Découvrez comment tester les contrats intelligents Solidity et utiliser des correspondances de contrats intelligents avec Waffle."
 author: Vladislav Starostenko
 tags:
   - "waffle"
diff --git a/public/content/translations/fr/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/fr/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
index a3bc9c409bc..c033b107ea0 100644
--- a/public/content/translations/fr/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
+++ b/public/content/translations/fr/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
@@ -1,26 +1,27 @@
 ---
-title: "The Graph : Résoudre le problème des requêtes de données du Web3"
-description: La blockchain est comme une base de données mais sans SQL. Toutes les données y sont présentes mais aucun moyen d'y accéder. Laissez-moi vous montrer comment résoudre cela avec The Graph et GraphQL.
+title: "The Graph : résoudre les problèmes de requêtes de données Web3"
+description: "La blockchain est comme une base de données mais sans SQL. Toutes les données y sont présentes mais il n'y a aucun moyen d'y accéder. Laissez-moi vous montrer comment résoudre cela avec The Graph et GraphQL."
 author: Markus Waas
 lang: fr
 tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "requêtes"
-  - "the graph"
-  - "create-eth-app"
-  - "react"
+  [
+    "Solidity",
+    "contrats intelligents",
+    "requêtes",
+    "the graph",
+    "react"
+  ]
 skill: intermediate
 published: 2020-09-06
 source: soliditydeveloper.com
 sourceUrl: https://soliditydeveloper.com/thegraph
 ---
 
-Nous allons nous intéresser de plus près à The Graph qui, depuis l'année dernière, fait essentiellement partie intégrante du stack standard pour le développement de dApps. Voyons d'abord comment nous ferions les choses de façon traditionnelle...
+Cette fois, nous allons nous intéresser de plus près à The Graph, qui est devenu au cours de l'année dernière un élément essentiel du stack standard pour le développement de dapps. Voyons d'abord comment nous ferions les choses de façon traditionnelle...
 
 ## Sans The Graph... {#without-the-graph}
 
-Prenons donc un exemple simple à titre d'illustration. Nous aimons tous les jeux, alors imaginez un jeu simple avec des utilisateurs qui placent des paris :
+Prenons donc un exemple simple à titre d'illustration. Nous aimons tous les jeux, alors imaginez un jeu simple avec des utilisateurs qui placent des paris :
 
 ```solidity
 pragma solidity 0.7.1;
@@ -35,7 +36,7 @@ contract Game {
 
         if (hasWon) {
             (bool success, ) = msg.sender.call{ value: msg.value * 2 }('');
-            require(success, "Transfer failed");
+            require(success, "Échec du transfert");
             totalGamesPlayerWon++;
         } else {
             totalGamesPlayerLost++;
@@ -46,90 +47,90 @@ contract Game {
 }
 ```
 
-Maintenant, disons que dans notre dApp, nous voulons afficher le total des mises, le total des parties perdues/gagnées et également le mettre à jour chaque fois que quelqu'un joue à nouveau. L'approche serait :
+Maintenant, disons que dans notre dapp, nous voulons afficher le total des paris, le total des parties perdues/gagnées et également mettre à jour ces informations chaque fois que quelqu'un joue à nouveau. L'approche serait :
 
 1. Récupérer `totalGamesPlayerWon`.
 2. Récupérer `totalGamesPlayerLost`.
 3. S'abonner aux événements `BetPlaced`.
 
-Nous pouvons considérer [l'événement sur Web3](https://docs.web3js.org/api/web3/class/Contract#events) comme indiqué sur la droite, mais cela nécessite de traiter pas mal de cas.
+Nous pouvons écouter l'[événement dans Web3](https://docs.web3js.org/api/web3/class/Contract#events) comme illustré à droite, mais cela nécessite de gérer un certain nombre de cas.
 
 ```solidity
 GameContract.events.BetPlaced({
     fromBlock: 0
 }, function(error, event) { console.log(event); })
 .on('data', function(event) {
-    // event fired
+    // événement déclenché
 })
 .on('changed', function(event) {
-    // event was removed again
+    // l'événement a été retiré
 })
 .on('error', function(error, receipt) {
-    // tx rejected
+    // transaction rejetée
 });
 ```
 
-C'est plutôt bien pour notre simple exemple. Mais disons que nous voulons maintenant afficher les quantités de paris perdus / gagnés uniquement pour le joueur actuel. Eh bien, pas de chance, vous devriez déployer un nouveau contrat qui stocke ces valeurs et les récupère. Et maintenant, imaginez un contrat intelligent et une dApp beaucoup plus complexes, les choses peuvent se gâter rapidement.
+Cela reste acceptable pour notre exemple simple. Mais disons que nous voulons maintenant afficher les montants des paris perdus/gagnés uniquement pour le joueur actuel. Eh bien, pas de chance, vous feriez mieux de déployer un nouveau contrat qui stocke ces valeurs et les récupère. Et maintenant, imaginez un contrat intelligent et une dapp beaucoup plus complexes, les choses peuvent vite se compliquer.
 
-![On ne se contente pas d'émettrer une requête](./one-does-not-simply-query.jpg)
+![One Does Not Simply Query](./one-does-not-simply-query.jpg)
 
-Vous pouvez voir pourquoi ce n'est pas optimal :
+Vous pouvez voir en quoi cette approche n'est pas optimale :
 
 - Ne fonctionne pas pour les contrats déjà déployés.
-- Frais supplémentaires (gaz) pour le stockage de ces valeurs.
+- Coûts de gaz supplémentaires pour stocker ces valeurs.
 - Nécessite un autre appel pour récupérer les données d'un nœud Ethereum.
 
-![Ce n'est pas assez bon](./not-good-enough.jpg)
+![Thats not good enough](./not-good-enough.jpg)
 
 Voyons maintenant une meilleure solution.
 
 ## Laissez-moi vous présenter GraphQL {#let-me-introduce-to-you-graphql}
 
-Commençons par parler de GraphQL, initialement conçu et implémenté par Facebook. Vous connaissez peut-être le modèle d'API REST traditionnel. Imaginez maintenant que vous puissiez écrire une requête pour obtenir exactement les données que vous voulez :
+Commençons par parler de GraphQL, initialement conçu et implémenté par Facebook. Vous connaissez peut-être le modèle d'API REST traditionnel. Imaginez maintenant que vous puissiez écrire une requête pour obtenir exactement les données que vous voulez :
 
-![API GraphQL vs. API REST](./graphql.jpg)
+![API GraphQL vs API REST](./graphql.jpg)
 
-<img src="https://cdn0.scrvt.com/b095ee27d37b3d7b6b150adba9ac6ec8/42226f4816a77656/bc5c8b270798/graphql-querygif.gif" width="100%" />
+![](./graphql-query.gif)
 
-Ces deux images illustrent bien l'essence de GraphQL. Avec la requête de droite, nous pouvons définir exactement les données que nous voulons. Ainsi, nous récupérons tout en une seule requête et rien de plus que ce dont nous avons exactement besoin. Un serveur GraphQL gère la récupération de toutes les données requises, il est ainsi incroyablement facile à utiliser côté consommateur. [Voici une bonne explication](https://www.apollographql.com/blog/graphql-explained) de la façon dont le serveur gère exactement une requête si vous êtes intéressé.
+Ces deux images illustrent bien l'essence de GraphQL. Avec la requête de droite, nous pouvons définir exactement les données que nous voulons. Ainsi, nous récupérons tout en une seule requête et rien de plus que ce dont nous avons exactement besoin. Un serveur GraphQL gère la récupération de toutes les données requises, ce qui le rend incroyablement facile à utiliser côté frontend. [Voici une bonne explication](https://www.apollographql.com/blog/graphql-explained) de la manière exacte dont le serveur gère une requête, si le sujet vous intéresse.
 
-Maintenant, avec cette connaissance, parlons enfin de blockchain et de The Graph.
+Maintenant, avec ces connaissances, parlons enfin de la blockchain et de The Graph.
 
-## Qu'est-ce que The Graph ? {#what-is-the-graph}
+## Qu'est-ce que The Graph ? {#what-is-the-graph}
 
-Une blockchain est une base de données décentralisée, mais contrairement à ce qui est généralement le cas, nous n'avons pas de langage de requête pour cette base de données. Les solutions pour récupérer les données sont pénibles ou totalement impossibles. The Graph est un protocole décentralisé pour l'indexation et la requête de données blockchain. Et vous l'aurez peut-être deviné, il utilise GraphQL comme langue de requête.
+Une blockchain est une base de données décentralisée, mais contrairement à ce qui est généralement le cas, nous n'avons pas de langage de requête pour cette base de données. Les solutions pour récupérer les données sont pénibles ou totalement impossibles. The Graph est un protocole décentralisé pour l'indexation et l'interrogation des données de la blockchain. Et vous l'aurez peut-être deviné, il utilise GraphQL comme langage de requête.
 
 ![The Graph](./thegraph.png)
 
 Rien de tel que quelques exemples pour comprendre une chose, alors utilisons The Graph pour notre exemple de GameContract.
 
-## Comment créer un Subgraph {#how-to-create-a-subgraph}
+## Comment créer un sous-graphe {#how-to-create-a-subgraph}
 
-La définition de comment indexer les données est appelée subgraph. Il nécessite trois composants :
+La définition de la manière d'indexer les données s'appelle un sous-graphe. Il nécessite trois composants :
 
 1. Manifeste (`subgraph.yaml`)
 2. Schéma (`schema.graphql`)
-3. Mapping (`mapping.ts`)
+3. Mappage (`mapping.ts`)
 
 ### Manifeste (`subgraph.yaml`) {#manifest}
 
-Le manifeste est notre fichier de configuration et définit :
+Le manifeste est notre fichier de configuration et définit :
 
 - quels contrats intelligents indexer (adresse, réseau, ABI...)
-- quels évènements écouter
-- d'autres éléments à prendre en compte comme des appels de fonction ou des blocs
-- les fonctions de mapping étant appelées (voir `mapping.ts` ci-dessous)
+- quels événements écouter
+- d'autres éléments à écouter, comme les appels de fonction ou les blocs
+- les fonctions de mappage qui sont appelées (voir `mapping.ts` ci-dessous)
 
-Ici, vous pouvez définir plusieurs contrats et handlers. Une configuration typique a un dossier de sous-graphes à l'intérieur du projet Hardhat avec son propre dépôt. Ensuite, vous pouvez facilement référencer l'ABI.
+Ici, vous pouvez définir plusieurs contrats et handlers. Une configuration typique aurait un dossier de sous-graphe à l'intérieur du projet Hardhat avec son propre dépôt. Ensuite, vous pouvez facilement référencer l'ABI.
 
-Pour des raisons de commodité, vous pouvez également utiliser un outil de template comme Mustache. Ensuite, vous allez créer un template `subgraph.template.yaml` et y insérez les adresses basées sur les derniers déploiements. Pour un exemple plus avancé, vous pouvez consulter le [répertoire de subgraphs Aave](https://github.com/aave/aave-protocol/tree/master/thegraph).
+Pour des raisons de commodité, vous pouvez également utiliser un outil de template comme Mustache. Ensuite, vous créez un fichier `subgraph.template.yaml` et y insérez les adresses en fonction des derniers déploiements. Pour un exemple de configuration plus avancé, voir par exemple le [dépôt du sous-graphe Aave](https://github.com/aave/aave-protocol/tree/master/thegraph).
 
 Et la documentation complète peut être consultée [ici](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest).
 
 ```yaml
 specVersion: 0.0.1
-description: Placing Bets on Ethereum
-repository: - GitHub link -
+description: Placer des paris sur Ethereum
+repository: - Lien GitHub -
 schema:
   file: ./schema.graphql
 dataSources:
@@ -157,17 +158,17 @@ dataSources:
 
 ### Schéma (`schema.graphql`) {#schema}
 
-Le schéma est la définition des données GraphQL. Il vous permettra de définir quelles entités existent et leurs types. Les types pris en charge par The Graph sont :
+Le schéma est la définition des données GraphQL. Il vous permettra de définir quelles entités existent et leurs types. Les types pris en charge par The Graph sont :
 
-- Bytes
+- Octets
 - ID
-- String (Chaîne de caractères)
+- String
 - Boolean
 - Int
 - BigInt
 - BigDecimal
 
-Vous pouvez également utiliser des entités comme type pour définir des relations. Dans notre exemple, nous définissons une relation « un à plusieurs » pour les paris d'un joueur. Le ! signifie que la valeur ne peut pas être vide. La documentation complète peut être consultée [ici](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest).
+Vous pouvez également utiliser des entités comme type pour définir des relations. Dans notre exemple, nous définissons une relation « un à plusieurs » entre un joueur et ses paris. Le `!` signifie que la valeur ne peut pas être vide. La documentation complète est disponible [ici](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest).
 
 ```graphql
 type Bet @entity {
@@ -188,15 +189,15 @@ type Player @entity {
 
 ### Mappage (`mapping.ts`) {#mapping}
 
-Le fichier de mapping dans The Graph définit nos fonctions qui transforment les événements entrants en entités. Il est écrit en AssemblyScript, un sous-ensemble de Typescript. Cela signifie qu'il peut être compilé en WASM (WebAssembly) pour une exécution plus efficace et portable du mapping.
+Le fichier de mappage dans The Graph définit nos fonctions qui transforment les événements entrants en entités. Il est écrit en AssemblyScript, un sous-ensemble de Typescript. Cela signifie qu'il peut être compilé en WASM (WebAssembly) pour une exécution plus efficace et portable du mappage.
 
-Vous devrez définir chaque fonction nommée dans le fichier `subgraph.yaml`. Ainsi dans notre cas, nous n'avons besoin que d'une seule : `handleNewBet`. Nous essayons d'abord de charger l'entité Player depuis l'adresse de l'expéditeur en tant qu'identifiant. Si elle n'existe pas, nous créons une nouvelle entité et la remplissons avec des valeurs de départ.
+Vous devrez définir chaque fonction nommée dans le fichier `subgraph.yaml`, donc dans notre cas, nous n'en avons besoin que d'une seule : `handleNewBet`. Nous essayons d'abord de charger l'entité Player depuis l'adresse de l'expéditeur en tant qu'identifiant. Si elle n'existe pas, nous créons une nouvelle entité et la remplissons avec des valeurs de départ.
 
-Puis nous créons une nouvelle entité Bet. L'ID pour cela sera `event.transaction.hash.toHex() + "-" + event.logIndex.toString()` assurant toujours une valeur unique. Utiliser uniquement le hachage n'est pas suffisant, car quelqu'un peut appeler la fonction placeBet plusieurs fois dans une transaction via un contrat intelligent.
+Puis nous créons une nouvelle entité Bet. L'identifiant pour cela sera `event.transaction.hash.toHex() + "-" + event.logIndex.toString()` ce qui garantit une valeur toujours unique. Utiliser uniquement le hachage n'est pas suffisant, car quelqu'un peut appeler la fonction placeBet plusieurs fois dans une transaction via un contrat intelligent.
 
-Enfin, nous pouvons mettre à jour l'entité du Player avec toutes les données. Les tableaux ne peuvent pas être poussés directement, mais doivent être mis à jour comme indiqué ici. Nous utilisons l'ID pour référencer le pari. Et `.save()` est requis à la fin pour stocker une entité.
+Enfin, nous pouvons mettre à jour l'entité Player avec toutes les données. Les tableaux ne peuvent pas être poussés directement, mais doivent être mis à jour comme indiqué ici. Nous utilisons l'ID pour référencer le pari. Et `.save()` est requis à la fin pour stocker une entité.
 
-La documentation complète est disponible ici : https://thegraph.com/docs/en/developing/creating-a-subgraph/#writing-mappings. Vous pouvez également ajouter une sortie de journalisation au fichier de mapping, voir [ici](https://thegraph.com/docs/en/subgraphs/developing/creating/graph-ts/api/#api-reference).
+La documentation complète est disponible ici : https://thegraph.com/docs/en/developing/creating-a-subgraph/#writing-mappings. Vous pouvez également ajouter une sortie de journalisation au fichier de mappage, voir [ici](https://thegraph.com/docs/en/subgraphs/developing/creating/graph-ts/api/#api-reference).
 
 ```typescript
 import { Bet, Player } from "../generated/schema"
@@ -206,7 +207,7 @@ export function handleNewBet(event: PlacedBet): void {
   let player = Player.load(event.transaction.from.toHex())
 
   if (player == null) {
-    // create if doesn't exist yet
+    // créer si elle n'existe pas encore
     player = new Player(event.transaction.from.toHex())
     player.bets = new Array<string>(0)
     player.totalPlayedCount = 0
@@ -229,7 +230,7 @@ export function handleNewBet(event: PlacedBet): void {
     player.hasLostCount++
   }
 
-  // update array like this
+  // mettre à jour le tableau comme ceci
   let bets = player.bets
   bets.push(bet.id)
   player.bets = bets
@@ -238,12 +239,12 @@ export function handleNewBet(event: PlacedBet): void {
 }
 ```
 
-## L'utiliser dans le Frontend {#using-it-in-the-frontend}
+## Utilisation dans le frontend {#using-it-in-the-frontend}
 
-En utilisant quelque chose comme Apollo Boost, vous pouvez facilement intégrer The Graph dans votre dApp React (ou Apollo-Vue). Surtout lorsque vous utilisez des hooks React et Apollo, récupérer des données est aussi simple que d'écrire une requête GraphQL dans votre composant. Une configuration type pourrait ressembler à ceci :
+En utilisant quelque chose comme Apollo Boost, vous pouvez facilement intégrer The Graph dans votre dapp React (ou Apollo-Vue). Surtout lorsque vous utilisez des hooks React et Apollo, récupérer des données est aussi simple que d'écrire une requête GraphQL dans votre composant. Une configuration type pourrait ressembler à ceci :
 
 ```javascript
-// See all subgraphs: https://thegraph.com/explorer/
+// Voir tous les sous-graphes : https://thegraph.com/explorer/
 const client = new ApolloClient({
   uri: "{{ subgraphUrl }}",
 })
@@ -256,11 +257,11 @@ ReactDOM.render(
 )
 ```
 
-Et maintenant, nous pouvons écrire par exemple une requête comme celle-ci. Elle nous retournera :
+Et maintenant, nous pouvons écrire par exemple une requête comme celle-ci. Elle nous récupérera :
 
 - combien de fois l'utilisateur actuel a gagné
 - combien de fois l'utilisateur actuel a perdu
-- une liste horodatée de tous ses paris précédents
+- une liste d'horodatages de tous ses paris précédents
 
 Le tout en une seule requête au serveur GraphQL.
 
@@ -285,29 +286,29 @@ React.useEffect(() => {
 }, [loading, error, data])
 ```
 
-![Magique](./magic.jpg)
+![Magie](./magic.jpg)
 
 Mais il nous manque une dernière pièce du puzzle et c'est le serveur. Vous pouvez soit l'exécuter vous-même, soit utiliser le service hébergé.
 
-## Serveur The Graph {#the-graph-server}
+## Le serveur The Graph {#the-graph-server}
 
 ### Graph Explorer : le service hébergé {#graph-explorer-the-hosted-service}
 
-Le moyen le plus simple est d'utiliser le service hébergé. Suivez les instructions [ici](https://thegraph.com/docs/en/deploying/deploying-a-subgraph-to-hosted/) pour déployer un subgraph. Pour de nombreux projets, vous pouvez trouver des subgraphs existants dans [l'explorateur](https://thegraph.com/explorer/).
+Le moyen le plus simple est d'utiliser le service hébergé. Suivez les instructions [ici](https://thegraph.com/docs/en/deploying/deploying-a-subgraph-to-hosted/) pour déployer un sous-graphe. Pour de nombreux projets, vous pouvez trouver des sous-graphes existants dans l'[explorateur](https://thegraph.com/explorer/).
 
-![Le Graph-Explorer](./thegraph-explorer.png)
+![The Graph-Explorer](./thegraph-explorer.png)
 
 ### Exécuter votre propre nœud {#running-your-own-node}
 
-Sinon, vous pouvez faire tourner votre propre nœud. Documentation [ici](https://github.com/graphprotocol/graph-node#quick-start). Une raison d'agir de la sorte peut être d'utiliser un réseau qui n'est pas pris en charge par le service hébergé. Les réseaux actuellement pris en charge [sont disponibles ici](https://thegraph.com/docs/en/developing/supported-networks/).
+Sinon, vous pouvez faire tourner votre propre nœud. La documentation se trouve [ici](https://github.com/graphprotocol/graph-node#quick-start). Une raison d'agir de la sorte peut être d'utiliser un réseau qui n'est pas pris en charge par le service hébergé. Les réseaux actuellement pris en charge [se trouvent ici](https://thegraph.com/docs/en/developing/supported-networks/).
 
-## Un avenir décentralisé {#the-decentralized-future}
+## L'avenir décentralisé {#the-decentralized-future}
 
-GraphQL prend également en charge les flux pour les nouveaux événements à venir. Ceux-ci sont pris en charge par The Graph par le biais de [Substreams](https://thegraph.com/docs/en/substreams/) qui est actuellement en version bêta ouverte.
+GraphQL prend également en charge les flux pour les nouveaux événements entrants. Ces derniers sont pris en charge sur The Graph par le biais de [Substreams](https://thegraph.com/docs/en/substreams/), qui sont actuellement en bêta ouverte.
 
-En [2021](https://thegraph.com/blog/mainnet-migration/), The Graph a commencé sa transition vers un réseau d'indexation décentralisé. Vous pouvez en savoir plus sur l'architecture de ce réseau d'indexation décentralisé [ici](https://thegraph.com/docs/en/network/explorer/).
+En [2021](https://thegraph.com/blog/mainnet-migration/), The Graph a entamé sa transition vers un réseau d'indexation décentralisé. Vous pouvez en savoir plus sur l'architecture de ce réseau d'indexation décentralisé [ici](https://thegraph.com/docs/en/network/explorer/).
 
-Les deux aspects clés sont :
+Les deux aspects clés sont :
 
 1. Les utilisateurs paient les indexeurs pour les requêtes.
-2. Les indexeurs mettront en jeu des jetons The Graph (GRT).
+2. Les indexeurs mettent en jeu des jetons Graph (GRT).
diff --git a/public/content/translations/fr/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/fr/developers/tutorials/token-integration-checklist/index.md
index 10529fa6b07..ee527094c65 100644
--- a/public/content/translations/fr/developers/tutorials/token-integration-checklist/index.md
+++ b/public/content/translations/fr/developers/tutorials/token-integration-checklist/index.md
@@ -1,84 +1,86 @@
 ---
-title: Liste des contrôles pour l'intégration de jetons
-description: Une liste des contrôles à réaliser lors d’interactions avec des jetons
+title: "Liste de contrôle pour l'intégration de jetons"
+description: "Une liste de contrôle des points à prendre en compte lors de l'interaction avec des jetons"
 author: "Trailofbits"
 lang: fr
 tags:
-  - "solidity"
-  - "contrats intelligents"
-  - "sécurité"
-  - "jetons"
+  [
+    "Solidity",
+    "contrats intelligents",
+    "sécurité",
+    "jetons"
+  ]
 skill: intermediate
 published: 2020-08-13
-source: Créer des contrats sécurisés
+source: Building secure contracts
 sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md
 ---
 
-Suivez cette liste de contrôle lorsque vous interagissez avec des jetons arbitraires. Assurez-vous de comprendre les risques associés à chaque élément et d'être capable de justifier toutes exceptions à ces règles.
+Suivez cette liste de contrôle lorsque vous interagissez avec des jetons arbitraires. Assurez-vous de bien comprendre les risques associés à chaque élément et de justifier toute exception à ces règles.
 
-Pour plus de commodité, tous les [services Slither](https://github.com/crytic/slither#tools) peuvent être directement exécutés sur une adresse de jeton, tel que :
+Pour plus de commodité, tous les [utilitaires](https://github.com/crytic/slither#tools) Slither peuvent être exécutés directement sur une adresse de jeton, comme suit :
 
-[Utilisation du tutoriel Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
+[Tutoriel sur l'utilisation de Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
 
 ```bash
 slither-check-erc 0xdac17f958d2ee523a2206206994597c13d831ec7 TetherToken
 ```
 
-Pour suivre cette liste de vérification, vous voudrez avoir cette sortie de Slither pour le jeton :
+Pour suivre cette liste de contrôle, vous aurez besoin de cette sortie de Slither pour le jeton :
 
 ```bash
 - slither-check-erc [target] [contractName] [optional: --erc ERC_NUMBER]
 - slither [target] --print human-summary
 - slither [target] --print contract-summary
-- slither-prop . --contract ContractName # requires configuration, and use of Echidna and Manticore
+- slither-prop . --contract ContractName # nécessite une configuration et l'utilisation d'Echidna et de Manticore
 ```
 
 ## Considérations générales {#general-considerations}
 
-- **Le contrat fait l'objet d'un contrôle de sécurité.** Évitez d'interagir avec des contrats qui ne font pas l'objet d'un quelconque contrôle de sécurité. Vérifiez la durée de l'évaluation (c'est-à-dire le « niveau d'effort »), la réputation de la société de sécurité, le nombre et la gravité des découvertes.
-- **Vous avez contacté les développeurs**. Vous devrez peut-être avertir leur équipe d'un incident. Recherchez des contacts appropriés sur[ blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts).
-- **Ils ont une liste de diffusions de sécurité pour les annonces critiques.** Leur équipe devrait informer les utilisateurs (comme vous !) lorsque des problèmes critiques sont trouvés ou lorsque des mises à jour se produisent.
+- **Le contrat a fait l'objet d'un audit de sécurité.** Évitez d'interagir avec des contrats qui n'ont pas fait l'objet d'un audit de sécurité. Vérifiez la durée de l'évaluation (c'est-à-dire le « niveau d'effort »), la réputation de l'entreprise de sécurité, ainsi que le nombre et la gravité des résultats.
+- **Vous avez contacté les développeurs.** Vous devrez peut-être alerter leur équipe en cas d'incident. Recherchez les contacts appropriés sur [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts).
+- **Ils disposent d'une liste de diffusion de sécurité pour les annonces critiques.** Leur équipe doit informer les utilisateurs (comme vous !) lorsque des problèmes critiques sont découverts ou que des mises à jour ont lieu.
 
 ## Conformité ERC {#erc-conformity}
 
-Slither inclut un utilitaire, [slither-check-erc](https://github.com/crytic/slither/wiki/ERC-Conformance), qui vérifie la conformité d'un token à de nombreuses normes ERC connexes. Utilisez slither-check-erc pour vérifier ceci:
+Slither inclut un utilitaire, [slither-check-erc](https://github.com/crytic/slither/wiki/ERC-Conformance), qui examine la conformité d'un jeton à de nombreuses normes ERC connexes. Utilisez slither-check-erc pour vérifier que :
 
-- **Transfer et transferFrom renvoient un booléen** Plusieurs token ne retournent pas un booléen sur ces fonctions. En conséquence, leurs appels au contrat pourraient échouer.
-- **Le nom, les décimales et les fonctions symbole sont présents si utilisés**. Ces fonctions sont optionnelles dans le standard ERC20 et pourraient ne pas être présentes.
-- **Les décimales retournent un uint8**. Plusieurs tokens retournent incorrectement un uint256. Si c'est le cas, assurez-vous que la valeur retournée est inférieure à 255.
-- **Le jeton atténue les risques connus [Problèmes de concurrence ERC20](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729).** Le standard ERC20 a un problème de concurrence bien connu qui doit être atténué pour empêcher les attaquants de voler des jetons.
-- **Le jeton n'est pas un jeton ERC777 et n'a pas d'appel de fonction externe dans le transfert et le transferFrom.** Les appels externes dans les fonctions de transfert peuvent conduire à des réentrances.
+- **`transfer` et `transferFrom` renvoient une valeur booléenne.** Plusieurs jetons ne renvoient pas de valeur booléenne sur ces fonctions. Par conséquent, leurs appels dans le contrat pourraient échouer.
+- **Les fonctions `name`, `decimals` et `symbol` sont présentes si elles sont utilisées.** Ces fonctions sont facultatives dans la norme ERC20 et peuvent ne pas être présentes.
+- **`decimals` renvoie un `uint8`.** Plusieurs jetons renvoient incorrectement un `uint256`. Si c'est le cas, assurez-vous que la valeur renvoyée est inférieure à 255.
+- **Le jeton atténue la [condition de concurrence ERC20](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729) connue.** La norme ERC20 présente une condition de concurrence connue qui doit être atténuée pour empêcher les attaquants de voler des jetons.
+- **Le jeton n'est pas un jeton ERC777 et n'a pas d'appel de fonction externe dans `transfer` et `transferFrom`.** Les appels externes dans les fonctions de transfert peuvent conduire à des réentrances.
 
-Slither inclut un utilitaire, [slither-popo](https://github.com/crytic/slither/wiki/Property-generation), qui génère des tests unitaires et des propriétés de sécurité qui peuvent découvrir de nombreuses failles ERC courantes. Utilisez slither-pop pour vérifier ceci :
+Slither inclut un utilitaire, [slither-prop](https://github.com/crytic/slither/wiki/Property-generation), qui génère des tests unitaires et des propriétés de sécurité permettant de découvrir de nombreuses failles ERC courantes. Utilisez slither-prop pour vérifier que :
 
-- **Le contrat passe tous les tests unitaires et propriétés de sécurités de slither-prop.** Exécutez ces tests unitaires générés puis vérifiez les propriétés avec [Echidna](https://github.com/crytic/echidna) et [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html).
+- **Le contrat réussit tous les tests unitaires et les propriétés de sécurité de slither-prop.** Exécutez les tests unitaires générés, puis vérifiez les propriétés avec [Echidna](https://github.com/crytic/echidna) et [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html).
 
-Enfin, il y a certaines caractéristiques qui sont difficiles à détecter automatiquement. Vérifiez ces conditions manuellement :
+Enfin, certaines caractéristiques sont difficiles à identifier automatiquement. Examinez manuellement ces conditions :
 
-- **Transfer et transferFrom ne doivent pas prendre de frais.** Les tokens déflationnistes peuvent conduire à des comportements inattendus.
-- **L'intérêt potentiel gagné à partir d'un token est pris en compte.** Certains tokens distribuent des intérêts aux détenteurs de jetons. Cet intérêt pourrait être pris au piège dans un contrat s'il n'est pas pris en compte.
+- **`transfer` et `transferFrom` ne doivent pas prélever de frais.** Les jetons déflationnistes peuvent entraîner un comportement inattendu.
+- **Les intérêts potentiels générés par le jeton sont pris en compte.** Certains jetons distribuent des intérêts aux détenteurs de jetons. Ces intérêts pourraient être bloqués dans le contrat s'ils ne sont pas pris en compte.
 
-## Composition de contrat {#contract-composition}
+## Composition du contrat {#contract-composition}
 
-- **Le contrat évite la complexité inutile.** Le jeton devrait être un simple contrat ; un jeton avec un code compliqué nécessite un niveau de contrôle accru. Utilisez [l'imprimante human-summary](https://github.com/crytic/slither/wiki/Printer-documentation#human-summary) de Slither pour identifier les codes complexes.
-- **Le contrat utilise SafeMath.** Les contrats qui n'utilisent pas SafeMath nécessitent un examen approfondi. Inspectez le contrat manuellement pour l'utilisation de SafeMath.
-- **Le contrat ne possède que quelques fonctions non liées au jeton.** Les fonctions non relatives au jeton augmentent la probabilité d'un problème dans le contrat. Utilisez [l'afficheur contract-summary](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) de Slither pour revoir largement le code utilisé dans le contrat.
-- **Le jeton n'a qu'une seule adresse.** Les jetons avec plusieurs points d'entrée pour les mises à jour de solde peuvent casser la comptabilité interne basée sur l'adresse (ex. `balances[token_address][msg.sender]` pourrait ne pas refléter le solde réel).
+- **Le contrat évite toute complexité inutile.** Le jeton doit être un contrat simple ; un jeton avec un code complexe nécessite un niveau d'examen plus élevé. Utilisez le [rapport de résumé pour humains](https://github.com/crytic/slither/wiki/Printer-documentation#human-summary) de Slither pour identifier le code complexe.
+- **Le contrat utilise SafeMath.** Les contrats qui n'utilisent pas SafeMath nécessitent un niveau d'examen plus élevé. Inspectez manuellement le contrat pour vérifier l'utilisation de SafeMath.
+- **Le contrat ne comporte que quelques fonctions non liées aux jetons.** Les fonctions non liées aux jetons augmentent la probabilité d'un problème dans le contrat. Utilisez le [rapport de résumé de contrat](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) de Slither pour examiner globalement le code utilisé dans le contrat.
+- **Le jeton ne possède qu'une seule adresse.** Les jetons avec plusieurs points d'entrée pour les mises à jour de solde peuvent perturber la comptabilité interne basée sur l'adresse (par exemple, `balances[token_address][msg.sender]` pourrait ne pas refléter le solde réel).
 
 ## Privilèges du propriétaire {#owner-privileges}
 
-- **Le jeton ne peut pas être mis à niveau.** Les contrats modifiables peuvent changer leurs règles au fil du temps. Utilisez l'imprimante [l'imprimante human-summary](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) de Slither pour déterminer si une mise à niveau du contrat est possible.
-- **Le propriétaire a des capacités de frappe limitées.** Les propriétaires malveillants ou compromis peuvent abuser des capacités de frappe. Utilisez [l'imprimante human-summary](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) de Slither pour examiner les capacités de frappe et envisagez de revoir le code manuellement .
-- **Le jeton ne peut pas être mis en pause.** Les propriétaires malveillants ou compromis peuvent piéger des contrats en mettant les jetons en pause. Identifiez manuellement le code en pause.
-- **Le propriétaire ne peut pas mettre sur liste noire le contrat.** Les propriétaires malveillants ou compromis peuvent piéger des contrats en s'appuyant sur des jetons avec une liste noire. Identifiez manuellement les fonctionnalités de la liste noire.
-- **L'équipe derrière le jeton est connue et peut être tenue responsable d'abus.** Les contrats ayant des équipes de développement anonymes, ou qui résident dans des juridictions douteuses nécessitent un niveau d'examen plus rigoureux.
+- **Le jeton ne peut pas être mis à niveau.** Les contrats pouvant être mis à niveau peuvent changer leurs règles au fil du temps. Utilisez le [rapport de résumé pour humains](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) de Slither pour déterminer si le contrat peut être mis à niveau.
+- **Le propriétaire dispose de capacités de frappe limitées.** Des propriétaires malveillants ou compromis peuvent abuser des capacités de frappe. Utilisez le [rapport de résumé pour humains](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) de Slither pour examiner les capacités de frappe et envisagez d'examiner manuellement le code.
+- **Le jeton ne peut pas être mis en pause.** Des propriétaires malveillants ou compromis peuvent bloquer les contrats qui dépendent de jetons pouvant être mis en pause. Identifiez manuellement le code pouvant être mis en pause.
+- **Le propriétaire ne peut pas mettre le contrat sur liste noire.** Des propriétaires malveillants ou compromis peuvent bloquer des contrats qui dépendent de jetons dotés d'une liste noire. Identifiez manuellement les fonctionnalités de mise sur liste noire.
+- **L'équipe derrière le jeton est connue et peut être tenue pour responsable en cas d'abus.** Les contrats dont les équipes de développement sont anonymes ou qui résident dans des paradis juridiques devraient exiger un niveau d'examen plus élevé.
 
-## Rareté des jetons {#token-scarcity}
+## Rareté du jeton {#token-scarcity}
 
-Rechercher des problèmes liés à la rareté des jetons nécessite un examen manuel. Vérifiez les conditions suivantes :
+L'examen des problèmes de rareté des jetons nécessite un examen manuel. Vérifiez les conditions suivantes :
 
-- **Personne ne possède la plupart de l'approvisionnement.** Si quelques utilisateurs possèdent la plupart des jetons, ils peuvent influencer les opérations basées sur la répartition du jeton.
-- **L'approvisionnement total est suffisant.** Les jetons avec un faible volume total peuvent être facilement manipulés.
-- **Les jetons sont disponibles sur de nombreuses plateformes d'échanges.** Si tous les jetons sont sur une seule plateforme, sa compromission peut affecter le contrat s'appuyant sur le jeton.
-- **Les utilisateurs comprennent les risques associés aux grands volumes de fonds ou aux prêts éclair.** Les contrats s'appuyant sur le solde de jetons doivent être soigneusement analysés notamment au regard des attaquants avec des fonds importants ou des attaques par le biais de prêts éclair .
-- **Le jeton n'autorise pas la frappe éclair**. Les frappes éclair peuvent entraîner des fluctuations substantielles du solde et de l'approvisionnement total, ce qui exige des contrôles stricts et complets sur les risques de débordement dans le fonctionnement du jeton.
+- **Aucun utilisateur ne détient la majorité de l'offre.** Si quelques utilisateurs détiennent la plupart des jetons, ils peuvent influencer les opérations en fonction de la répartition du jeton.
+- **L'offre totale est suffisante.** Les jetons dont l'offre totale est faible peuvent être facilement manipulés.
+- **Les jetons sont disponibles sur plus que quelques plateformes d'échange.** Si tous les jetons se trouvent sur une seule plateforme d'échange, une compromission de celle-ci peut compromettre le contrat qui dépend du jeton.
+- **Les utilisateurs comprennent les risques associés aux fonds importants ou aux prêts flash.** Les contrats qui dépendent du solde des jetons doivent soigneusement prendre en considération les attaquants disposant de fonds importants ou les attaques par prêts flash.
+- **Le jeton ne permet pas la frappe flash**. La frappe flash peut entraîner des fluctuations importantes du solde et de l'offre totale, ce qui nécessite des vérifications de dépassement strictes et complètes dans le fonctionnement du jeton.
diff --git a/public/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/public/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
index fed3fe3d9ac..ce6f2129498 100644
--- a/public/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
+++ b/public/content/translations/fr/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -1,12 +1,14 @@
 ---
-title: Transferts et approbation des jetons ERC-20 à partir d'un contrat intelligent de solidity
-description: Comment utiliser un contrat intelligent pour interagir avec un jeton en utilisant le langage Solidity
+title: "Transferts et approbation de jetons ERC-20 à partir d'un contrat intelligent Solidity"
+description: "Construire un contrat intelligent DEX qui gère les transferts et les approbations de jetons ERC-20 en utilisant Solidity."
 author: "jdourlens"
 tags:
-  - "contrats intelligents"
-  - "jetons"
-  - "solidity"
-  - "erc-20"
+  [
+    "contrats intelligents",
+    "jetons",
+    "Solidity",
+    "erc-20"
+  ]
 skill: intermediate
 lang: fr
 published: 2020-04-07
@@ -15,16 +17,16 @@ sourceUrl: https://ethereumdev.io/transfers-and-approval-or-erc20-tokens-from-a-
 address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 ---
 
-Dans le tutoriel précédent, nous avons étudié [l'anatomie d'un jeton ERC-20 dans Solidity](/developers/tutorials/understand-the-erc-20-token-smart-contract/) sur la blockchain Ethereum. Dans cet article, nous allons voir comment nous pouvons utiliser un contrat intelligent pour interagir avec un jeton en utilisant le langage Solidity.
+Dans le tutoriel précédent, nous avons étudié [l'anatomie d'un jeton ERC-20 dans Solidity](/developers/tutorials/understand-the-erc-20-token-smart-contract/) sur la blockchain Ethereum. Dans cet article, nous verrons comment nous pouvons utiliser un contrat intelligent pour interagir avec un jeton en utilisant le langage Solidity.
 
-Pour ce contrat intelligent, nous allons créer un échange décentralisé très rudimentaire où un utilisateur pourra échanger de l'Ether contre notre nouveau [jeton ERC-20](/developers/docs/standards/tokens/erc-20/) récemment déployé.
+Pour ce contrat intelligent, nous allons créer un véritable échange décentralisé factice où un utilisateur pourra échanger de l'éther contre notre [jeton ERC-20](/developers/docs/standards/tokens/erc-20/) nouvellement déployé.
 
-Pour ce tutoriel, nous utiliserons le code que nous avons écrit dans le tutoriel précédent comme base. Notre DEX instanciera une instance du contrat dans son constructeur et effectuera les opérations de :
+Pour ce tutoriel, nous utiliserons le code que nous avons écrit dans le tutoriel précédent comme base. Notre DEX instanciera une instance du contrat dans son constructeur et effectuera les opérations suivantes :
 
-- échange de jetons en ethers
-- échange d'ethers contre des jetons
+- échanger des jetons contre de l'éther
+- échanger de l'éther contre des jetons
 
-Nous allons commencer notre code d'échange décentralisé en ajoutant notre simple base de code ERC20 :
+Nous allons commencer le code de notre échange décentralisé en ajoutant notre base de code ERC20 simple :
 
 ```solidity
 pragma solidity ^0.8.0;
@@ -60,11 +62,11 @@ contract ERC20Basic is IERC20 {
 
 
    constructor() {
-    balances[msg.sender] = totalSupply_;
+	balances[msg.sender] = totalSupply_;
     }
 
     function totalSupply() public override view returns (uint256) {
-    return totalSupply_;
+	return totalSupply_;
     }
 
     function balanceOf(address tokenOwner) public override view returns (uint256) {
@@ -104,7 +106,7 @@ contract ERC20Basic is IERC20 {
 
 ```
 
-Notre nouveau contrat intelligent DEX déploiera l'ERC-20 et fera tout le nécessaire :
+Notre nouveau contrat intelligent DEX déploiera l'ERC-20 et obtiendra toute la réserve de jetons :
 
 ```solidity
 contract DEX {
@@ -129,82 +131,82 @@ contract DEX {
 }
 ```
 
-Nous avons à présent notre DEX et il possède toute la réserve de jetons disponibles. Le contrat a deux fonctions :
+Nous avons donc maintenant notre DEX et il dispose de toute la réserve de jetons. Le contrat a deux fonctions :
 
-- `Acheter` : L'utilisateur peut envoyer des ethers et obtenir des jetons en échange
-- `sell` : L'utilisateur peut décider d'envoyer des jetons pour récupérer des ethers
+- `buy` : L'utilisateur peut envoyer de l'éther et obtenir des jetons en échange
+- `sell` : L'utilisateur peut envoyer des jetons pour récupérer de l'éther
 
-## La fonction d'achat {#the-buy-function}
+## La fonction buy {#the-buy-function}
 
-Codons la fonction achat. Nous devrons d'abord vérifier la quantité d'ethers que le message contient et vérifier que les contrats possèdent suffisamment de jetons et que le message contient un peu d'ethers dedans. Si le contrat possède suffisamment de jetons, il enverra le nombre de jetons à l'utilisateur et émettra l'événement `Acheté`.
+Codons la fonction buy. Nous devrons d'abord vérifier la quantité d'éther que le message contient et vérifier que le contrat possède suffisamment de jetons et que le message contient bien de l'éther. Si le contrat possède suffisamment de jetons, il enverra le nombre de jetons à l'utilisateur et émettra l'événement `Bought`.
 
-Notez que si nous appelons la fonction require dans le cas d'une erreur, l'ether envoyé sera directement restauré et restitué à l'utilisateur.
+Notez que si nous appelons la fonction `require`, en cas d'erreur, l'éther envoyé sera directement annulé et rendu à l'utilisateur.
 
-Pour garder les choses simples, il suffit d'échanger 1 jeton contre 1 Wei.
+Pour simplifier, nous échangeons simplement 1 jeton contre 1 wei.
 
 ```solidity
 function buy() payable public {
     uint256 amountTobuy = msg.value;
     uint256 dexBalance = token.balanceOf(address(this));
-    require(amountTobuy > 0, "You need to send some ether");
-    require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
+    require(amountTobuy > 0, "Vous devez envoyer de l'éther");
+    require(amountTobuy <= dexBalance, "Pas assez de jetons dans la réserve");
     token.transfer(msg.sender, amountTobuy);
     emit Bought(amountTobuy);
 }
 ```
 
-Dans le cas où l'achat est réussi, nous devrions voir deux événements dans la transaction : le jeton `Transfert` et l'événement `Achat`.
+Si l'achat réussit, nous devrions voir deux événements dans la transaction : l'événement de jeton `Transfer` et l'événement `Bought`.
 
-![Deux événements dans la transaction : Transfert et Achat](./transfer-and-bought-events.png)
+![Deux événements dans la transaction : Transfer et Bought](./transfer-and-bought-events.png)
 
-## La fonction de vente {#the-sell-function}
+## La fonction sell {#the-sell-function}
 
-La fonction responsable de la vente demandera d'abord à l'utilisateur d'avoir approuvé le montant en appelant la fonction d'approbation au préalable. L'approbation du transfert nécessite que le jeton ERC20Basic, instancié par le DEX, soit appelé par l'utilisateur. Ceci peut être réalisé en appelant d'abord la fonction `token()` du contrat DEX pour récupérer l'adresse où DEX a déployé le contrat ERC20Basic appelé `token`. Ensuite, nous créons une instance de ce contrat dans notre session et appelons sa fonction `approve`. Ensuite, nous pouvons appeler la fonction DEX `sell` et échanger nos jetons contre des ethers. Par exemple, voici à quoi cela ressemble dans une session de navigation interactive :
+La fonction responsable de la vente exigera d'abord que l'utilisateur ait approuvé le montant en appelant au préalable la fonction `approve`. L'approbation du transfert exige que le jeton ERC20Basic instancié par le DEX soit appelé par l'utilisateur. Cela peut être réalisé en appelant d'abord la fonction `token()` du contrat DEX pour récupérer l'adresse où le DEX a déployé le contrat ERC20Basic appelé `token`. Ensuite, nous créons une instance de ce contrat dans notre session et appelons sa fonction `approve`. Ensuite, nous pouvons appeler la fonction `sell` du DEX et échanger nos jetons contre de l'éther. Par exemple, voici à quoi cela ressemble dans une session interactive de Brownie :
 
 ```python
 #### Python in interactive brownie console...
 
-# deploy the DEX
+# déployer le DEX
 dex = DEX.deploy({'from':account1})
 
-# call the buy function to swap ether for token
-# 1e18 is 1 ether denominated in wei
+# appeler la fonction buy pour échanger de l'éther contre un jeton
+# 1e18 correspond à 1 éther exprimé en wei
 dex.buy({'from': account2, 1e18})
 
-# get the deployment address for the ERC20 token
-# that was deployed during DEX contract creation
-# dex.token() returns the deployed address for token
+# obtenir l'adresse de déploiement du jeton ERC20
+# qui a été déployé lors de la création du contrat DEX
+# dex.token() renvoie l'adresse déployée pour le jeton
 token = ERC20Basic.at(dex.token())
 
-# call the token's approve function
-# approve the dex address as spender
-# and how many of your tokens it is allowed to spend
+# appeler la fonction approve du jeton
+# approuver l'adresse du dex en tant que dépensier
+# et le nombre de vos jetons qu'il est autorisé à dépenser
 token.approve(dex.address, 3e18, {'from':account2})
 
 ```
 
-Ensuite, lorsque la fonction de vente est appelée, nous vérifierons si le transfert de l’adresse de l’appelant à l’adresse du contrat a été réussi et nous retournerons ensuite les ethers à l’adresse de l’appelant.
+Ensuite, lorsque la fonction `sell` est appelée, nous vérifierons si le transfert depuis l'adresse de l'appelant vers l'adresse du contrat a réussi, puis nous renverrons l'éther à l'adresse de l'appelant.
 
 ```solidity
 function sell(uint256 amount) public {
-    require(amount > 0, "You need to sell at least some tokens");
+    require(amount > 0, "Vous devez vendre au moins quelques jetons");
     uint256 allowance = token.allowance(msg.sender, address(this));
-    require(allowance >= amount, "Check the token allowance");
+    require(allowance >= amount, "Vérifiez l'allocation de jetons");
     token.transferFrom(msg.sender, address(this), amount);
     payable(msg.sender).transfer(amount);
     emit Sold(amount);
 }
 ```
 
-Si tout fonctionne correctement, vous devriez voir 2 événements (un `Transfer` et `Sold`) dans la transaction, ainsi que la mise à jour de votre solde de jetons et de votre solde d'Ether.
+Si tout fonctionne, vous devriez voir 2 événements (un `Transfer` et un `Sold`) dans la transaction, et votre solde de jetons ainsi que votre solde d'éther mis à jour.
 
-![Deux événements dans la transaction : le transfert et la vente](./transfer-and-sold-events.png)
+![Deux événements dans la transaction : Transfer et Sold](./transfer-and-sold-events.png)
 
 <Divider />
 
-À partir de ce tutoriel, nous avons vu comment vérifier le solde et la provision d'un jeton ERC-20 et comment appeler `Transfer` et `TransferFrom` d'un contrat intelligent ERC20 à l'aide de l'interface.
+Dans ce tutoriel, nous avons vu comment vérifier le solde et l'allocation d'un jeton ERC-20, ainsi que la manière d'appeler `Transfer` et `TransferFrom` d'un contrat intelligent ERC20 en utilisant l'interface.
 
-Une fois que vous avez effectué une transaction, nous avons un tutoriel JavaScript pour [attendre et obtenir des détails sur les transactions](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/) qui ont été réalisées dans votre contrat et un [tutoriel pour décoder les événements générés par des transferts de jetons ou tout autre événement](https://ethereumdev.io/how-to-decode-event-logs-in-javascript-using-abi-decoder/) tant que vous disposez de l'ABI.
+Une fois que vous avez effectué une transaction, nous avons un tutoriel JavaScript pour [attendre et obtenir les détails sur les transactions](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/) qui ont été effectuées sur votre contrat et un [tutoriel pour décoder les événements générés par les transferts de jetons ou tout autre événement](https://ethereumdev.io/how-to-decode-event-logs-in-javascript-using-abi-decoder/) tant que vous avez l'ABI.
 
 Voici le code complet du tutoriel :
 
@@ -242,11 +244,11 @@ contract ERC20Basic is IERC20 {
 
 
    constructor() {
-    balances[msg.sender] = totalSupply_;
+	balances[msg.sender] = totalSupply_;
     }
 
     function totalSupply() public override view returns (uint256) {
-    return totalSupply_;
+	return totalSupply_;
     }
 
     function balanceOf(address tokenOwner) public override view returns (uint256) {
@@ -299,16 +301,16 @@ contract DEX {
     function buy() payable public {
         uint256 amountTobuy = msg.value;
         uint256 dexBalance = token.balanceOf(address(this));
-        require(amountTobuy > 0, "You need to send some ether");
-        require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
+        require(amountTobuy > 0, "Vous devez envoyer de l'éther");
+        require(amountTobuy <= dexBalance, "Pas assez de jetons dans la réserve");
         token.transfer(msg.sender, amountTobuy);
         emit Bought(amountTobuy);
     }
 
     function sell(uint256 amount) public {
-        require(amount > 0, "You need to sell at least some tokens");
+        require(amount > 0, "Vous devez vendre au moins quelques jetons");
         uint256 allowance = token.allowance(msg.sender, address(this));
-        require(allowance >= amount, "Check the token allowance");
+        require(allowance >= amount, "Vérifiez l'allocation de jetons");
         token.transferFrom(msg.sender, address(this), amount);
         payable(msg.sender).transfer(amount);
         emit Sold(amount);
diff --git a/public/content/translations/fr/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md b/public/content/translations/fr/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
index c952de2380e..8ae9ee1f10a 100644
--- a/public/content/translations/fr/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
+++ b/public/content/translations/fr/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
@@ -1,12 +1,14 @@
 ---
 title: Comprendre le contrat intelligent de jeton ERC-20
-description: Introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum
+description: "Apprenez à mettre en œuvre la norme de jeton ERC-20 avec un exemple complet de contrat intelligent Solidity et son explication."
 author: "jdourlens"
 tags:
-  - "contrats intelligents"
-  - "jetons"
-  - "solidity"
-  - "erc-20"
+  [
+    "contrats intelligents",
+    "jetons",
+    "Solidity",
+    "erc-20"
+  ]
 skill: beginner
 lang: fr
 published: 2020-04-05
@@ -15,11 +17,11 @@ sourceUrl: https://ethereumdev.io/understand-the-erc20-token-smart-contract/
 address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
 ---
 
-L'un des plus importantes [normes de contrat intelligent](/developers/docs/standards/) sur Ethereum est connue sous le nom de [ERC-20](/developers/docs/standards/tokens/ERC-20/), qui est apparu comme le standard technique de référence pour tous les contrats intelligents sur la blockchain Ethereum pour les implémentations de jetons fongibles.
+L'une des [normes de contrat intelligent](/developers/docs/standards/) les plus importantes sur Ethereum est connue sous le nom d'[ERC-20](/developers/docs/standards/tokens/erc-20/). Elle s'est imposée comme la norme technique utilisée pour tous les contrats intelligents sur la blockchain Ethereum pour les implémentations de jetons fongibles.
 
-ERC-20 définit une liste commune de règles auxquelles tous les jetons Ethereum fongibles devraient adhérer. Par conséquent, cette norme de jeton permet aux développeurs de tous types de prédire avec précision comment de nouveaux jetons fonctionneront au sein du système Ethereum dans son ensemble. Cela simplifie et facilite les tâches des développeurs, car ils peuvent se concentrer sur leur travail tout en sachant que chacun de leurs projets et chaque nouveau projet n'aura pas besoin d'être refait ou modifié à chaque fois qu'un nouveau jeton est publié, à condition que le jeton respecte les règles.
+L'ERC-20 définit une liste commune de règles auxquelles tous les jetons Ethereum fongibles doivent adhérer. Par conséquent, cette norme de jeton permet aux développeurs de tous types de prédire avec précision comment les nouveaux jetons fonctionneront au sein du système Ethereum. Cela simplifie et facilite la tâche des développeurs, car ils peuvent poursuivre leur travail, sachant que les projets n'auront pas besoin d'être refaits à chaque sortie d'un nouveau jeton, tant que ce dernier respecte les règles.
 
-Voici les fonctions, présentées comme une interface, que tout jeton ERC-20 doit implémenter. Si vous n'êtes pas sûr de ce qu'est une interface : consultez notre article sur la programmation [orientée objet dans Solidity](https://ethereumdev.io/inheritance-in-solidity-contracts-are-classes/).
+Voici, présentées sous forme d'interface, les fonctions qu'un ERC-20 doit mettre en œuvre. Si vous n'êtes pas sûr de ce qu'est une interface, consultez notre article sur [la programmation orientée objet dans Solidity](https://ethereumdev.io/inheritance-in-solidity-contracts-are-classes/).
 
 ```solidity
 pragma solidity ^0.6.0;
@@ -48,19 +50,19 @@ Voici une explication ligne par ligne de ce à quoi sert chaque fonction. Après
 function totalSupply() external view returns (uint256);
 ```
 
-Renvoie le nombre total de jetons existants. Cette fonction est un getter et ne modifie pas l'état du contrat. Gardez à l'esprit qu'il n'y a pas de nombres décimaux dans Solidity. C'est pourquoi la plupart des jetons adoptent 18 décimales et retournent le total des jetons ainsi que d'autres résultats sous la forme de 1000000000000000000 pour 1 jeton. Tous les jetons n'ont pas nécessairement 18 décimales et c'est donc un élément à surveiller lorsqu'on manipule des jetons.
+Renvoie le nombre total de jetons existants. Cette fonction est un getter et ne modifie pas l'état du contrat. Gardez à l'esprit qu'il n'y a pas de nombres à virgule flottante dans Solidity. Par conséquent, la plupart des jetons adoptent 18 décimales et renvoient l'offre totale et d'autres résultats sous la forme 1000000000000000000 pour 1 jeton. Tous les jetons n'ont pas 18 décimales, et c'est un point auquel vous devez vraiment faire attention lorsque vous manipulez des jetons.
 
 ```solidity
 function balanceOf(address account) external view returns (uint256);
 ```
 
-Renvoie le nombre de jetons détenus par une adresse (`compte`). Cette fonction est un getter et ne modifie pas l'état du contrat.
+Renvoie la quantité de jetons détenus par une adresse (`compte`). Cette fonction est un getter et ne modifie pas l'état du contrat.
 
 ```solidity
 function allowance(address owner, address spender) external view returns (uint256);
 ```
 
-La norme ERC-20 permet à une adresse de donner une allocation (« allowance ») à une autre adresse pour pouvoir récupérer des jetons à partir de celle-ci. Ce getter retourne le nombre restant de jetons que le `dépenseur` sera autorisé à dépenser au nom du `propriétaire`. Cette fonction est un getter et ne modifie pas l'état du contrat et doit retourner 0 par défaut.
+La norme ERC-20 permet à une adresse de donner une allocation (« allowance ») à une autre adresse afin que cette dernière puisse en retirer des jetons. Ce getter renvoie le nombre de jetons restants que le `spender` sera autorisé à dépenser au nom du `owner`. Cette fonction est un getter, ne modifie pas l'état du contrat et doit renvoyer 0 par défaut.
 
 ## Fonctions {#functions}
 
@@ -68,19 +70,19 @@ La norme ERC-20 permet à une adresse de donner une allocation (« allowance »)
 function transfer(address recipient, uint256 amount) external returns (bool);
 ```
 
-Déplace le montant `amount` de jetons de l'adresse de l'appelant de la fonction (`msg.sender`) à l'adresse du destinataire. Cette fonction émet l'événement `Transfert` que nous expliquerons plus tard. Il renvoie « vrai » si le transfert a été possible.
+Déplace la quantité (`amount`) de jetons de l'adresse de l'appelant de la fonction (`msg.sender`) à l'adresse du destinataire. Cette fonction émet l'événement `Transfer` défini plus loin. Elle renvoie `true` si le transfert a été possible.
 
 ```solidity
 function approve(address spender, uint256 amount) external returns (bool);
 ```
 
-Définit le montant de `l'allocation` que le dépenseur `spender` est autorisé à transférer à partir du solde de l'appelant de la fonction (`msg.sender`). Cette fonction émet l'événement d'approbation « Approval ». La fonction retourne si l'allocation a été mise en place avec succès.
+Définit le montant de l'`allowance` que le `spender` est autorisé à transférer depuis le solde de l'appelant de la fonction (`msg.sender`). Cette fonction émet l'événement `Approval`. La fonction renvoie une valeur indiquant si l'allocation a été définie avec succès.
 
 ```solidity
 function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 ```
 
-Déplace le montant `amount` de jetons de `l'expéditeur` vers `le destinataire` en utilisant le mécanisme de provision « allowance ». le montant est ensuite déduit de la provision « allowance » de l'appelant. Cette fonction émet l'événement `Transfert` .
+Déplace la quantité (`amount`) de jetons de `sender` à `recipient` en utilisant le mécanisme d'allocation. La quantité `amount` est ensuite déduite de l'allocation de l'appelant. Cette fonction émet l'événement `Transfer`.
 
 ## Événements {#events}
 
@@ -88,19 +90,19 @@ Déplace le montant `amount` de jetons de `l'expéditeur` vers `le destinataire`
 event Transfer(address indexed from, address indexed to, uint256 value);
 ```
 
-Cet événement est émis lorsque le nombre de jetons (valeur) est envoyé depuis l'adresse `de` à l'adresse `à`.
+Cet événement est émis lorsque la quantité de jetons (`value`) est envoyée de l'adresse `from` à l'adresse `to`.
 
-Dans le cas du minage de nouveaux jetons, le transfert s'opère généralement `depuis` l'adresse 0x00..000 alors que dans le cas d'une destruction de jetons, le transfert s'opère `vers` l'adresse 0x00..0000.
+En cas de frappe de nouveaux jetons, le transfert est généralement `from` l'adresse 0x00..0000, tandis qu'en cas de destruction (« burn ») de jetons, le transfert est `to` l'adresse 0x00..0000.
 
 ```solidity
 event Approval(address indexed owner, address indexed spender, uint256 value);
 ```
 
-Cet événement est émis lorsque le nombre de jetons (`value`) est approuvé par le propriétaire `owner` pour etre utilisé par le dépenseur `spender`.
+Cet événement est émis lorsque la quantité de jetons (`value`) est approuvée par le `owner` pour être utilisée par le `spender`.
 
 ## Une implémentation basique des jetons ERC-20 {#a-basic-implementation-of-erc-20-tokens}
 
-Voici le code le plus simple possible à prendre comme base pour votre jeton ERC-20 :
+Voici le code le plus simple sur lequel baser votre jeton ERC-20 :
 
 ```solidity
 pragma solidity ^0.8.0;
@@ -136,11 +138,11 @@ contract ERC20Basic is IERC20 {
 
 
    constructor() {
-    balances[msg.sender] = totalSupply_;
+	balances[msg.sender] = totalSupply_;
     }
 
     function totalSupply() public override view returns (uint256) {
-    return totalSupply_;
+	return totalSupply_;
     }
 
     function balanceOf(address tokenOwner) public override view returns (uint256) {
@@ -178,4 +180,4 @@ contract ERC20Basic is IERC20 {
 }
 ```
 
-Une autre excellente implémentation de la norme de jeton ERC-20 est l'implémentation [OpenZeppelin ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
+Une autre excellente implémentation de la norme de jeton ERC-20 est l'[implémentation ERC-20 d'OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
diff --git a/public/content/translations/fr/developers/tutorials/uniswap-v2-annotated-code/index.md b/public/content/translations/fr/developers/tutorials/uniswap-v2-annotated-code/index.md
index ffd0da82b7c..04a33065977 100644
--- a/public/content/translations/fr/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/public/content/translations/fr/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -1,9 +1,8 @@
 ---
 title: "Visite guidée du contrat Uniswap-v2"
-description: Comment fonctionne le contrat Uniswap-v2 ? Pourquoi est-il écrit de cette façon ?
+description: "Comment fonctionne le contrat Uniswap-v2 ? Pourquoi est-il écrit de cette façon ?"
 author: Ori Pomerantz
-tags:
-  - "solidity"
+tags: [ "solidité" ]
 skill: intermediate
 published: 2021-05-01
 lang: fr
@@ -11,81 +10,82 @@ lang: fr
 
 ## Introduction {#introduction}
 
-[Uniswap v2](https://uniswap.org/whitepaper.pdf) permet de créer un marché d'échange entre deux jetons ERC-20 quels qu'ils soient. Dans cet article nous allons passer en revue le code source des contrats qui implémentent ce protocole et voir pourquoi ils sont écrits comme ils le sont.
+[Uniswap v2](https://app.uniswap.org/whitepaper.pdf) peut créer un marché d'échange entre deux jetons ERC-20, quels qu'ils soient. Dans cet article, nous allons passer en revue le code source des contrats qui implémentent ce protocole et voir pourquoi ils sont écrits comme ils le sont.
 
 ### Que fait Uniswap ? {#what-does-uniswap-do}
 
-Fondamentalement, il existe deux types d'utilisateurs : les fournisseurs de liquidités et les négociants également appelés traders.
+Fondamentalement, il existe deux types d'utilisateurs : les fournisseurs de liquidités et les traders.
 
-Les _fournisseurs de liquidités_ fournissent la réserve (« pool ») avec les deux jetons qui peuvent être échangés (nous les appellerons **Jeton0** et **Jeton1**). En retour, ils reçoivent un troisième jeton, appelé un _jeton de liquidité_, qui représente la détention partielle du pool.
+Les _fournisseurs de liquidités_ fournissent le pool avec les deux jetons qui peuvent être échangés (nous les appellerons **Jeton0** et **Jeton1**). En retour, ils reçoivent un troisième jeton qui représente une propriété partielle du pool, appelé un _jeton de liquidité_.
 
-Les _traders_ envoient un type de jeton au pool et reçoivent l'autre (par exemple, envoie le **Jeton0** et reçoit le **Jeton1**) du pool, mis à disposition par les fournisseurs de liquidités. Le taux de change est déterminé par le nombre relatif de **Jeton0** et de **Jeton1** que le pool possède. En outre, le pool récupère un petit pourcentage en guise de récompense pour le pool de liquidités.
+Les _traders_ envoient un type de jeton au pool et reçoivent l'autre (par exemple, envoient le **Jeton0** et reçoivent le **Jeton1**) hors du pool fourni par les fournisseurs de liquidités. Le taux de change est déterminé par le nombre relatif de **Jeton0** et de **Jeton1** que le pool possède. En outre, le pool prélève un petit pourcentage en guise de récompense pour le pool de liquidités.
 
-Lorsque les fournisseurs de liquidités veulent récupérer leurs actifs, ils peuvent brûler les jetons du pool et récupérer leurs jetons, y compris leur part des récompenses.
+Lorsque les fournisseurs de liquidités veulent récupérer leurs actifs, ils peuvent brûler les jetons du pool et recevoir en retour leurs jetons, y compris leur part des récompenses.
 
 [Cliquez ici pour une description plus complète](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/swaps/).
 
 ### Pourquoi v2 ? Pourquoi pas v3 ? {#why-v2}
 
-[Uniswap v3](https://uniswap.org/whitepaper-v3.pdf) est une mise à jour beaucoup plus complexe que la v2. Il est plus facile de découvrir d'abord la v2, puis de passer à la v3.
+[Uniswap v3](https://app.uniswap.org/whitepaper-v3.pdf) est une mise à niveau bien plus compliquée que la v2. Il est plus facile d'apprendre d'abord la v2, puis de passer à la v3.
 
-### Contrats de base vs Contrats périphériques {#contract-types}
+### Contrats de base et contrats périphériques {#contract-types}
 
-Uniswap v2 est divisé en deux composants, un noyau et une périphérie. Cette division permet aux contrats de base, qui détiennent les actifs et _doivent_ donc être sécurisés, d'être plus simples et plus faciles à vérifier. Toutes les fonctionnalités supplémentaires requises par les traders peuvent alors être fournies par des contrats périphériques.
+Uniswap v2 est divisé en deux composants, un noyau et une périphérie. Cette division permet aux contrats de base, qui détiennent les actifs et doivent donc être _sécurisés_, d'être plus simples et plus faciles à auditer. Toutes les fonctionnalités supplémentaires requises par les traders peuvent alors être fournies par des contrats périphériques.
 
 ## Flux de données et de contrôle {#flows}
 
-Ce sont les flux de données et de contrôle qui se produisent lorsque vous effectuez les trois actions principales d'Uniswap :
+Voici le flux de données et de contrôle qui se produit lorsque vous effectuez les trois actions principales d'Uniswap :
 
-1. Échanger différents jetons
-2. Ajouter des liquidités sur le marché et obtenir des récompenses sous forme de jetons de liquidité ERC
-3. Brûler des jetons de liquidité ERC-20 et récupérer des jetons ERC-20 que l'échange en paire permet aux traders d'échanger
+1. Échanger entre différents jetons
+2. Ajouter de la liquidité au marché et être récompensé par des jetons de liquidité ERC-20 d'échange de paires
+3. Brûler des jetons de liquidité ERC-20 et récupérer les jetons ERC-20 que l'échange de paires permet aux traders d'échanger
 
-### Échanger {#swap-flow}
+### Échange {#swap-flow}
 
-C'est le flux le plus fréquemment utilisé par les traders :
+C'est le flux le plus courant, utilisé par les traders :
 
 #### Appelant {#caller}
 
-1. Fournir au compte périphérique une provision correspondant au montant à échanger.
-2. Appeler l'une des nombreuses fonctions d'échange du contrat périphérique (celui dont on dépend si ETH est impliqué ou non, si le trader spécifie le nombre de jetons à déposer ou le nombre de jetons à récupérer, etc). Chaque fonction d'échange accepte un chemin `path`, un tableau d'échanges à parcourir.
+1. Fournir au compte périphérique une provision pour le montant à échanger.
+2. Appeler l'une des nombreuses fonctions d'échange du contrat périphérique (la fonction utilisée dépend de si l'ETH est impliqué ou non, si le trader spécifie le montant de jetons à déposer ou le montant de jetons à récupérer, etc.).
+   Chaque fonction d'échange accepte un `path` (chemin), un tableau d'échanges à parcourir.
 
 #### Dans le contrat périphérique (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02-sol}
 
-3. Identifier les montants qui doivent être négociés à chaque échange tout au long du chemin.
-4. Itèrer sur le chemin. Pour chaque échange réalisé en cours de route, il envoie le jeton d'entrée puis appelle la fonction `swap` pour l'échange. Dans la plupart des cas, l'adresse de destination des jetons est la prochaine paire d'échange sur le chemin. Dans l'échange final, c'est l'adresse fournie par le trader.
+3. Identifier les montants qui doivent être échangés sur chaque échange le long du chemin.
+4. Itère sur le chemin. Pour chaque échange le long du chemin, il envoie le jeton d'entrée, puis appelle la fonction `swap` de l'échange.
+   Dans la plupart des cas, l'adresse de destination des jetons est le prochain échange de paires sur le chemin. Pour l'échange final, il s'agit de l'adresse fournie par le trader.
 
-#### Dans le contrat de base (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}
+#### Dans le contrat de base (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. Vérifier que le contrat de base ne fait pas l'objet d'une tricherie et peut maintenir une liquidité suffisante après l'échange.
 
-5. Vérifier que le contrat de base n'est pas faussé et qu'il dispose de suffisamment de liquidités après l'échange.
-6. Constater combien de jetons supplémentaires nous avons en plus des réserves connues. Ce montant est le nombre de jetons d'entrée que nous avons reçus et à échanger.
+6. Voir combien de jetons supplémentaires ont été reçus en plus des réserves connues. Ce montant correspond au nombre de jetons d'entrée reçus pour l'échange.
 7. Envoyer les jetons de sortie à la destination.
-8. Appeler `_update` pour mettre à jour les montants de la réserve
+8. Appeler `_update` pour mettre à jour les montants de la réserve.
 
-#### Retour au contrat périphérique (UniswapV2Router02.sol) {#back-in-the-periphery-contract-uniswapv2router02-sol}
+#### Retour dans le contrat périphérique (UniswapV2Router02.sol) {#back-in-the-periphery-contract-uniswapv2router02-sol}
 
-9. Effectuer tout nettoyage nécessaire (par exemple, brûler des jetons WETH pour récupérer des ETH à envoyer au trader)
+9. Effectuer tout nettoyage nécessaire (par exemple, brûler des jetons WETH pour récupérer des ETH à envoyer au trader).
 
-### Ajouter des liquidités {#add-liquidity-flow}
+### Ajout de liquidité {#add-liquidity-flow}
 
 #### Appelant {#caller-2}
 
-1. Fournir au compte périphérique une provision à ajouter à la réserve de liquidités.
+1. Fournir au compte périphérique une provision pour les montants à ajouter au pool de liquidités.
 2. Appeler l'une des fonctions `addLiquidity` du contrat périphérique.
 
 #### Dans le contrat périphérique (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-2}
 
-3. Créer un nouvel échange de paires si nécessaire
-4. S'il existe un échange de paires existant, calculer le nombre de jetons à ajouter. La valeur est sensée être identique pour les deux jetons, soit le même ratio entre les nouveaux jetons et les jetons existants.
-5. Vérifier si les montants sont acceptables (les appelants peuvent spécifier un montant minimum en-dessous duquel ils préfèrent ne pas ajouter de liquidité)
+3. Créer un nouvel échange de paires si nécessaire.
+4. S'il existe un échange de paires, calculer le montant des jetons à ajouter. La valeur est censée être identique pour les deux jetons, donc le ratio des nouveaux jetons par rapport aux jetons existants doit être le même.
+5. Vérifier si les montants sont acceptables (les appelants peuvent spécifier un montant minimum en dessous duquel ils préfèrent ne pas ajouter de liquidité).
 6. Appeler le contrat de base.
 
 #### Dans le contrat de base (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}
 
-7. Frapper des jetons de liquidité et les envoyer à l'appelant
-8. Appeler `_update` pour mettre à jour les montants de la réserve
+7. Frapper des jetons de liquidité et les envoyer à l'appelant.
+8. Appeler `_update` pour mettre à jour les montants de la réserve.
 
-### Retirer la liquidité {#remove-liquidity-flow}
+### Retrait de liquidité {#remove-liquidity-flow}
 
 #### Appelant {#caller-3}
 
@@ -94,21 +94,21 @@ C'est le flux le plus fréquemment utilisé par les traders :
 
 #### Dans le contrat périphérique (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-3}
 
-3. Envoyer les jetons de liquidité à l'échange de paire
+3. Envoyer les jetons de liquidité à l'échange de paires.
 
 #### Dans le contrat de base (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-3}
 
-4. Envoie l'adresse de destination des jetons sous-jacents en proportion des jetons brûlés. Par exemple s'il y a 1 000 jetons A dans le pool, 500 jetons B, 90 jetons de liquidité, et que nous recevons 9 jetons à brûler, nous brûlons 10 % des jetons de liquidité et nous renvoyons donc à l'utilisateur 100 jetons A et 50 jetons B.
-5. Brûler les jetons de liquidité
-6. Appeler `_update` pour mettre à jour les montants de la réserve
+4. Envoyer à l'adresse de destination les jetons sous-jacents en proportion des jetons brûlés. Par exemple, s'il y a 1 000 jetons A dans le pool, 500 jetons B et 90 jetons de liquidité, et que nous recevons 9 jetons à brûler, nous brûlons 10 % des jetons de liquidité, nous renvoyons donc à l'utilisateur 100 jetons A et 50 jetons B.
+5. Brûler les jetons de liquidité.
+6. Appeler `_update` pour mettre à jour les montants de la réserve.
 
 ## Les contrats de base {#core-contracts}
 
-Ce sont les contrats sécurisés qui détiennent les liquidités.
+Ce sont les contrats sécurisés qui détiennent la liquidité.
 
 ### UniswapV2Pair.sol {#UniswapV2Pair}
 
-[Ce contrat](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol) implémente le pool d'échange effectif des jetons. C'est une fonctionnalité de base d'Uniswap.
+[Ce contrat](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol) met en œuvre le pool réel qui échange les jetons. C'est la fonctionnalité principale d'Uniswap.
 
 ```solidity
 pragma solidity =0.5.16;
@@ -128,21 +128,22 @@ Ce sont toutes les interfaces que le contrat doit connaître, soit parce que le
 contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
 ```
 
-Ce contrat hérite de `UniswapV2ERC20`, qui fournit les fonctions ERC-20 pour les jetons de liquidité.
+Ce contrat hérite d'UniswapV2ERC20, qui fournit les fonctions ERC-20 pour les jetons de liquidité.
 
 ```solidity
     using SafeMath  for uint;
 ```
 
-La bibliothèque [SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math) est utilisée pour éviter les dépassements et soupassements. C'est important car sinon nous pourrions nous retrouver dans une situation où une valeur devrait être `-1`, mais est en réalité `2^256-1`.
+La [bibliothèque SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math) est utilisée pour éviter les dépassements de capacité (overflow) et les sous-dépassements (underflow). Ceci est important car sinon, nous pourrions nous retrouver dans une situation où une valeur devrait être `-1`, mais est en fait `2^256-1`.
 
 ```solidity
     using UQ112x112 for uint224;
 ```
 
-De nombreux calculs dans le contrat de pool nécessitent des fractions. Cependant, les fractions ne sont pas prises en charge par l'EVM. La solution trouvée par Uniswap est d'utiliser des valeurs de 224 bits, avec 112 bits pour la partie entière, et 112 bits pour la fraction. Ainsi, `1.0` est représenté par `2^112`, `1.5` est représenté par `2^112 + 2^111`, etc.
+De nombreux calculs dans le contrat de pool nécessitent des fractions. Cependant, les fractions ne sont pas prises en charge par l'EVM.
+La solution trouvée par Uniswap est d'utiliser des valeurs de 224 bits, avec 112 bits pour la partie entière et 112 bits pour la fraction. Ainsi, `1,0` est représenté par `2^112`, `1,5` est représenté par `2^112 + 2^111`, etc.
 
-D'autres informations sur cette bibliothèque sont disponibles [plus bas dans ce document](#FixedPoint).
+Plus de détails sur cette bibliothèque sont disponibles [plus loin dans le document](#FixedPoint).
 
 #### Variables {#pair-vars}
 
@@ -150,103 +151,104 @@ D'autres informations sur cette bibliothèque sont disponibles [plus bas dans ce
     uint public constant MINIMUM_LIQUIDITY = 10**3;
 ```
 
-Pour éviter les cas de division par zéro, il existe toujours un nombre minimum de jetons de liquidité (mais détenus par le compte zéro). Ce nombre est **LIQUIDITÉ_MINIMUM**, un millier.
+Pour éviter les cas de division par zéro, il existe toujours un nombre minimum de jetons de liquidité (mais ils sont détenus par le compte zéro). Ce nombre est **MINIMUM_LIQUIDITY**, soit un millier.
 
 ```solidity
     bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
 ```
 
-C'est le sélecteur ABI pour la fonction de transfert ERC-20. Il est utilisé pour transférer les jetons ERC-20 dans les deux comptes de jetons.
+C'est le sélecteur ABI pour la fonction de transfert ERC-20. Il est utilisé pour transférer des jetons ERC-20 sur les deux comptes de jetons.
 
 ```solidity
     address public factory;
 ```
 
-C'est le contrat d'usine qui a créé ce pool. Chaque pool est un échange entre deux jetons ERC-20, l'usine étant le point central qui relie tous ces pools.
+C'est le contrat d'usine qui a créé ce pool. Chaque pool est un échange entre deux jetons ERC-20, l'usine est le point central qui relie tous ces pools.
 
 ```solidity
     address public token0;
     address public token1;
 ```
 
-Il y a les adresses des contrats pour les deux types de jetons ERC-20 qui peuvent être échangés par ce pool.
+Ce sont les adresses des contrats pour les deux types de jetons ERC-20 qui peuvent être échangés par ce pool.
 
 ```solidity
     uint112 private reserve0;           // uses single storage slot, accessible via getReserves
     uint112 private reserve1;           // uses single storage slot, accessible via getReserves
 ```
 
-La réserve dont dispose le pool pour chaque type de jeton. Nous supposons que les deux ensembles représentent le même montant de valeur, et ainsi que chaque jeton0 vaut le jeton1 reserve1/reserve0.
+La réserve du pool pour chaque type de jeton. Nous supposons que les deux représentent le même montant de valeur, et donc que chaque jeton0 vaut la valeur de jeton1 multipliée par reserve1/reserve0.
 
 ```solidity
     uint32  private blockTimestampLast; // uses single storage slot, accessible via getReserves
 ```
 
-L'horodatage du dernier bloc dans lequel un échange a eu lieu, utilisé pour suivre les taux de change auu fil du temps.
+L'horodatage du dernier bloc dans lequel un échange a eu lieu, utilisé pour suivre les taux de change dans le temps.
 
-L'une des dépenses de gaz les plus importantes des contrats Ethereum est relative au stockage, qui persiste d'un appel de contrat à l'autre. Chaque cellule de stockage fait 256 bits de long. Ainsi, trois variables, `reserve0`, `reserve1` et `blockTimestampLast`, sont allouées de manière à ce qu'une seule valeur de stockage puisse inclure les trois (112+112+32=256).
+L'une des plus grandes dépenses de gaz des contrats Ethereum est le stockage, qui persiste d'un appel de contrat à l'autre. Chaque cellule de stockage fait 256 bits de long. Ainsi, trois variables, `reserve0`, `reserve1` et `blockTimestampLast`, sont allouées de manière à ce qu'une seule valeur de stockage puisse inclure les trois (112+112+32=256).
 
 ```solidity
     uint public price0CumulativeLast;
     uint public price1CumulativeLast;
 ```
 
-Ces variables contiennent les coûts cumulatifs pour chaque jeton (chacune en fonction de l'autre). Ils peuvent être utilisés pour calculer le taux de change moyen sur une période de temps.
+Ces variables contiennent les coûts cumulatifs pour chaque jeton (chacun en fonction de l'autre). Elles peuvent être utilisées pour calculer le taux de change moyen sur une période de temps.
 
 ```solidity
     uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
 ```
 
-Dans le cadre de l'échange de paires, le taux de change entre le jeton0 et jeton 1 est déterminé en gardant le multiple des deux réserves constant lors des échanges. `kLast` est cette valeur. Elle change lors du dépot de liquidités par un fournisseur ou des retraits de jetons et augmente légèrement à cause des frais de marché de 0,3 %.
+Pour décider du taux de change entre jeton0 et jeton1, l'échange de paires maintient le multiple des deux réserves constant pendant les transactions. `kLast` est cette valeur. Elle change lorsqu'un fournisseur de liquidités dépose ou retire des jetons, et elle augmente légèrement en raison des frais de marché de 0,3 %.
 
-Voici un exemple simple. Notez que pour des raisons de simplicité, le tableau n'affiche que trois chiffres après la virgule et que nous ignorons le taux de change de 0,3 % et qu'ainsi, les chiffres présentés sont inexacts.
+Voici un exemple simple. Notez que par souci de simplicité, le tableau ne comporte que trois chiffres après la virgule, et que nous ignorons les frais de transaction de 0,3 %, de sorte que les chiffres ne sont pas exacts.
 
-| Evénement                                             |  reserve0 |  reserve1 | reserve0 \* reserve1 | Taux de change moyen (jeton1 / jeton0) |
-| ----------------------------------------------------- | ---------:| ---------:| ----------------------:| -------------------------------------- |
-| Configuration initiale                                | 1.000,000 | 1.000,000 |              1.000.000 |                                        |
-| Le trader A échange 50 jetons0 contre 47,619 jetons1  | 1.050,000 |   952,381 |              1.000.000 | 0,952                                  |
-| Le trader B échange 10 jetons0 contre 8,984 jetons1   | 1.060,000 |   943,396 |              1.000.000 | 0,898                                  |
-| Le trader C échange 40 jetons0 pcontre 34,305 jetons1 | 1.100,000 |   909,090 |              1.000.000 | 0,858                                  |
-| Le trader D échange 100 jetons1 contre 109,01 jetons0 |   990,990 | 1.009,090 |              1.000.000 | 0,917                                  |
-| Le trader E échange 10 jetons0 contre 10,079 jetons1  | 1.000.990 |   999.010 |              1.000,000 | 1,008                                  |
+| Événement                                             |  réserve0 |  réserve1 | réserve0 \* réserve1 | Taux de change moyen (jeton1 / jeton0) |
+| ----------------------------------------------------- | --------: | --------: | -------------------: | --------------------------------------------------------- |
+| Configuration initiale                                | 1 000,000 | 1 000,000 |            1 000 000 |                                                           |
+| Le trader A échange 50 jetons0 contre 47,619 jetons1  | 1 050,000 |   952,381 |            1 000 000 | 0,952                                                     |
+| Le trader B échange 10 jetons0 contre 8,984 jetons1   | 1 060,000 |   943,396 |            1 000 000 | 0,898                                                     |
+| Le trader C échange 40 jetons0 contre 34,305 jetons1  | 1 100,000 |   909,090 |            1 000 000 | 0,858                                                     |
+| Le trader D échange 100 jetons1 contre 109,01 jetons0 |   990,990 | 1 009,090 |            1 000 000 | 0,917                                                     |
+| Le trader E échange 10 jetons0 contre 10,079 jetons1  | 1 000,990 |   999,010 |            1 000 000 | 1,008                                                     |
 
-Comme les traders fournissent plus de jetons0, la valeur relative du jeton1 augmente et vice versa, en fonction de l'offre et de la demande.
+Plus les traders fournissent de jetons0, plus la valeur relative du jeton1 augmente, et vice versa, en fonction de l'offre et de la demande.
 
-#### Verrouiller {#pair-lock}
+#### Verrouillage {#pair-lock}
 
 ```solidity
     uint private unlocked = 1;
 ```
 
-Il existe une classe de vulnérabilités de sécurité liées à la [faille de réentrance](https://medium.com/coinmonks/ethernaut-lvl-10-re-entrancy-walkthrough-how-to-abuse-execution-ordering-and-reproduce-the-dao-7ec88b912c14). Uniswap doit transférer arbitrairement des jetons ERC-20, ce qui signifie appler des contrats ERC-20 qui pourraient tenter d'utiliser à mauvais escient le marché Uniswap. En disposant d'une variable `unlocked` comme partie du contrat, nous pouvons empêcher les fonctions d'être appelées pendant qu'elles sont en cours d'exécution (au cours de la même transaction).
+Il existe une catégorie de vulnérabilités de sécurité basées sur [l'abus de réentrance](https://medium.com/coinmonks/ethernaut-lvl-10-re-entrancy-walkthrough-how-to-abuse-execution-ordering-and-reproduce-the-dao-7ec88b912c14). Uniswap doit transférer des jetons ERC-20 arbitraires, ce qui signifie appeler des contrats ERC-20 qui pourraient tenter d'abuser du marché Uniswap qui les appelle.
+En intégrant une variable `unlocked` au contrat, nous pouvons empêcher l'appel de fonctions pendant qu'elles sont en cours d'exécution (dans la même transaction).
 
 ```solidity
     modifier lock() {
 ```
 
-Cette fonction est un [modificateur](https://docs.soliditylang.org/en/v0.8.3/contracts.html#function-modifiers), une fonction qui entoure une fonction normale pour changer son comportement d'une manière ou d'une autre.
+Cette fonction est un [modificateur](https://docs.soliditylang.org/en/v0.8.3/contracts.html#function-modifiers), une fonction qui enveloppe une fonction normale pour en modifier le comportement d'une manière ou d'une autre.
 
 ```solidity
         require(unlocked == 1, 'UniswapV2: LOCKED');
         unlocked = 0;
 ```
 
-Si `unlocked` est égal à un, définissez-la à zéro. Si elle est déjà à zéro, faites échouer l'appel.
+Si `unlocked` est égal à un, le définir à zéro. S'il est déjà à zéro, annuler l'appel, le faire échouer.
 
 ```solidity
         _;
 ```
 
-Dans un modificateur `_ ;` est l'appel à la fonction originale (avec tous les paramètres). Ici, cela signifie que l'appel de fonction ne se produit que si `unlocked` était un paramètre appelé, et que, lors de son exécution, la valeur de `unlocked` est zéro.
+Dans un modificateur, `_;` est l'appel de fonction d'origine (avec tous les paramètres). Ici, cela signifie que l'appel de fonction ne se produit que si `unlocked` valait un lorsqu'il a été appelé, et que pendant son exécution, la valeur de `unlocked` est nulle.
 
 ```solidity
         unlocked = 1;
     }
 ```
 
-Après le retour de la fonction principale, déverrouillez.
+Une fois que la fonction principale est retournée, libérer le verrou.
 
-#### Misc. fonctions {#pair-misc}
+#### Divers fonctions {#pair-misc}
 
 ```solidity
     function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
@@ -256,37 +258,37 @@ Après le retour de la fonction principale, déverrouillez.
     }
 ```
 
-Cette fonction fournit aux appelants l'état courant de l'échange. Notez que les fonctions Solidity [peuvent faire remonter des valeurs multiples](https://docs.soliditylang.org/en/v0.8.3/contracts.html#returning-multiple-values).
+Cette fonction fournit aux appelants l'état actuel de l'échange. Notez que les fonctions Solidity [peuvent retourner plusieurs valeurs](https://docs.soliditylang.org/en/v0.8.3/contracts.html#returning-multiple-values).
 
 ```solidity
     function _safeTransfer(address token, address to, uint value) private {
         (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
 ```
 
-Cette fonction interne transfère un montant de jetons ERC20 de l'échange à une autre personne. `SELECTOR` spécifie que la fonction que nous appelons est `transfer(address,uint)` (voir définition ci-dessus).
+Cette fonction interne transfère un montant de jetons ERC20 de l'échange à une autre personne. `SELECTOR` spécifie que la fonction que nous appelons est `transfer(address,uint)` (voir la définition ci-dessus).
 
-Pour éviter d'avoir à importer une interface pour la fonction jeton, nous créons « manuellement » l'appel en utilisant l'une des [fonctions ABI](https://docs.soliditylang.org/en/v0.8.3/units-and-global-variables.html#abi-encoding-and-decoding-functions).
+Pour éviter d'avoir à importer une interface pour la fonction de jeton, nous créons « manuellement » l'appel en utilisant l'une des [fonctions ABI](https://docs.soliditylang.org/en/v0.8.3/units-and-global-variables.html#abi-encoding-and-decoding-functions).
 
 ```solidity
         require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
     }
 ```
 
-Un appel de transfert ERC-20 peut signaler un échec de deux façons :
+Un appel de transfert ERC-20 peut signaler un échec de deux manières :
 
-1. Rétablir. Lorsque l'appel à un contrat externe indique que la valeur de retour booléen est `false`
-2. Terminer normalement mais signaler un échec. Dans ce cas, le tampon de valeur de retour a une longueur non nulle et, lorsque décodé comme une valeur booléenne, est `false`
+1. Annuler. Si un appel à un contrat externe est annulé, alors la valeur de retour booléenne est `false`.
+2. Se terminer normalement mais signaler un échec. Dans ce cas, le tampon de valeur de retour a une longueur non nulle et, lorsqu'il est décodé en tant que valeur booléenne, il est `false`.
 
-Si l'une ou l'autre de ces conditions se produit, revenez en arrière.
+Si l'une de ces conditions se produit, annuler.
 
-#### Évènements {#pair-events}
+#### Événements {#pair-events}
 
 ```solidity
     event Mint(address indexed sender, uint amount0, uint amount1);
     event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
 ```
 
-Ces deux événements sont émis lorsqu'un fournisseur de liquidités dépose des liquidités (`Mint`) ou les retire (`Burn`). Dans les deux cas, les montants des jetons0 et jetons1 déposés ou retirés font partie de l'événement, comme également l'identité du compte qui les a appelés (`sender`). Dans le cas d'un retrait, l'événement inclut également la cible qui a reçu les jetons (`to`), qui peut ne pas être la même que l'expéditeur.
+Ces deux événements sont émis lorsqu'un fournisseur de liquidités dépose des liquidités (`Mint`) ou les retire (`Burn`). Dans les deux cas, les montants des jetons0 et jetons1 déposés ou retirés font partie de l'événement, tout comme l'identité du compte qui nous a appelés (`sender`). Dans le cas d'un retrait, l'événement inclut également la cible qui a reçu les jetons (`to`), qui peut ne pas être la même que l'expéditeur.
 
 ```solidity
     event Swap(
@@ -299,17 +301,18 @@ Ces deux événements sont émis lorsqu'un fournisseur de liquidités dépose de
     );
 ```
 
-Cet événement est émis lorsqu'un trader échange un jeton contre un autre. Encore une fois, l'expéditeur et le destinataire peuvent ne pas être les mêmes. Chaque jeton peut être soit envoyé à l’échange, soit reçu de celui-ci.
+Cet événement est émis lorsqu'un trader échange un jeton contre un autre. Encore une fois, l'expéditeur et le destinataire peuvent ne pas être les mêmes.
+Chaque jeton peut être soit envoyé à l’échange, soit reçu de celui-ci.
 
 ```solidity
     event Sync(uint112 reserve0, uint112 reserve1);
 ```
 
-Enfin, `Sync` est émis chaque fois que des jetons sont ajoutés ou retirés, quelle que soit la raison, pour fournir les dernières informations de réserve (et donc le taux de change).
+Enfin, `Sync` est émis chaque fois que des jetons sont ajoutés ou retirés, quelle qu'en soit la raison, pour fournir les dernières informations de réserve (et donc le taux de change).
 
 #### Fonctions de configuration {#pair-setup}
 
-Ces fonctions sont censées être appelées une fois, lors de la mise en place de la nouvelle paire d’échange.
+Ces fonctions sont censées être appelées une fois, lors de la mise en place du nouvel échange de paires.
 
 ```solidity
     constructor() public {
@@ -317,7 +320,7 @@ Ces fonctions sont censées être appelées une fois, lors de la mise en place d
     }
 ```
 
-Le constructeur s'assure que nous garderons une trace de l'adresse de l'usine qui a créé la paire. Ces informations sont requises pour `initialiser` et pour les frais d'usine (s'il y en a)
+Le constructeur s'assure que nous garderons une trace de l'adresse de l'usine qui a créé la paire. Ces informations sont requises pour `initialize` et pour les frais d'usine (s'il y en a).
 
 ```solidity
     // called once by the factory at time of deployment
@@ -328,7 +331,7 @@ Le constructeur s'assure que nous garderons une trace de l'adresse de l'usine qu
     }
 ```
 
-Cette fonction permet à l'usine (et seulement à l'usine) de spécifier les deux jetons ERC-20 que cette paire va échanger.
+Cette fonction permet à l'usine (et seulement à l'usine) de spécifier les deux jetons ERC-20 que cette paire échangera.
 
 #### Fonctions de mise à jour interne {#pair-update-internal}
 
@@ -345,7 +348,7 @@ Cette fonction est appelée chaque fois que des jetons sont déposés ou retiré
         require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
 ```
 
-Si solde0 ou solde1 (uint256) est supérieur à uint112(-1) (=2^112-1) (donc il déborde et se retrouve à 0 lorsqu'il est converti en uint112), refusez de continuer la \_update pour éviter les débordements. Avec un jeton normal qui peut être subdivisé en 10^18 unités, cela signifie que chaque échange est limité à environ 5,1\*10^15 de chaque jeton. Jusqu'à présent, cela n'a posé aucun problème.
+Si balance0 ou balance1 (uint256) est supérieur à uint112(-1) (=2^112-1) (donc il déborde et revient à 0 lorsqu'il est converti en uint112), refuser de continuer le \_update pour éviter les débordements. Avec un jeton normal qui peut être subdivisé en 10^18 unités, cela signifie que chaque échange est limité à environ 5,1\*10^15 de chaque jeton. Jusqu'à présent, cela n'a pas posé de problème.
 
 ```solidity
         uint32 blockTimestamp = uint32(block.timestamp % 2**32);
@@ -362,20 +365,20 @@ Si le temps écoulé n'est pas nul, cela signifie que nous sommes la première t
         }
 ```
 
-Chaque accumulateur de coûts est mis à jour en tenant compte du coût le plus récent (réserve de l'autre jeton/réserve de ce jeton) multiplié par le temps écoulé en secondes. Pour obtenir un prix moyen, vous prenez le prix cumulé de deux points dans le temps et le divisez par la différence de temps entre ces deux points. Par exemple, supposons cette séquence d'événements :
+Chaque accumulateur de coûts est mis à jour avec le coût le plus récent (réserve de l'autre jeton/réserve de ce jeton) multiplié par le temps écoulé en secondes. Pour obtenir un prix moyen, vous lisez le prix cumulé à deux moments donnés et vous divisez par la différence de temps entre eux. Par exemple, supposons la séquence d'événements suivante :
 
-| Evénement                                                 |  réserve0 |  réserve1 | horodatage | Taux de change marginal (réserve1 / réserve0) |           DernierprixCumulé0 |
-| --------------------------------------------------------- | ---------:| ---------:| ---------- | ---------------------------------------------:| ----------------------------:|
-| Configuration initiale                                    | 1.000,000 | 1.000,000 | 5.000      |                                         1,000 |                            0 |
-| Le Trader A dépose 50 jetons0 et récupère 47,619 jetons1  | 1.050,000 |   952,381 | 5.020      |                                         0,907 |                           20 |
-| Le Trader B dépose 10 jetons0 et récupère 8,984 jetons1   | 1.060,000 |   943,396 | 5.030      |                                         0,890 |       20+10\*0,907 = 29,07 |
-| Le Trader C dépose 40 jetons0 et récupère 34,305 jetons1  | 1.100,000 |   909,090 | 5.100      |                                         0,826 |    29,07+70\*0,890 = 91,37 |
-| Le Trader D dépose 100 jetons1 et récupère 109,01 jetons0 |   990,990 | 1.009,090 | 5.110      |                                         1,018 |    91,37+10\*0,826 = 99,63 |
-| Le Trader E dépose 10 jetons0 et récupère 10,079 jetons1  | 1.000,990 |   999,010 | 5.150      |                                         0,998 | 99,63+40\*1,1018 = 143,702 |
+| Événement                                                 |  réserve0 |  réserve1 | horodatage | Taux de change marginal (réserve1 / réserve0) |       price0CumulativeLast |
+| --------------------------------------------------------- | --------: | --------: | ---------- | ---------------------------------------------------------------: | -------------------------: |
+| Configuration initiale                                    | 1 000,000 | 1 000,000 | 5 000      |                                                            1,000 |                          0 |
+| Le trader A dépose 50 jetons0 et récupère 47,619 jetons1  | 1 050,000 |   952,381 | 5 020      |                                                            0,907 |                         20 |
+| Le trader B dépose 10 jetons0 et récupère 8,984 jetons1   | 1 060,000 |   943,396 | 5 030      |                                                            0,890 |       20+10\*0,907 = 29,07 |
+| Le trader C dépose 40 jetons0 et récupère 34,305 jetons1  | 1 100,000 |   909,090 | 5 100      |                                                            0,826 |    29,07+70\*0,890 = 91,37 |
+| Le trader D dépose 100 jetons1 et récupère 109,01 jetons0 |   990,990 | 1 009,090 | 5 110      |                                                            1,018 |    91,37+10\*0,826 = 99,63 |
+| Le trader E dépose 10 jetons0 et récupère 10,079 jetons1  | 1 000,990 |   999,010 | 5 150      |                                                            0,998 | 99,63+40\*1,1018 = 143,702 |
 
-Disons que nous souhaitons calculer le prix moyen du **Jeton** entre les horodatages 5.030 et 5.150. La différence de valeur du `price0Cumulative` est 143,702-29,07=114,632. Il s'agit de la moyenne sur deux minutes (120 secondes). Donc le prix moyen est 114,632/120 = 0,955.
+Disons que nous souhaitons calculer le prix moyen du **Jeton0** entre les horodatages 5 030 et 5 150. La différence de la valeur de `price0Cumulative` est 143,702-29,07=114,632. Il s'agit de la moyenne sur deux minutes (120 secondes). Le prix moyen est donc 114,632/120 = 0,955.
 
-Ce calcul de prix est la raison pour laquelle nous avons besoin de connaître les anciennes tailles de réserve.
+Ce calcul de prix est la raison pour laquelle nous devons connaître les anciennes tailles de réserve.
 
 ```solidity
         reserve0 = uint112(balance0);
@@ -385,7 +388,7 @@ Ce calcul de prix est la raison pour laquelle nous avons besoin de connaître le
     }
 ```
 
-Enfin, mettez à jour les variables globales et émettez un événement `Sync`.
+Enfin, mettre à jour les variables globales et émettre un événement `Sync`.
 
 ##### \_mintFee
 
@@ -394,29 +397,30 @@ Enfin, mettez à jour les variables globales et émettez un événement `Sync`.
     function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
 ```
 
-Dans Uniswap 2.0, les traders paient des frais de 0,30 % pour utiliser le marché. La plus grande partie de ces frais (0,25 % de la transaction) va toujours aux fournisseurs de liquidités. Les 0,05 % restants peuvent être distribués soit aux fournisseurs de liquidités, soit à une adresse spécifiée par l'usine en tant que frais de protocole, qui paie Uniswap pour leurs efforts de développement.
+Dans Uniswap 2.0, les traders paient des frais de 0,30 % pour utiliser le marché. La plus grande partie de ces frais (0,25 % de la transaction) va toujours aux fournisseurs de liquidités. Les 0,05 % restants peuvent être versés soit aux fournisseurs de liquidités, soit à une adresse spécifiée par l'usine en tant que frais de protocole, qui rémunère Uniswap pour ses efforts de développement.
 
-Pour réduire les calculs (et donc les frais de gaz), ces frais ne sont calculés que lorsque la liquidité est ajoutée ou retirée du pool plutôt que lors de chaque transaction.
+Pour réduire les calculs (et donc les frais de gaz), ces frais ne sont calculés que lorsque la liquidité est ajoutée ou retirée du pool, plutôt qu'à chaque transaction.
 
 ```solidity
         address feeTo = IUniswapV2Factory(factory).feeTo();
         feeOn = feeTo != address(0);
 ```
 
-Regardez les frais de destination de l'usine. S'ils sont de zéro, alors il n'y aura pas de frais de protocole et donc nul besoin de les calculer.
+Lire la destination des frais de l'usine. S'ils sont nuls, alors il n'y a pas de frais de protocole et il n'est pas nécessaire de les calculer.
 
 ```solidity
         uint _kLast = kLast; // gas savings
 ```
 
-La variable d'état `kLast` est située dans le stockage et aura donc une valeur entre différents appels au contrat. L'accès au stockage est beaucoup plus onéreux que l'accès à la mémoire volatile qui est libérée lorsque l'appel de fonction au contrat se termine. Ainsi, nous utilisons une variable interne pour faire des économies sur le gaz.
+La variable d'état `kLast` est située dans le stockage, elle aura donc une valeur entre les différents appels au contrat.
+L'accès au stockage est beaucoup plus cher que l'accès à la mémoire volatile qui est libérée lorsque l'appel de fonction au contrat se termine. Nous utilisons donc une variable interne pour économiser du gaz.
 
 ```solidity
         if (feeOn) {
             if (_kLast != 0) {
 ```
 
-Les fournisseurs de liquidités obtiennent leur part par simple appréciation de leurs jetons de liquidité. Mais les frais de protocole nécessitent de nouveaux jetons de liquidité à frapper et à fournir à l'adresse `feeTo`.
+Les fournisseurs de liquidités obtiennent leur part simplement par l'appréciation de leurs jetons de liquidité. Mais les frais de protocole nécessitent que de nouveaux jetons de liquidité soient frappés et fournis à l'adresse `feeTo`.
 
 ```solidity
                 uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
@@ -424,7 +428,7 @@ Les fournisseurs de liquidités obtiennent leur part par simple appréciation de
                 if (rootK > rootKLast) {
 ```
 
-S'il y a de nouvelles liquidités sur lesquelles percevoir des frais de protocole. Vous pourrez voir la fonction racine carrée [plus loin dans cet article](#Math)
+S'il y a de nouvelles liquidités sur lesquelles percevoir des frais de protocole. Vous pouvez voir la fonction de racine carrée [plus loin dans cet article](#Math).
 
 ```solidity
                     uint numerator = totalSupply.mul(rootK.sub(rootKLast));
@@ -432,7 +436,7 @@ S'il y a de nouvelles liquidités sur lesquelles percevoir des frais de protocol
                     uint liquidity = numerator / denominator;
 ```
 
-Ce calcul complexe des frais est expliqué dans [le livre blanc](https://uniswap.org/whitepaper.pdf) en page 5. Nous savons qu'entre le moment où le temps `kLast` a été calculé et le moment présent, aucune liquidité n'a été ajoutée ou supprimée (car nous n'exécutons ce calcul qu'à chaque fois que la liquidité est ajoutée ou supprimée, avant qu'il ne change réellement). Par conséquent, tout changement dans `reserve0 * reserve1` doit venir des frais de transaction (sans eux, nous conserverons la constante `reserve0 * reserve1`).
+Ce calcul compliqué des frais est expliqué dans [le livre blanc](https://app.uniswap.org/whitepaper.pdf) à la page 5. Nous savons qu'entre le moment où `kLast` a été calculé et le moment présent, aucune liquidité n'a été ajoutée ou supprimée (car nous exécutons ce calcul à chaque fois que la liquidité est ajoutée ou supprimée, avant qu'elle ne change réellement). Par conséquent, tout changement dans `reserve0 * reserve1` doit provenir des frais de transaction (sans eux, nous conserverions la constante `reserve0 * reserve1`).
 
 ```solidity
                     if (liquidity > 0) _mint(feeTo, liquidity);
@@ -440,7 +444,7 @@ Ce calcul complexe des frais est expliqué dans [le livre blanc](https://uniswap
             }
 ```
 
-Utilisez la fonction `UniswapV2ERC20._mint` pour créer les jetons de liquidité supplémentaires et les affecter à `feeTo`.
+Utiliser la fonction `UniswapV2ERC20._mint` pour créer les jetons de liquidité supplémentaires et les affecter à `feeTo`.
 
 ```solidity
         } else if (_kLast != 0) {
@@ -449,11 +453,12 @@ Utilisez la fonction `UniswapV2ERC20._mint` pour créer les jetons de liquidité
     }
 ```
 
-S'il n'existe pas de frais, réglez `kLast` à zéro (si ce n'est pas déjà le cas). Lorsque ce contrat a été rédigé, il existait une [fonctionnalité de remboursement de gaz](https://eips.ethereum.org/EIPS/eip-3298) qui encourageait les contrats à réduire la taille globale de l'état d'Ethereum en mettant à zéro le stockage dont ils n'avaient pas besoin. Ce code récupère ce remboursement lorsque c'est possible.
+S'il n'y a pas de frais, régler `kLast` à zéro (si ce n'est pas déjà le cas). Lorsque ce contrat a été rédigé, il existait une [fonctionnalité de remboursement de gaz](https://eips.ethereum.org/EIPS/eip-3298) qui encourageait les contrats à réduire la taille globale de l'état d'Ethereum en mettant à zéro le stockage dont ils n'avaient pas besoin.
+Ce code obtient ce remboursement lorsque c'est possible.
 
 #### Fonctions accessibles en externe {#pair-external}
 
-Notez que bien que toute transaction ou contrat _peut_ appeler ces fonctions. Elles sont conçues pour être appelées depuis le contrat périphérique. Si vous les appelez directement, vous ne pourrez pas tricher concernant la paire d'échange, mais vous pourriez perdre des valeurs par erreur.
+Notez que bien que toute transaction ou tout contrat _puisse_ appeler ces fonctions, elles sont conçues pour être appelées depuis le contrat périphérique. Si vous les appelez directement, vous ne pourrez pas tricher sur l'échange de paires, mais vous pourriez perdre de la valeur par erreur.
 
 ##### frapper
 
@@ -462,13 +467,13 @@ Notez que bien que toute transaction ou contrat _peut_ appeler ces fonctions. El
     function mint(address to) external lock returns (uint liquidity) {
 ```
 
-Cette fonction est appelée lorsqu'un fournisseur de liquidités ajoute de la liquidité à la réserve. Elle frappe des jetons de liquidités supplémentaires en récompense. Elle devrait être appelée à partir d'un [contrat périphérique](#UniswapV2Router02) qui l'appelle après avoir ajouté la liquidité dans la même transaction (ainsi personne d'autre ne serait en mesure de soumettre une transaction sollicitant la nouvelle liquidité avant le propriétaire légitime).
+Cette fonction est appelée lorsqu'un fournisseur de liquidités ajoute de la liquidité au pool. Elle frappe des jetons de liquidité supplémentaires en guise de récompense. Elle devrait être appelée à partir d'[un contrat périphérique](#UniswapV2Router02) qui l'appelle après avoir ajouté la liquidité dans la même transaction (afin que personne d'autre ne puisse soumettre une transaction réclamant la nouvelle liquidité avant le propriétaire légitime).
 
 ```solidity
         (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
 ```
 
-C'est ainsi que doivent être lus les résultats d'une fonction Solidity qui restitue plusieurs valeurs. Nous rejetons les dernières valeurs retournées, l'horodatage du bloc, car nous n'en avons pas besoin.
+C'est ainsi qu'il faut lire les résultats d'une fonction Solidity qui retourne plusieurs valeurs. Nous ignorons la dernière valeur retournée, l'horodatage du bloc, car nous n'en avons pas besoin.
 
 ```solidity
         uint balance0 = IERC20(token0).balanceOf(address(this));
@@ -477,13 +482,13 @@ C'est ainsi que doivent être lus les résultats d'une fonction Solidity qui res
         uint amount1 = balance1.sub(_reserve1);
 ```
 
-Récupèrez les soldes courants et vérifiez le montant ajouté à chaque type de jeton.
+Obtenir les soldes actuels et voir combien a été ajouté pour chaque type de jeton.
 
 ```solidity
         bool feeOn = _mintFee(_reserve0, _reserve1);
 ```
 
-Calculez les frais de protocole à percevoir, le cas échéant, et minez les jetons de liquidité en conséquence. Parce que les paramètres de `_mintFee` sont les anciennes valeurs de réserve, les frais sont calculés avec précision uniquement sur la base des modifications apportées au pool en raison des frais.
+Calculer les frais de protocole à percevoir, le cas échéant, et frapper les jetons de liquidité en conséquence. Étant donné que les paramètres de `_mintFee` sont les anciennes valeurs de réserve, les frais sont calculés avec précision en se basant uniquement sur les changements de pool dus aux frais.
 
 ```solidity
         uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
@@ -492,35 +497,36 @@ Calculez les frais de protocole à percevoir, le cas échéant, et minez les jet
            _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
 ```
 
-S'il s'agit du premier dépôt, créez des jetons `MINIMUM_LIQUIDITY` et envoyez-les à l'adresse zéro pour les verrouiller. Ils ne peuvent jamais être rachetés, ce qui signifie que la réserve ne sera jamais complètement vide (d'une certaine façon cela nous évite une division par zéro). La valeur `MINIMUM_LIQUIDITY` est d'un millier, ce qui implique que la plupart des ERC-20 sont subdivisés en unités de 10^-18'e d'un jeton, étant donné que la division de l'ETH en wei est de 10^-15 de la valeur d'un jeton unique. Ce n'est pas un coût élevé.
+S'il s'agit du premier dépôt, créer des jetons `MINIMUM_LIQUIDITY` et les envoyer à l'adresse zéro pour les verrouiller. Ils ne peuvent jamais être rachetés, ce qui signifie que le pool ne sera jamais complètement vidé (cela nous évite une division par zéro à certains endroits). La valeur de `MINIMUM_LIQUIDITY` est de mille, ce qui, si l'on considère que la plupart des ERC-20 sont subdivisés en unités de 10^-18 d'un jeton, comme l'ETH est divisé en wei, correspond à 10^-15 de la valeur d'un seul jeton. Le coût n'est pas élevé.
 
-Lors du premier dépôt, nous ne connaissons pas la valeur relative des deux jetons, donc nous multiplions simplement les montants et prenons une racine carrée, en supposant que le dépôt nous donne la même valeur pour les deux jetons.
+Au moment du premier dépôt, nous ne connaissons pas la valeur relative des deux jetons, nous multiplions donc simplement les montants et prenons une racine carrée, en supposant que le dépôt nous fournisse une valeur égale pour les deux jetons.
 
-Nous pouvons nous y fier parce qu'il est dans l'intérêt du déposant de fournir une valeur égale pour éviter de perdre de la valeur à l'arbitrage. Imaginons que la valeur des deux jetons est identique mais que notre déposant a déposé quatre fois plus de **Jetons1** que de **Jetons0**. Un trader peut s'appuyer sur le fait que l'échange de paire laisse supposer qu'il est plus utile de retirer de la valeur du **Jeton0**.
+Nous pouvons nous y fier car il est dans l'intérêt du déposant de fournir une valeur égale pour éviter de perdre de la valeur à cause de l'arbitrage.
+Imaginons que la valeur des deux jetons est identique, mais que notre déposant ait déposé quatre fois plus de **Jeton1** que de **Jeton0**. Un trader peut utiliser le fait que l'échange de paires pense que le **Jeton0** a plus de valeur pour en extraire de la valeur.
 
-| Evénement                                                              | réserve0 | réserve1 | réserve0 \* réserve1 | Valeur du pool (réserve0 + réserve1) |
-| ---------------------------------------------------------------------- | --------:| --------:| ----------------------:| ------------------------------------:|
-| Configuration initiale                                                 |        8 |       32 |                    256 |                                   40 |
-| Le Trader dépose dépose 8 jetons **Jeton0** et récupère 16 **Jetons1** |       16 |       16 |                    256 |                                   32 |
+| Événement                                                    | réserve0 | réserve1 | réserve0 \* réserve1 | Valeur du pool (reserve0 + reserve1) |
+| ------------------------------------------------------------ | -------: | -------: | -------------------: | ------------------------------------------------------: |
+| Configuration initiale                                       |        8 |       32 |                  256 |                                                      40 |
+| Le trader dépose 8 jetons **Jeton0**, récupère 16 **Jeton1** |       16 |       16 |                  256 |                                                      32 |
 
-Comme vous pouvez le constater, le trader a gagné 8 jetons supplémentaires qui viennent d'une réduction de la valeur du pool, affectant le déposant qui le possède.
+Comme vous pouvez le voir, le trader a gagné 8 jetons supplémentaires, qui proviennent d'une réduction de la valeur du pool, ce qui pénalise le déposant qui le possède.
 
 ```solidity
         } else {
             liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
 ```
 
-À chaque dépôt ultérieur, nous connaissons déjà le taux de change entre les deux actifs et nous attendons des fournisseurs de liquidités qu'ils fournissent une valeur égale dans les deux. S'ils ne le font pas, nous leur donnons en guise de punition des jetons de liquidité basés sur la valeur la plus basse.
+À chaque dépôt ultérieur, nous connaissons déjà le taux de change entre les deux actifs et nous attendons des fournisseurs de liquidités qu'ils fournissent une valeur égale pour les deux. S'ils ne le font pas, nous leur donnons des jetons de liquidité basés sur la valeur inférieure qu'ils ont fournie, en guise de pénalité.
 
-Qu'il s'agisse du dépôt initial ou d'un dépôt ultérieur, le nombre de jetons de liquidité que nous fournissons est égal à la racine carrée du changement dans `reserve0*reserve1` et la valeur du jeton de liquidité ne change pas (sauf si nous obtenons un dépôt qui n'a pas de valeurs égales pour les deux types, auquel cas l'« amende » est distribuée). Voici un autre exemple avec deux jetons qui ont la même valeur, avec trois bons dépôts et un mauvais (dépôt d'un seul type de jeton, donc il ne produit aucun jeton de liquidité).
+Qu'il s'agisse du dépôt initial ou d'un dépôt ultérieur, le nombre de jetons de liquidité que nous fournissons est égal à la racine carrée de la variation de `reserve0*reserve1` et la valeur du jeton de liquidité ne change pas (sauf si nous recevons un dépôt qui n'a pas de valeurs égales pour les deux types, auquel cas l'« amende » est distribuée). Voici un autre exemple avec deux jetons qui ont la même valeur, avec trois bons dépôts et un mauvais (dépôt d'un seul type de jeton, il ne produit donc aucun jeton de liquidité).
 
-| Événement                      | réserve0 | réserve1 | réserve0 \* réserve1 | Valeur du pool (réserve0 + réserve1) | Jetons de liquidité frappés pour ce dépôt | Jetons de liquidité totaux | Valeur de chaque jeton de liquidité |
-| ------------------------------ | --------:| --------:| ----------------------:| ------------------------------------:| -----------------------------------------:| --------------------------:| -----------------------------------:|
-| Configuration initiale         |    8,000 |    8,000 |                     64 |                               16,000 |                                         8 |                          8 |                               2,000 |
-| Dépôt de quatre de chaque type |   12,000 |   12,000 |                    144 |                               24,000 |                                         4 |                         12 |                               2,000 |
-| Dépôt de deux de chaque type   |   14,000 |   14,000 |                    196 |                               28,000 |                                         2 |                         14 |                               2,000 |
-| Dépôt de valeurs inégales      |   18,000 |   14,000 |                    252 |                               32,000 |                                         0 |                         14 |                              ~2,286 |
-| Après arbitrage                |  ~15,874 |  ~15,874 |                    252 |                              ~31,748 |                                         0 |                         14 |                              ~2,267 |
+| Événement                      |                réserve0 |                réserve1 | réserve0 \* réserve1 | Valeur du pool (réserve0 + réserve1) | Jetons de liquidité frappés pour ce dépôt | Total des jetons de liquidité | valeur de chaque jeton de liquidité |
+| ------------------------------ | ----------------------: | ----------------------: | -------------------: | ------------------------------------------------------: | ----------------------------------------: | ----------------------------: | ----------------------------------: |
+| Configuration initiale         |                   8,000 |                   8,000 |                   64 |                                                  16,000 |                                         8 |                             8 |                               2,000 |
+| Dépôt de quatre de chaque type |                  12,000 |                  12,000 |                  144 |                                                  24,000 |                                         4 |                            12 |                               2,000 |
+| Dépôt de deux de chaque type   |                  14,000 |                  14,000 |                  196 |                                                  28,000 |                                         2 |                            14 |                               2,000 |
+| Dépôt de valeur inégale        |                  18,000 |                  14,000 |                  252 |                                                  32,000 |                                         0 |                            14 |              ~2,286 |
+| Après arbitrage                | ~15,874 | ~15,874 |                  252 |                                 ~31,748 |                                         0 |                            14 |              ~2,267 |
 
 ```solidity
         }
@@ -528,7 +534,7 @@ Qu'il s'agisse du dépôt initial ou d'un dépôt ultérieur, le nombre de jeton
         _mint(to, liquidity);
 ```
 
-Utilisez la fonction `UniswapV2ERC20._mint` pour créer les jetons de liquidité supplémentaires et les attribuer au bon compte.
+Utiliser la fonction `UniswapV2ERC20._mint` pour créer les jetons de liquidité supplémentaires et les donner au bon compte.
 
 ```solidity
 
@@ -547,7 +553,8 @@ Mettre à jour les variables d'état (`reserve0`, `reserve1` et si nécessaire `
     function burn(address to) external lock returns (uint amount0, uint amount1) {
 ```
 
-Cette fonction est appelée lorsque la liquidité est retirée et que les jetons de liquidité appropriés doivent être brûlés. Elle devrait également être appelée [depuis un compte périphérique](#UniswapV2Router02).
+Cette fonction est appelée lorsque la liquidité est retirée et que les jetons de liquidité appropriés doivent être brûlés.
+Elle devrait également être appelée [depuis un compte périphérique](#UniswapV2Router02).
 
 ```solidity
         (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
@@ -568,7 +575,7 @@ Le contrat périphérique a transféré la liquidité à brûler vers ce contrat
         require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
 ```
 
-Le fournisseur de liquidités reçoit la même valeur des deux jetons. De cette façon, nous ne changeons pas le taux de change.
+Le fournisseur de liquidités reçoit la même valeur pour les deux jetons. De cette façon, nous ne modifions pas le taux de change.
 
 ```solidity
         _burn(address(this), liquidity);
@@ -586,7 +593,7 @@ Le fournisseur de liquidités reçoit la même valeur des deux jetons. De cette
 
 Le reste de la fonction `burn` est l'image miroir de la fonction `mint` ci-dessus.
 
-##### échanger
+##### échange
 
 ```solidity
     // this low-level function should be called from a contract which performs important safety checks
@@ -605,7 +612,8 @@ Cette fonction est également censée être appelée depuis [un contrat périph
         { // scope for _token{0,1}, avoids stack too deep errors
 ```
 
-Les variables locales peuvent être stockées en mémoire ou, si elles ne sont pas trop nombreuses, directement sur la pile. Si nous pouvons limiter le nombre, nous utiliserons la pile pour utiliser moins de gaz. Pour plus de détails, consultez [the yellow paper, the formal Ethereum specifications](https://ethereum.github.io/yellowpaper/paper.pdf), p. 26, equation 298.
+Les variables locales peuvent être stockées soit en mémoire, soit, si elles ne sont pas trop nombreuses, directement sur la pile.
+Si nous pouvons limiter le nombre, nous utiliserons la pile pour consommer moins de gaz. Pour plus de détails, voir [le Yellow Paper, les spécifications formelles d'Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf), p. 26, équation 298.
 
 ```solidity
             address _token0 = token0;
@@ -615,13 +623,13 @@ Les variables locales peuvent être stockées en mémoire ou, si elles ne sont p
             if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
 ```
 
-Ce transfert est optimiste puisque nous transférons avant d'être sûrs que toutes les conditions sont remplies. Ceci est acceptable dans Ethereum parce que si les conditions ne sont pas remplies plus tard lors de l'appel, l'opération ainsi que les changements réalisés seront annulés.
+Ce transfert est optimiste, car nous transférons avant d'être sûrs que toutes les conditions sont remplies. Ceci est acceptable dans Ethereum car si les conditions ne sont pas remplies plus tard lors de l'appel, nous annulons l'opération ainsi que les changements qu'elle a créés.
 
 ```solidity
             if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
 ```
 
-Informez si celà est demandé, le bénéficiaire du swap.
+Informer le destinataire de l'échange si demandé.
 
 ```solidity
             balance0 = IERC20(_token0).balanceOf(address(this));
@@ -629,7 +637,7 @@ Informez si celà est demandé, le bénéficiaire du swap.
         }
 ```
 
-Récupèrez les soldes actuels. Le contrat périphérique nous envoie les jetons avant de nous appeler pour l'échange. Il est ainsi aisé de s'assurer que le contrat n'a pas été falsifié, cette vérification _devant_ intervenir dans le contrat de base (parce que nous pouvons être appelés par d'autres entités que notre contrat périphérique).
+Obtenir les soldes actuels. Le contrat périphérique nous envoie les jetons avant de nous appeler pour l'échange. Il est ainsi facile pour le contrat de vérifier qu'il n'est pas trompé, une vérification qui _doit_ avoir lieu dans le contrat de base (car nous pouvons être appelés par d'autres entités que notre contrat périphérique).
 
 ```solidity
         uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
@@ -641,7 +649,7 @@ Récupèrez les soldes actuels. Le contrat périphérique nous envoie les jetons
             require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
 ```
 
-Ceci est un test d'intégrité visant à s'assurer que nous ne perdons rien lors de l'échange. En aucune circonstance, un échange ne devrait réduire la `reserve0*reserve1`. C'est également dans ce cntexte que nous nous assurons qu'une redevance de 0,3 % est envoyée sur l'échange. Avant de vérifier la valeur de K, nous multiplions les deux soldes par 1 000 soustraits des montants multipliés par 3, ce qui signifie que 0,3 % (3/1000 = 0,003 = 0,3 %) est déduit du solde avant de comparer sa valeur K à la valeur actuelle des réserves K.
+Ceci est un contrôle de cohérence pour s'assurer que nous ne perdons rien lors de l'échange. En aucune circonstance un échange ne devrait réduire `reserve0*reserve1`. C'est également là que nous nous assurons qu'une redevance de 0,3 % est envoyée sur l'échange ; avant de vérifier la valeur de K, nous multiplions les deux soldes par 1 000 et soustrayons les montants multipliés par 3, ce qui signifie que 0,3 % (3/1000 = 0,003 = 0,3 %) est déduit du solde avant de comparer sa valeur K à la valeur K des réserves actuelles.
 
 ```solidity
         }
@@ -651,16 +659,17 @@ Ceci est un test d'intégrité visant à s'assurer que nous ne perdons rien lors
     }
 ```
 
-Mettre à jour `réserve0` et `réserve1`, et si nécessaire les accumulateurs de prix, l'horodatage et émettre un événement.
+Mettre à jour `reserve0` et `reserve1`, et si nécessaire les accumulateurs de prix et l'horodatage, et émettre un événement.
 
-##### Synchroniser ou ignorer
+##### Sync ou Skim
 
-Il est possible que les soldes réels se désynchronisent des réserves que l'échange de la paire aura généré. Il n'y a aucun moyen de retirer des jetons sans l'accord du contrat, mais pour les dépôts c'est une autre affaire. Un compte peut transférer des jetons à l'échange sans avoir appelé `mint` ou `swap`.
+Il est possible que les soldes réels se désynchronisent des réserves que l'échange de paires pense avoir.
+Il n'y a aucun moyen de retirer des jetons sans le consentement du contrat, mais pour les dépôts c'est une autre affaire. Un compte peut transférer des jetons à l'échange sans appeler ni `mint` ni `swap`.
 
 Dans ce cas, il y a deux solutions :
 
-- `sync`, mettre à jour les réserves en tenant compte des soldes actuels
-- `skim`, retirer le montant supplémentaire. Notez que tout compte est autorisé à appeler `skim` parce que nous ne savons pas qui a déposé les jetons. Cette information est émise dans un événement, mais les événements ne sont pas accessibles depuis la blockchain.
+- `sync`, mettre à jour les réserves avec les soldes actuels
+- `skim`, retirer le montant supplémentaire. Notez que tout compte est autorisé à appeler `skim` car nous ne savons pas qui a déposé les jetons. Cette information est émise dans un événement, mais les événements ne sont pas accessibles depuis la blockchain.
 
 ```solidity
     // force balances to match reserves
@@ -682,7 +691,7 @@ Dans ce cas, il y a deux solutions :
 
 ### UniswapV2Factory.sol {#UniswapV2Factory}
 
-[Ce contrat](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Factory.sol) crée l es échanges de paires.
+[Ce contrat](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Factory.sol) crée les échanges de paires.
 
 ```solidity
 pragma solidity =0.5.16;
@@ -695,7 +704,8 @@ contract UniswapV2Factory is IUniswapV2Factory {
     address public feeToSetter;
 ```
 
-Ces variables d'état sont nécessaires pour implémenter les frais de protocole (voir [le livre blanc](https://uniswap.org/whitepaper.pdf), p. 5). L'adresse `feeTo` accumule les jetons de liquidité pour les frais de protocole, et `feeToSetter` est l'adresse autorisée à changer `feeTo` en une adresse différente.
+Ces variables d'état sont nécessaires pour implémenter les frais de protocole (voir [le livre blanc](https://app.uniswap.org/whitepaper.pdf), p. 5).
+L'adresse `feeTo` accumule les jetons de liquidité pour les frais de protocole, et `feeToSetter` est l'adresse autorisée à changer `feeTo` en une adresse différente.
 
 ```solidity
     mapping(address => mapping(address => address)) public getPair;
@@ -704,17 +714,17 @@ Ces variables d'état sont nécessaires pour implémenter les frais de protocole
 
 Ces variables gardent une trace des paires, des échanges entre deux types de jetons.
 
-La première, `getPair`, est un mapping qui identifie un contrat d'échange de paires basé sur les deux jetons ERC-20 échangés. Les jetons ERC-20 sont identifiés par les adresses des contrats qui les implémentent. Ainsi, les clés et la valeur sont toutes des adresses. Pour obtenir l'adresse de l'échange de paires qui vous permet de convertir des `tokenA` en `tokenB`, vous utilisez `getPair[<tokenA address>][<tokenB address>]` (ou l'inverse).
+La première, `getPair`, est un mappage qui identifie un contrat d'échange de paires basé sur les deux jetons ERC-20 qu'il échange. Les jetons ERC-20 sont identifiés par les adresses des contrats qui les implémentent, de sorte que les clés et la valeur sont toutes des adresses. Pour obtenir l'adresse de l'échange de paires qui vous permet de convertir `tokenA` en `tokenB`, vous utilisez `getPair[<adresse de tokenA>][<adresse de tokenB>]` (ou l'inverse).
 
-La seconde variable, `allPairs`, est un tableau qui inclut toutes les adresses d'échanges de paires créées par cette usine. Sur Ethereum, vous ne pouvez pas itérer le contenu d'un mapping ou obtenir une liste de toutes les clés, ainsi cette variable est la seule façon de savoir quels échanges sont gérés par cette usine.
+La seconde variable, `allPairs`, est un tableau qui inclut toutes les adresses des échanges de paires créés par cette usine. Sur Ethereum, vous ne pouvez pas itérer sur le contenu d'un mapping, ni obtenir une liste de toutes les clés. Cette variable est donc le seul moyen de savoir quels échanges cette usine gère.
 
-Remarque : Si vous ne pouvez pas itérer sur toutes les clés d'un mapping c'est parce que le stockage des données de contrat est _coûteux_, ainsi moins nous en utilisons, moins nous réalisons de changements et mieux ce sera. Vous pouvez créer des mappings [qui supportent l'itération](https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol) mais qui nécessitent un stockage supplémentaire pour une liste de clés. Dans la plupart des applications, vous n'avez pas besoin de ça.
+Note : La raison pour laquelle vous ne pouvez pas itérer sur toutes les clés d'un mapping est que le stockage des données de contrat est _coûteux_, donc moins nous en utilisons, et moins nous le modifions, mieux c'est. Vous pouvez créer [des mappings qui supportent l'itération](https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol), mais ils nécessitent un stockage supplémentaire pour une liste de clés. Dans la plupart des applications, vous n'en avez pas besoin.
 
 ```solidity
     event PairCreated(address indexed token0, address indexed token1, address pair, uint);
 ```
 
-Cet événement est émis lorsqu'un nouvel échange de paires est créé. Il comprend les adresses des jetons, l'adresse de l'échange de la paire et le nombre total d'échanges gérés par l'usine.
+Cet événement est émis lorsqu'un nouvel échange de paires est créé. Il comprend les adresses des jetons, l'adresse de l'échange de paires et le nombre total d'échanges gérés par l'usine.
 
 ```solidity
     constructor(address _feeToSetter) public {
@@ -722,7 +732,7 @@ Cet événement est émis lorsqu'un nouvel échange de paires est créé. Il com
     }
 ```
 
-La seule chose que le constructeur fait est de spécifier le `feeToSetter`. Les usines commencent sans frais, et seul `feeSetter` peut changer cela.
+La seule chose que fait le constructeur est de spécifier le `feeToSetter`. Les usines commencent sans frais, et seul `feeSetter` peut changer cela.
 
 ```solidity
     function allPairsLength() external view returns (uint) {
@@ -730,7 +740,7 @@ La seule chose que le constructeur fait est de spécifier le `feeToSetter`. Les
     }
 ```
 
-Cette fonction restitue le nombre de paires d'échange.
+Cette fonction retourne le nombre de paires d'échange.
 
 ```solidity
     function createPair(address tokenA, address tokenB) external returns (address pair) {
@@ -743,20 +753,22 @@ C'est la fonction principale de l'usine : créer un échange de paires entre deu
         (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
 ```
 
-Nous souhaitons que l'adresse du nouvel échange soit déterminable de sorte qu'elle puisse être calculée à l'avance hors chaîne (cela peut être utile pour [les transactions de couche 2](/developers/docs/layer-2-scaling/)). Pour cela, nous devons avoir les adresses de jetons dans un ordre cohérent indépendant de l'ordre dans lequel nous les avons reçus. Aussi les trions-nous ici.
+Nous voulons que l'adresse du nouvel échange soit déterministe, afin qu'elle puisse être calculée à l'avance hors chaîne (cela peut être utile pour les [transactions de couche 2](/developers/docs/scaling/)).
+Pour ce faire, nous devons avoir un ordre cohérent des adresses de jetons, quel que soit l'ordre dans lequel nous les avons reçues. Nous les trions donc ici.
 
 ```solidity
         require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
         require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
 ```
 
-Les grands pools de liquidités sont meilleurs que les petits parce qu'ils proposent des prix plus stables. Nous ne voulons pas disposer de plus d'un pool de liquidités par paire de jetons. S'il existe déjà un échange, il n'est pas nécessaire d'en créer un autre pour la même paire.
+Les grands pools de liquidités sont préférables aux petits, car ils ont des prix plus stables. Nous ne voulons pas avoir plus d'un pool de liquidités par paire de jetons. S'il existe déjà un échange, il n'est pas nécessaire d'en créer un autre pour la même paire.
 
 ```solidity
         bytes memory bytecode = type(UniswapV2Pair).creationCode;
 ```
 
-Pour créer un nouveau contrat, nous avons besoin du code qui va le créer (tant la fonction constructeur que le code qui va écrire en mémoire le bytecode EVM du contrat effectif). Normalement dans Solidity nous utilisons `addr = new <name of contract>(<constructor parameters>)` et le compilateur s'occupe de tout pour nous. Pour obtenir une adresse de contrat déterminable, nous devons toutefois utiliser [l'opcode CREATE2](https://eips.ethereum.org/EIPS/eip-1014). Lorsque ce code a été écrit, cet opcode n'était pas encore pris en charge par Solidity et il était donc nécessaire d'obtenir manuellement le code. Ce n'est plus un problème car [Solidity prend désormais en charge CREATE2](https://docs.soliditylang.org/en/v0.8.3/control-structures.html#salted-contract-creations-create2).
+Pour créer un nouveau contrat, nous avons besoin du code qui le crée (à la fois la fonction constructeur et le code qui écrit en mémoire le bytecode EVM du contrat réel). Normalement, dans Solidity, nous utilisons simplement `addr = new <nom du contrat>(<paramètres du constructeur>)` et le compilateur s'occupe de tout pour nous, mais pour avoir une adresse de contrat déterministe, nous devons utiliser [l'opcode CREATE2](https://eips.ethereum.org/EIPS/eip-1014).
+Lorsque ce code a été écrit, cet opcode n'était pas encore pris en charge par Solidity, il était donc nécessaire d'obtenir manuellement le code. Ce n'est plus un problème, car [Solidity prend maintenant en charge CREATE2](https://docs.soliditylang.org/en/v0.8.3/control-structures.html#salted-contract-creations-create2).
 
 ```solidity
         bytes32 salt = keccak256(abi.encodePacked(token0, token1));
@@ -765,23 +777,22 @@ Pour créer un nouveau contrat, nous avons besoin du code qui va le créer (tant
         }
 ```
 
-Lorsqu'un opcode n'est pas encore pris en charge par Solidity, nous pouvons l'appeler en utilisant l'[assemblage en ligne](https://docs.soliditylang.org/en/v0.8.3/assembly.html).
+Lorsqu'un opcode n'est pas encore pris en charge par Solidity, nous pouvons l'appeler en utilisant [l'assembly en ligne](https://docs.soliditylang.org/en/v0.8.3/assembly.html).
 
 ```solidity
         IUniswapV2Pair(pair).initialize(token0, token1);
 ```
 
-Appelez la fonction `initialize` pour dire au nouvel échange quels sont les deux jetons qu'il échange.
+Appeler la fonction `initialize` pour indiquer au nouvel échange les deux jetons qu'il échange.
 
 ```solidity
         getPair[token0][token1] = pair;
         getPair[token1][token0] = pair; // populate mapping in the reverse direction
         allPairs.push(pair);
         emit PairCreated(token0, token1, pair, allPairs.length);
-    }
 ```
 
-Enregistrez les informations de la nouvelle paire dans les variables d'état et émettez un événement pour informer tout le monde du nouvel échange de paires.
+Enregistrer les informations de la nouvelle paire dans les variables d'état et émettre un événement pour informer le monde du nouvel échange de paires.
 
 ```solidity
     function setFeeTo(address _feeTo) external {
@@ -796,13 +807,14 @@ Enregistrez les informations de la nouvelle paire dans les variables d'état et
 }
 ```
 
-Ces deux fonctions permettent à `feeSetter` de contrôler le destinataire des frais (le cas échéant) et d'orienter `feeSetter` vers une nouvelle adresse.
+Ces deux fonctions permettent à `feeSetter` de contrôler le destinataire des frais (le cas échéant) et de changer `feeSetter` en une nouvelle adresse.
 
 ### UniswapV2ERC20.sol {#UniswapV2ERC20}
 
-[Ce contrat](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) implemente le jeton de liquidité ERC-20. Il est identique au [contrat OpenZeppelin ERC-20](/developers/tutorials/erc20-annotated-code). De fait, je n'expliquerai que la partie qui est différente, à savoir la fonctionnalité `Permit`.
+[Ce contrat](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) met en œuvre le jeton de liquidité ERC-20. Il est similaire au [contrat ERC-20 d'OpenZeppelin](/developers/tutorials/erc20-annotated-code), je n'expliquerai donc que la partie qui est différente, la fonctionnalité `permit`.
 
-Les transactions sur Ethereum coûtent de l'Ether (ETH), ce qui équivaut à de l'argent réel. Si vous avez des jetons ERC-20 mais pas d'ETH, vous ne pouvez pas envoyer de transactions. Vous ne pouvez donc rien faire avec. Pour éviter ce problème, vous pouvez opter pour des [méta-transactions](https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/supporting-meta-transactions). Le propriétaire des jetons signe une transaction qui permet à quelqu'un d'autre de retirer des jetons hors chaîne et de les envoyer via Internet à un destinataire. Le destinataire disposant d'ETH soumet ensuite le permis pour le compte du propriétaire.
+Les transactions sur Ethereum coûtent de l'ether (ETH), ce qui équivaut à de l'argent réel. Si vous avez des jetons ERC-20 mais pas d'ETH, vous ne pouvez pas envoyer de transactions, et vous ne pouvez donc rien en faire. Une solution pour éviter ce problème est d'utiliser les [méta-transactions](https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/supporting-meta-transactions).
+Le propriétaire des jetons signe une transaction qui permet à une autre personne de retirer des jetons hors chaîne et l'envoie via Internet au destinataire. Le destinataire, qui possède des ETH, soumet alors le permis au nom du propriétaire.
 
 ```solidity
     bytes32 public DOMAIN_SEPARATOR;
@@ -810,13 +822,13 @@ Les transactions sur Ethereum coûtent de l'Ether (ETH), ce qui équivaut à de
     bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
 ```
 
-Ce hachage est l'[identifiant pour le type de transaction](https://eips.ethereum.org/EIPS/eip-712#rationale-for-typehash). Le seul que nous prenons en charge ici est `Permit` avec ces paramètres.
+Ce hachage est l'[identifiant du type de transaction](https://eips.ethereum.org/EIPS/eip-712#rationale-for-typehash). Le seul que nous prenons en charge ici est `Permit` avec ces paramètres.
 
 ```solidity
     mapping(address => uint) public nonces;
 ```
 
-Il n'est pas possible pour un destinataire de falsifier une signature numérique. Cependant, il est trivial d'envoyer la même transaction deux fois (c'est une forme d' [attaque par répétition](https://wikipedia.org/wiki/Replay_attack)). Pour éviter cela, nous utilisons un [nonce](https://wikipedia.org/wiki/Cryptographic_nonce). Si le nonce d'un nouveau `Permit` n'est pas supérieur de un au dernier nonce utilisé, nous supposons qu'il est invalide.
+Il n'est pas possible pour un destinataire de falsifier une signature numérique. Cependant, il est trivial d'envoyer la même transaction deux fois (c'est une forme d'[attaque par rejeu](https://wikipedia.org/wiki/Replay_attack)). Pour éviter cela, nous utilisons un [nonce](https://wikipedia.org/wiki/Cryptographic_nonce). Si le nonce d'un nouveau `Permit` n'est pas supérieur de un au dernier nonce utilisé, nous le considérons comme invalide.
 
 ```solidity
     constructor() public {
@@ -826,7 +838,7 @@ Il n'est pas possible pour un destinataire de falsifier une signature numérique
         }
 ```
 
-Ceci est le code pour récupérer [l'identifiant de la chaîne](https://chainid.network/). Il utilise une langue d'assemblage EVM appelé [Yul](https://docs.soliditylang.org/en/v0.8.4/yul.html). Notez que dans la version actuelle de Yul, vous devez utiliser `chainid()` et non pas `chainid`.
+Ceci est le code pour récupérer l'[identifiant de la chaîne](https://chainid.network/). Il utilise un dialecte d'assembly EVM appelé [Yul](https://docs.soliditylang.org/en/v0.8.4/yul.html). Notez que dans la version actuelle de Yul, vous devez utiliser `chainid()`, et non `chainid`.
 
 ```solidity
         DOMAIN_SEPARATOR = keccak256(
@@ -847,13 +859,13 @@ Calculer le [séparateur de domaine](https://eips.ethereum.org/EIPS/eip-712#rati
     function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
 ```
 
-C'est la fonction qui implémente les permissions. Elle reçoit comme paramètres les champs pertinents, et les trois valeurs scalaires pour [la signature](https://yos.io/2018/11/16/ethereum-signatures/) (v, r, et s).
+C'est la fonction qui implémente les permissions. Elle reçoit comme paramètres les champs pertinents, et les trois valeurs scalaires pour [la signature](https://yos.io/2018/11/16/ethereum-signatures/) (v, r et s).
 
 ```solidity
         require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
 ```
 
-N'acceptez pas les transactions après la date limite.
+Ne pas accepter les transactions après la date limite.
 
 ```solidity
         bytes32 digest = keccak256(
@@ -865,15 +877,15 @@ N'acceptez pas les transactions après la date limite.
         );
 ```
 
-`abi.encodePacked(...)` est le message que nous attendons de recevoir. Nous savons ce que le nonce devrait être. Il n'y a donc nul besoin de l'obtenir sous forme de paramètre.
+`abi.encodePacked(...)` est le message que nous nous attendons à recevoir. Nous savons ce que le nonce devrait être, il n'est donc pas nécessaire de l'obtenir en tant que paramètre.
 
-L'algorithme de signature Ethereum a besoin de 256 bits pour signer. aussi, utilisons-nous la fonction de hachage `keccak256`.
+L'algorithme de signature d'Ethereum attend 256 bits à signer, nous utilisons donc la fonction de hachage `keccak256`.
 
 ```solidity
         address recoveredAddress = ecrecover(digest, v, r, s);
 ```
 
-À partir du condensé et de la signature, nous pouvons obtenir l'adresse qui l'a signé en utilisant [ecrecovery](https://coders-errand.com/ecrecover-signature-verification-ethereum/).
+À partir du condensé et de la signature, nous pouvons obtenir l'adresse qui l'a signé en utilisant [ecrecover](https://coders-errand.com/ecrecover-signature-verification-ethereum/).
 
 ```solidity
         require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
@@ -882,19 +894,20 @@ L'algorithme de signature Ethereum a besoin de 256 bits pour signer. aussi, util
 
 ```
 
-Quand tout est en ordre, traitez ceci comme un [ERC-20 approve](https://eips.ethereum.org/EIPS/eip-20#approve).
+Si tout est OK, traiter cela comme [une approbation ERC-20](https://eips.ethereum.org/EIPS/eip-20#approve).
 
 ## Les contrats périphériques {#periphery-contracts}
 
-Les contrats périphériques sont l'API (interface du programme d'application) pour Uniswap. Ils sont disponibles pour les appels externes, en provenance d'autres contrats ou d'applications décentralisées. Vous pourriez appeler directement les contrats de base, mais c'est plus compliqué et vous pourriez perdre des valeurs si vous faites une erreur. Les contrats de base ne contiennent que des tests pour éviter toute escroquerie au contrat, pas de tests d'intégrité pour qui que ce soit d'autre. Ceux-ci sont au niveau des périphériques pour pouvoir être mis à jour au besoin.
+Les contrats périphériques sont l'API (interface de programme d'application) d'Uniswap. Ils sont disponibles pour les appels externes, en provenance d'autres contrats ou d'applications décentralisées. Vous pourriez appeler directement les contrats de base, mais c'est plus compliqué et vous pourriez perdre de la valeur si vous faites une erreur. Les contrats de base ne contiennent que des tests pour s'assurer qu'ils ne sont pas trompés, pas de contrôles de cohérence pour qui que ce soit d'autre. Ceux-ci sont dans la périphérie afin de pouvoir être mis à jour au besoin.
 
 ### UniswapV2Router01.sol {#UniswapV2Router01}
 
-[Ce contrat](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router01.sol) présente des dangers et [ne doit plus être utilisé](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-01). Heureusement, les contrats périphériques sont dénués d'état et ne détiennent aucun actif. Il est ainsi facile de les déprécier et de suggérer aux gens d'utiliser à la place `UniswapV2Router02`.
+[Ce contrat](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router01.sol) a des problèmes et [ne devrait plus être utilisé](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-01). Heureusement, les contrats périphériques sont apatrides et ne détiennent aucun actif, il est donc facile de le déprécier et de suggérer aux gens d'utiliser le remplacement, `UniswapV2Router02`, à la place.
 
 ### UniswapV2Router02.sol {#UniswapV2Router02}
 
-Dans la plupart des cas, vous utiliseriez Uniswap par le biais de [ce contrat](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router02.sol). Vous pouvez voir comment l'utiliser [ici](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02).
+Dans la plupart des cas, vous utiliseriez Uniswap via [ce contrat](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router02.sol).
+Vous pouvez voir comment l'utiliser [ici](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02).
 
 ```solidity
 pragma solidity =0.6.6;
@@ -909,7 +922,7 @@ import './interfaces/IERC20.sol';
 import './interfaces/IWETH.sol';
 ```
 
-Nous avons déjà rencontrés auparavant la plupart d'entre eux ou ils sont assez évidents. La seule exception est `IWETH.sol`. Uniswap v2 permet l'échange de n'importe quelle paire de jetons ERC-20 mais l'éther (ETH), en lui-même, n'est pas un jeton ERC-20. Il est antérieur à la norme et est transféré par des mécanismes spécifiques. Pour activer l'utilisation d'ETH dans les contrats qui s'appliquent aux jetons ERC-20, les programmeurs ont l'habitude d'utiliser le contrat [wrapped ether (WETH)](https://weth.tkn.eth.limo/). Vous envoyez ce contrat ETH, et il va frapper un montant équivalent de WETH. Vous pouvez également brûler WETH, et récupérer de l'ETH en retour.
+La plupart d'entre eux ont déjà été rencontrés ou sont assez évidents. La seule exception est `IWETH.sol`. Uniswap v2 permet les échanges pour n'importe quelle paire de jetons ERC-20, mais l'ether (ETH) lui-même n'est pas un jeton ERC-20. Il est antérieur à la norme et est transféré par des mécanismes uniques. Pour permettre l'utilisation d'ETH dans les contrats qui s'appliquent aux jetons ERC-20, le contrat [wrapped ether (WETH)](https://weth.tkn.eth.limo/) a été créé. Vous envoyez des ETH à ce contrat, et il frappe un montant équivalent de WETH. Ou vous pouvez brûler du WETH, et récupérer de l'ETH.
 
 ```solidity
 contract UniswapV2Router02 is IUniswapV2Router02 {
@@ -919,7 +932,7 @@ contract UniswapV2Router02 is IUniswapV2Router02 {
     address public immutable override WETH;
 ```
 
-Le routeur a besoin de savoir quelle usine utiliser, et pour les transactions qui nécessitent WETH, quel contrat WETH utiliser. Ces valeurs sont [immuables](https://docs.soliditylang.org/en/v0.8.3/contracts.html#constant-and-immutable-state-variables), ce qui signifie qu'elles ne peuvent être définies que dans le constructeur. Cela donne aux utilisateurs l'assurance que personne ne pourra les modifier pour tendre vers des contrats moins sûrs.
+Le routeur a besoin de savoir quelle usine utiliser et, pour les transactions qui nécessitent des WETH, quel contrat WETH utiliser. Ces valeurs sont [immuables](https://docs.soliditylang.org/en/v0.8.3/contracts.html#constant-and-immutable-state-variables), ce qui signifie qu'elles ne peuvent être définies que dans le constructeur. Cela donne aux utilisateurs l'assurance que personne ne pourra les modifier pour pointer vers des contrats moins honnêtes.
 
 ```solidity
     modifier ensure(uint deadline) {
@@ -928,7 +941,7 @@ Le routeur a besoin de savoir quelle usine utiliser, et pour les transactions qu
     }
 ```
 
-Ce modificateur permet de s'assurer que les opérations limitées dans le temps (« faire X avant le moment Y si possible ») ne se produisent pas après la limite de temps impartie.
+Ce modificateur garantit que les transactions limitées dans le temps (« faire X avant l'heure Y si possible ») ne se produisent pas après leur délai imparti.
 
 ```solidity
     constructor(address _factory, address _WETH) public {
@@ -945,11 +958,11 @@ Le constructeur définit simplement les variables d'état immuables.
     }
 ```
 
-Cette fonction est appelée lorsque nous échangeons des jetons du contrat WETH en ETH. Seul le contrat WETH que nous utilisons est autorisé à faire cela.
+Cette fonction est appelée lorsque nous échangeons des jetons du contrat WETH contre des ETH. Seul le contrat WETH que nous utilisons est autorisé à faire cela.
 
-#### Ajouter des liquidités {#add-liquidity}
+#### Ajouter de la liquidité {#add-liquidity}
 
-Ces fonctions ajoutent des jetons à l'échange de paires, ce qui augmente la réserve de liquidités.
+Ces fonctions ajoutent des jetons à l'échange de paires, ce qui augmente le pool de liquidités.
 
 ```solidity
 
@@ -957,49 +970,49 @@ Ces fonctions ajoutent des jetons à l'échange de paires, ce qui augmente la r
     function _addLiquidity(
 ```
 
-Cette fonction est utilisée pour calculer le nombre de jetons A et B qui doivent être déposés dans l'échange de paires.
+Cette fonction est utilisée pour calculer le montant des jetons A et B qui doivent être déposés dans l'échange de paires.
 
 ```solidity
         address tokenA,
         address tokenB,
 ```
 
-Voici les adresses des contrats de jetons ERC-20.
+Ce sont les adresses des contrats de jetons ERC-20.
 
 ```solidity
         uint amountADesired,
         uint amountBDesired,
 ```
 
-Ce sont les montants que le fournisseur de liquidités veut déposer. Ils sont également les montants maximum de A et de B à déposer.
+Ce sont les montants que le fournisseur de liquidités souhaite déposer. Ce sont également les montants maximums de A et de B à déposer.
 
 ```solidity
         uint amountAMin,
         uint amountBMin
 ```
 
-Ce sont les montants minimums acceptables pour le dépôt. Si la transaction ne peut avoir lieu avec ces montants ou plus, annulez-la. Si vous ne souhaitez pas de cette fonctionnalité, spécifiez simplement zéro.
+Ce sont les montants minimums acceptables pour le dépôt. Si la transaction ne peut pas avoir lieu avec ces montants ou plus, l'annuler. Si vous ne souhaitez pas cette fonctionnalité, spécifiez simplement zéro.
 
-Les fournisseurs de liquidités spécifient un minimum, généralement parce qu'ils souhaitent limiter la transaction à un taux de change proche de celui actuel. Si le taux de change fluctue trop, ce peut être en raison de nouvelles qui changent les valeurs sous-jacentes et les fournisseurs peuvent alors vouloir décider manuellement ce qu'il faut faire.
+Les fournisseurs de liquidités spécifient un minimum, généralement parce qu'ils souhaitent limiter la transaction à un taux de change proche de celui en vigueur. Si le taux de change fluctue trop, cela peut signifier que des nouvelles ont modifié les valeurs sous-jacentes, et ils veulent décider manuellement de la marche à suivre.
 
-Par exemple, imaginez un cas où le taux de change est d'un pour un et où le fournisseur de liquidités spécifie ces valeurs :
+Par exemple, imaginons un cas où le taux de change est de un pour un et où le fournisseur de liquidités spécifie ces valeurs :
 
 | Paramètre      | Valeur |
-| -------------- | ------:|
+| -------------- | -----: |
 | amountADesired |   1000 |
 | amountBDesired |   1000 |
 | amountAMin     |    900 |
 | amountBMin     |    800 |
 
-Tant que le taux de change reste compris entre 0,9 et 1,25, la transaction aura lieu. Si le taux de change sort de cette fourchette, la transaction sera annulée.
+Tant que le taux de change reste compris entre 0,9 et 1,25, la transaction a lieu. Si le taux de change sort de cette fourchette, la transaction est annulée.
 
-Cette précaution s'explique par le fait que les transactions ne sont pas immédiates, vous les soumettez et au bout du compte un validateur va les inclure dans un bloc (à moins que le prix du gaz soit particulièrement bas, auquel cas vous devrez soumettre, à la place, une autre transaction avec le même nonce et un prix de gaz plus élevé). Vous ne pouvez pas contrôler ce qui se passe pendant l'intervalle entre la soumission et l'inclusion.
+Cette précaution s'explique par le fait que les transactions ne sont pas immédiates, vous les soumettez et un validateur finira par les inclure dans un bloc (à moins que le prix du gaz soit très bas, auquel cas vous devrez soumettre une autre transaction avec le même nonce et un prix du gaz plus élevé pour l'écraser). Vous ne pouvez pas contrôler ce qui se passe pendant l'intervalle entre la soumission et l'inclusion.
 
 ```solidity
     ) internal virtual returns (uint amountA, uint amountB) {
 ```
 
-La fonction retourne les montants que le fournisseur de liquidités doit déposer pour avoir un taux égal au taux actuel entre les réserves.
+La fonction retourne les montants que le fournisseur de liquidités doit déposer pour avoir un ratio égal au ratio actuel entre les réserves.
 
 ```solidity
         // create the pair if it doesn't exist yet
@@ -1008,27 +1021,27 @@ La fonction retourne les montants que le fournisseur de liquidités doit dépose
         }
 ```
 
-S'il n'existe pas encore d'échange pour cette paire de jetons, créez-la.
+S'il n'existe pas encore d'échange pour cette paire de jetons, le créer.
 
 ```solidity
         (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
 ```
 
-Récupérez les réserves actuelles dans la paire.
+Obtenir les réserves actuelles de la paire.
 
 ```solidity
         if (reserveA == 0 && reserveB == 0) {
             (amountA, amountB) = (amountADesired, amountBDesired);
 ```
 
-Si les réserves actuelles sont vides alors il s'agit d'un nouvel échange de paires. Les montants à déposer devraient être exactement les mêmes que ceux que le fournisseur de liquidités souhaite fournir.
+Si les réserves actuelles sont vides, alors il s'agit d'un nouvel échange de paires. Les montants à déposer doivent être exactement les mêmes que ceux que le fournisseur de liquidités souhaite fournir.
 
 ```solidity
         } else {
             uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
 ```
 
-Si nous souhaitons connaître quels sont ces montants, sachez que le montant optimal est obtenu à l'aide de[cette fonction](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol#L35). L'objectif est d'avoir le même ratio que les réserves actuelles.
+Si nous devons voir quels seront les montants, nous obtenons le montant optimal en utilisant [cette fonction](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol#L35). Nous voulons le même ratio que les réserves actuelles.
 
 ```solidity
             if (amountBOptimal <= amountBDesired) {
@@ -1036,7 +1049,7 @@ Si nous souhaitons connaître quels sont ces montants, sachez que le montant opt
                 (amountA, amountB) = (amountADesired, amountBOptimal);
 ```
 
-Si `amountBOptimal` est plus petit que le montant que le fournisseur de liquidités veut déposer, cela signifie que le jeton B est à ce stade plus précieux que ne le pense le déposant de liquidité. Ainsi, un montant plus bas est requis.
+Si `amountBOptimal` est inférieur au montant que le fournisseur de liquidités souhaite déposer, cela signifie que le jeton B a actuellement plus de valeur que ne le pense le déposant, un montant inférieur est donc requis.
 
 ```solidity
             } else {
@@ -1046,13 +1059,13 @@ Si `amountBOptimal` est plus petit que le montant que le fournisseur de liquidit
                 (amountA, amountB) = (amountAOptimal, amountBDesired);
 ```
 
-Si le montant optimal de B est supérieur au montant désiré de B, cela signifie que les jetons B sont moins précieux actuellement que ne le pense le déposant de liquidités. Ainsi, un montant plus élevé est requis. Cependant, le montant souhaité est un maximum et nous ne pouvons donc pas aller jusque-là. Nous calculons donc le nombre optimal de jetons A pour le montant souhaité de jetons B.
+Si le montant optimal de B est supérieur au montant désiré de B, cela signifie que les jetons B ont actuellement moins de valeur que ne le pense le déposant de liquidités, un montant plus élevé est donc requis. Cependant, le montant souhaité est un maximum, nous ne pouvons donc pas le dépasser. Nous calculons donc le nombre optimal de jetons A pour le montant souhaité de jetons B.
 
-En mettant tout cela ensemble, nous obtenons ce graphique. Supposons que vous essayez de déposer un millier de jetons A (ligne bleue) et un millier de jetons B (ligne rouge). L'axe x est le taux de change, A/B. Si x=1, ils sont égaux en valeur et vous déposez mille de chaque. Si x=2, A est deux fois la valeur de B (vous obtenez deux jetons B pour chaque jeton A). Vous déposez donc un millier de jetons B, mais seulement 500 jetons A. Si x=0.5, la situation est alors inversée avec mille jetons A et cinq cents jetons B.
+En assemblant tout cela, nous obtenons ce graphique. Supposons que vous essayiez de déposer un millier de jetons A (ligne bleue) et un millier de jetons B (ligne rouge). L'axe des x représente le taux de change, A/B. Si x=1, ils ont la même valeur et vous déposez un millier de chaque. Si x=2, A vaut deux fois la valeur de B (vous obtenez deux jetons B pour chaque jeton A), vous déposez donc un millier de jetons B, mais seulement 500 jetons A. Si x=0,5, la situation est inversée : un millier de jetons A et cinq cents jetons B.
 
-![Graph](liquidityProviderDeposit.png)
+![Graphique](liquidityProviderDeposit.png)
 
-Vous pouvez déposer des liquidités directement dans le contrat principal (en utilisant [UniswapV2Pair::mint](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L110)), mais le contrat de base vérifie uniquement qu'il ne se trompe pas lui-même. Ainsi, vous risquez de perdre de la valeur si le taux de change évolue entre le moment où vous soumettez votre transaction et le moment où elle est exécutée. Si vous utilisez le contrat périphérique, il indique le montant que vous devez déposer et le dépose immédiatement. Ainsi, le taux de change n'évolue pas et vous ne perdez rien.
+Vous pourriez déposer des liquidités directement dans le contrat de base (en utilisant [UniswapV2Pair::mint](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L110)), mais le contrat de base vérifie uniquement qu'il ne se trompe pas lui-même. Vous risquez donc de perdre de la valeur si le taux de change évolue entre le moment où vous soumettez votre transaction et le moment où elle est exécutée. Si vous utilisez le contrat périphérique, il calcule le montant que vous devez déposer et le dépose immédiatement, de sorte que le taux de change ne change pas et vous ne perdez rien.
 
 ```solidity
     function addLiquidity(
@@ -1066,9 +1079,10 @@ Vous pouvez déposer des liquidités directement dans le contrat principal (en u
         uint deadline
 ```
 
-Cette fonction peut être appelée par une transaction de dépôt de liquidités. La plupart des paramètres sont les mêmes que pour `_addLiquidity` ci-dessus, à deux exceptions près :
+Cette fonction peut être appelée par une transaction pour déposer des liquidités. La plupart des paramètres sont les mêmes que dans `_addLiquidity` ci-dessus, à deux exceptions près :
 
-. `to` est l'adresse qui reçoit les nouveaux jetons de liquidité minés pour montrer la part du pool que détient le fournisseur de liquidités. `deadline` est une limite de temps sur la transaction
+. `to` est l'adresse qui reçoit les nouveaux jetons de liquidité frappés pour montrer la part du pool détenue par le fournisseur de liquidités.
+`deadline` est une limite de temps pour la transaction.
 
 ```solidity
     ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
@@ -1076,21 +1090,21 @@ Cette fonction peut être appelée par une transaction de dépôt de liquidités
         address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
 ```
 
-Nous calculons les montants à déposer et trouvons ensuite l'adresse de la réserve de liquidités. Pour économiser du gaz, nous ne le faisons pas en interrogeant l'usine, mais en utilisant la fonction de bibliothèque `pairFor` (voir ci-dessous dans les bibliothèques)
+Nous calculons les montants à déposer réellement, puis nous trouvons l'adresse du pool de liquidités. Pour économiser du gaz, nous ne le faisons pas en interrogeant l'usine, mais en utilisant la fonction de bibliothèque `pairFor` (voir ci-dessous dans les bibliothèques).
 
 ```solidity
         TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
         TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
 ```
 
-Transférez les bons montants de jetons de l'utilisateur à l'échange de paire.
+Transférer les bons montants de jetons de l'utilisateur vers l'échange de paires.
 
 ```solidity
         liquidity = IUniswapV2Pair(pair).mint(to);
     }
 ```
 
-En retour, donnez des jetons de liquidité à l'adresse `to` en vue de la détention partielle de la réserve. La fonction `mint` du contrat de base détermine de combien de jetons supplémentaires elle dispose (par rapport à ce dont elle disposait la dernière fois que la liquidité a changé) et frappe la liquidité en conséquence.
+En retour, donner à l'adresse `to` des jetons de liquidité pour une propriété partielle du pool. La fonction `mint` du contrat de base voit combien de jetons supplémentaires elle a (par rapport à ce qu'elle avait la dernière fois que la liquidité a changé) et frappe la liquidité en conséquence.
 
 ```solidity
     function addLiquidityETH(
@@ -1098,7 +1112,7 @@ En retour, donnez des jetons de liquidité à l'adresse `to` en vue de la déten
         uint amountTokenDesired,
 ```
 
-Lorsqu'un fournisseur de liquidités veut fournir des liquidités à un échange de paire Jeton/ETH, il y a quelques différences. Le contrat gère l'encapsulage d'ETH pour le fournisseur de liquidités. Il n'est pas nécessaire de spécifier combien d'ETH l'utilisateur veut déposer, parce que l'utilisateur les envoie simplement avec la transaction (le montant est disponible dans `msg.value`).
+Lorsqu'un fournisseur de liquidités souhaite fournir de la liquidité à un échange de paires Jeton/ETH, il y a quelques différences. Le contrat gère l'enveloppement de l'ETH pour le fournisseur de liquidités. Il n'est pas nécessaire de spécifier combien d'ETH l'utilisateur souhaite déposer, car il les envoie simplement avec la transaction (le montant est disponible dans `msg.value`).
 
 ```solidity
         uint amountTokenMin,
@@ -1120,7 +1134,7 @@ Lorsqu'un fournisseur de liquidités veut fournir des liquidités à un échange
         assert(IWETH(WETH).transfer(pair, amountETH));
 ```
 
-Pour déposer l'ETH le contrat va l'envelopper dans WETH, puis transfère le WETH dans la paire. Notez que le transfert est encapsulé dans un `assert`. Cela signifie que si le transfert échoue, cet appel de contrat échoue également et qu'ainsi l'encapsulage ne se produit pas.
+Pour déposer l'ETH, le contrat l'enveloppe d'abord dans du WETH, puis transfère le WETH dans la paire. Notez que le transfert est enveloppé dans un `assert`. Cela signifie que si le transfert échoue, cet appel de contrat échoue également, et donc l'enveloppement ne se produit pas réellement.
 
 ```solidity
         liquidity = IUniswapV2Pair(pair).mint(to);
@@ -1129,9 +1143,9 @@ Pour déposer l'ETH le contrat va l'envelopper dans WETH, puis transfère le WET
     }
 ```
 
-L'utilisateur nous a déjà envoyé l'ETH. Ainsi, s'il existe des reliquats (parce que l'autre jeton est moins précieux que ce que l'utilisateur pense), nous devons effectuer un remboursement.
+L'utilisateur nous a déjà envoyé les ETH. S'il reste un surplus (parce que l'autre jeton a moins de valeur que ne le pensait l'utilisateur), nous devons émettre un remboursement.
 
-#### Retirer la liquidité {#remove-liquidity}
+#### Retirer de la liquidité {#remove-liquidity}
 
 Ces fonctions supprimeront la liquidité et rembourseront le fournisseur de liquidités.
 
@@ -1148,7 +1162,7 @@ Ces fonctions supprimeront la liquidité et rembourseront le fournisseur de liqu
     ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
 ```
 
-Le cas le plus simple pour supprimer les liquidités. Il y a un montant minimum pour chaque jeton que le fournisseur de liquidités convient d'accepter et cela doit se produire avant la date limite.
+Le cas le plus simple de retrait de liquidité. Il y a un montant minimum pour chaque jeton que le fournisseur de liquidités accepte de recevoir, et cela doit avoir lieu avant la date limite.
 
 ```solidity
         address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
@@ -1156,19 +1170,19 @@ Le cas le plus simple pour supprimer les liquidités. Il y a un montant minimum
         (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
 ```
 
-La fonction `burn` du contrat de base permet de payer les jetons en retour à l'utilisateur.
+La fonction `burn` du contrat de base gère le remboursement des jetons à l'utilisateur.
 
 ```solidity
         (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
 ```
 
-Lorsqu'une fonction retourne plusieurs valeurs, mais que nous ne sommes intéressés que par certaines d'entre elles, nous récupérons uniquement ces valeurs. C'est un peu moins cher en termes de gaz que de lire une valeur et de ne jamais l'utiliser.
+Lorsqu'une fonction retourne plusieurs valeurs, mais que nous ne sommes intéressés que par certaines d'entre elles, voici comment nous obtenons uniquement ces valeurs. C'est un peu moins cher en termes de gaz que de lire une valeur et de ne jamais l'utiliser.
 
 ```solidity
         (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
 ```
 
-Traduit les montants de la façon dont le contrat de base les renvoie (jeton d'adresse inférieure d'abord) à la manière dont l'utilisateur les attend (correspondant au `jetonA` et `jetonB`).
+Traduire les montants de la façon dont le contrat de base les renvoie (jeton d'adresse inférieure en premier) à la manière dont l'utilisateur les attend (correspondant à `tokenA` et `tokenB`).
 
 ```solidity
         require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
@@ -1176,7 +1190,7 @@ Traduit les montants de la façon dont le contrat de base les renvoie (jeton d'a
     }
 ```
 
-Il est possible de faire le transfert d'abord puis de vérifier qu'il est légitime, car si ce n'est pas le cas, nous annulerons tous les changements d'état.
+Il est acceptable d'effectuer le transfert d'abord, puis de vérifier sa légitimité, car si ce n'est pas le cas, nous annulerons tous les changements d'état.
 
 ```solidity
     function removeLiquidityETH(
@@ -1202,7 +1216,7 @@ Il est possible de faire le transfert d'abord puis de vérifier qu'il est légit
     }
 ```
 
-Retirer la liquidité des ETH se fait presque de la même manière sauf que nous recevons les jetons WETH et que nous les rachetons pour que des ETH soient restitués au fournisseur de liquidités.
+Le retrait de liquidité pour l'ETH est presque identique, sauf que nous recevons les jetons WETH, puis les échangeons contre de l'ETH pour les restituer au fournisseur de liquidités.
 
 ```solidity
     function removeLiquidityWithPermit(
@@ -1238,10 +1252,9 @@ Retirer la liquidité des ETH se fait presque de la même manière sauf que nous
     }
 ```
 
-Ces fonctions relayent les méta-transactions pour permettre aux utilisateurs sans éther de se retirer du pool en utilisant [le mécanisme du permis](#UniswapV2ERC20).
+Ces fonctions relaient les méta-transactions pour permettre aux utilisateurs sans ether de se retirer du pool, en utilisant [le mécanisme de permis](#UniswapV2ERC20).
 
 ```solidity
-
     // **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
     function removeLiquidityETHSupportingFeeOnTransferTokens(
         address token,
@@ -1267,7 +1280,7 @@ Ces fonctions relayent les méta-transactions pour permettre aux utilisateurs sa
 
 ```
 
-Cette fonction peut être utilisée pour les jetons associés à des frais de transfert ou de stockage. Lorsqu'un jeton a de tels frais, nous ne pouvons pas compter sur la fonction `removeLiquidity` pour nous dire combien de jetons nous récupérons. Nous devons donc d'abord nous retirer et ensuite obtenir le solde.
+Cette fonction peut être utilisée pour les jetons qui ont des frais de transfert ou de stockage. Lorsqu'un jeton a de tels frais, nous ne pouvons pas compter sur la fonction `removeLiquidity` pour nous dire combien de jetons nous récupérons. Nous devons donc d'abord retirer, puis obtenir le solde.
 
 ```solidity
 
@@ -1292,11 +1305,11 @@ Cette fonction peut être utilisée pour les jetons associés à des frais de tr
 
 La fonction finale combine les frais de stockage avec les méta-transactions.
 
-#### Échanger {#trade}
+#### Commercer {#trade}
 
 ```solidity
     // **** SWAP ****
-    // requires the initial amount to have already been sent to the first pair
+    // nécessite que le montant initial ait déjà été envoyé à la première paire
     function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
 ```
 
@@ -1306,21 +1319,21 @@ Cette fonction réalise un traitement interne requis pour les fonctions qui sont
         for (uint i; i < path.length - 1; i++) {
 ```
 
-Au moment d'écrire ces lignes, il y a [388.160 jetons ERC-20](https://etherscan.io/tokens). S'il y avait un échange de paires pour chaque paire de jetons, cela représenterait plus de 150 milliards d'échanges de paires. La chaîne entière, en cet instant précis, [ne dispose que de 0,1 % de ce nombre de comptes](https://etherscan.io/chart/address). Les fonctions d'échange supportent le concept du chemin. Un trader peut échanger A contre B, B contre C et C contre D. Ainsi, il n'y a pas besoin d'un échange direct de paire A-D.
+Au moment où j'écris ces lignes, il existe [388 160 jetons ERC-20](https://eth.blockscout.com/tokens). S'il y avait un échange de paires pour chaque paire de jetons, cela représenterait plus de 150 milliards d'échanges de paires. La chaîne entière, à l'heure actuelle, [ne compte que 0,1 % de ce nombre de comptes](https://eth.blockscout.com/stats/accountsGrowth). Les fonctions d'échange supportent plutôt le concept de chemin. Un trader peut échanger A contre B, B contre C et C contre D. Ainsi, il n'y a pas besoin d'un échange direct de paire A-D.
 
-Les prix sur ces marchés tendent à être synchronisés, car quand ils sont désynchronisés, cela crée une opportunité d'arbitrage. Imaginez, par exemple, trois jetons : A, B et C. Il existe donc trois échanges de paires, un pour chaque paire.
+Les prix sur ces marchés tendent à être synchronisés, car quand ils sont désynchronisés, cela crée une opportunité d'arbitrage. Imaginez, par exemple, trois jetons : A, B et C. Il existe donc trois échanges de paires, un pour chaque paire.
 
 1. La situation initiale
-2. Un négociant vend 24,695 jetons A et récupère en échange 25,305 jetons B.
+2. Un trader vend 24,695 jetons A et obtient 25,305 jetons B.
 3. Le trader vend 24,695 jetons B contre 25,305 jetons C, et garde environ 0,61 jeton B comme bénéfice.
 4. Puis le trader vend 24,695 jetons C en échange de 25,305 jetons A, et garde environ 0,61 jeton C comme bénéfice. Le trader a également 0,61 jeton A supplémentaire (les 25,305 dont dispose le trader en fin de transaction moins l'investissement initial de 24,695).
 
-| Étape | Échange A-B                       | Échange B-C                       | Échange A-C                       |
-| ----- | --------------------------------- | --------------------------------- | --------------------------------- |
-| 1     | A : 1 000 B : 1 050 A/B=1,05      | B : 1 000 C : 1 050 B/C=1,05      | A : 1 050 C : 1 000 C/A=1,05      |
-| 2     | A : 1 024,695 B : 1 024,695 A/B=1 | B : 1 000 C : 1 050 B/C=1,05      | A : 1 050 C : 1 000 C/A=1,05      |
-| 3     | A : 1 024,695 B : 1 024,695 A/B=1 | B : 1 024,695 C : 1 024,695 B/C=1 | A : 1 050 C : 1 000 C/A=1,05      |
-| 4     | A : 1 024,695 B : 1 024,695 A/B=1 | B :1 024,695 C : 1 024,695 B/C=1  | A : 1 024,695 C : 1 024,695 C/A=1 |
+| Étape | Échange A-B                                                     | Échange B-C                                                     | Échange A-C                                                     |
+| ----- | --------------------------------------------------------------- | --------------------------------------------------------------- | --------------------------------------------------------------- |
+| 1     | A : 1 000 B : 1 050 A/B=1,05    | B : 1 000 C : 1 050 B/C=1,05    | A : 1 050 C : 1 000 C/A=1,05    |
+| 2     | A : 1024,695 B : 1024,695 A/B=1 | B : 1 000 C : 1 050 B/C=1,05    | A : 1 050 C : 1 000 C/A=1,05    |
+| 3     | A : 1024,695 B : 1024,695 A/B=1 | B : 1024,695 C : 1024,695 B/C=1 | A : 1 050 C : 1 000 C/A=1,05    |
+| 4     | A : 1024,695 B : 1024,695 A/B=1 | B : 1024,695 C : 1024,695 B/C=1 | A : 1024,695 C : 1024,695 C/A=1 |
 
 ```solidity
             (address input, address output) = (path[i], path[i + 1]);
@@ -1328,19 +1341,19 @@ Les prix sur ces marchés tendent à être synchronisés, car quand ils sont dé
             uint amountOut = amounts[i + 1];
 ```
 
-Obtenez la paire que nous traitons actuellement, triez-la (pour l'utiliser avec la paire) et obtenez le montant prévu de sortie.
+Obtenez la paire que nous traitons actuellement, triez-la (pour l'utiliser avec la paire) et obtenez le montant de sortie attendu.
 
 ```solidity
             (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
 ```
 
-Obtenez les montants prévus, triés de la façon dont l'échange de paire est souhaité.
+Obtenez les montants de sortie attendus, triés de la manière attendue par l'échange de paires.
 
 ```solidity
             address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
 ```
 
-Est-ce le dernier échange ? Si c'est le cas, envoyez les jetons reçus pour la transaction à sa destination. Si ce n'est pas le cas, envoyez-le à la prochaine paire d'échange.
+Est-ce le dernier échange ? Si c'est le cas, envoyez les jetons reçus pour la transaction à sa destination. Si ce n'est pas le cas, envoyez-le à la prochaine paire d'échange.
 
 ```solidity
 
@@ -1351,7 +1364,7 @@ Est-ce le dernier échange ? Si c'est le cas, envoyez les jetons reçus pour la
     }
 ```
 
-Effectuez un appel pour l'échange de paire afin d'échanger les jetons. Nous n'avons pas besoin d'un rappel pour être informé de l'échange. De fait, nous n'envoyons pas d'octets dans ce champ.
+Appelez réellement l'échange de paires pour échanger les jetons. Nous n'avons pas besoin d'un rappel pour être informé de l'échange. De fait, nous n'envoyons pas d'octets dans ce champ.
 
 ```solidity
     function swapExactTokensForTokens(
@@ -1367,9 +1380,9 @@ Cette fonction est utilisée directement par les traders pour échanger un jeton
 
 Ce paramètre contient les adresses des contrats ERC-20. Comme expliqué ci-dessus, il s'agit d'un tableau parce que vous pourriez avoir besoin de passer par plusieurs échanges de paires pour passer de l'actif que vous avez à l'actif que vous voulez.
 
-Un paramètre de fonction sur Solidity peut être stocké soit dans `memory`, soit dans `calldata`. Si la fonction est un point d'entrée du contrat, directement appelée par un utilisateur (en utilisant une transaction) ou à partir d'un contrat différent, la valeur du paramètre peut être directement obtenue à partir des données d'appel. Si la fonction est appelée en interne, comme ci-dessus avec `_swap`, alors les paramètres doivent être stockés dans `memory`. Du point de vue du contrat appelé `calldata` est en lecture seule.
+Un paramètre de fonction dans Solidity peut être stocké soit en `memory`, soit en `calldata`. Si la fonction est un point d'entrée du contrat, directement appelée par un utilisateur (en utilisant une transaction) ou à partir d'un contrat différent, la valeur du paramètre peut être directement obtenue à partir des données d'appel. Si la fonction est appelée en interne, comme `_swap` ci-dessus, alors les paramètres doivent être stockés en `memory`. Du point de vue du contrat appelé, `calldata` est en lecture seule.
 
-Avec des types scalaires tels que `uint` ou `address` le compilateur gère le moyen de stockage pour nous, mais avec les tableaux, qui sont plus longs et plus coûteux, nous spécifions le type de stockage à utiliser.
+Avec des types scalaires tels que `uint` ou `address`, le compilateur gère le choix de stockage pour nous, mais avec les tableaux, qui sont plus longs et plus coûteux, nous spécifions le type de stockage à utiliser.
 
 ```solidity
         address to,
@@ -1377,14 +1390,14 @@ Avec des types scalaires tels que `uint` ou `address` le compilateur gère le mo
     ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
 ```
 
-Les valeurs retournées sont toujours retournées en mémoire.
+Les valeurs de retour sont toujours retournées en mémoire.
 
 ```solidity
         amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
         require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
 ```
 
-Calculez le montant à acheter pour chaque échange. Si le résultat est inférieur au minimum que ce que le trader est prêt à accepter, annulez la transaction.
+Calculez le montant à acheter pour chaque échange. Si le résultat est inférieur au minimum que le trader est prêt à accepter, annulez la transaction.
 
 ```solidity
         TransferHelper.safeTransferFrom(
@@ -1394,7 +1407,7 @@ Calculez le montant à acheter pour chaque échange. Si le résultat est inféri
     }
 ```
 
-Enfin, transférez le jeton ERC-20 initial sur le compte pour l'échange de la première paire et appelez `_swap`. Tout cela se passe dans la même transaction. Ainsi, l'échange de paire sait que tous les jetons inattendus font partie de ce transfert.
+Enfin, transférez le jeton ERC-20 initial sur le compte pour l'échange de la première paire et appelez `_swap`. Tout cela se passe dans la même transaction. Ainsi, l'échange de paires sait que tous les jetons inattendus font partie de ce transfert.
 
 ```solidity
     function swapTokensForExactTokens(
@@ -1415,7 +1428,7 @@ Enfin, transférez le jeton ERC-20 initial sur le compte pour l'échange de la p
 
 La fonction précédente, `swapTokensForTokens`, permet à un trader de spécifier le nombre exact de jetons d'entrée qu'il est prêt à donner et le nombre minimum de jetons de sortie qu'il est prêt à recevoir en retour. Cette fonction fait l'échange inverse, elle permet à un trader de spécifier le nombre de jetons de sortie qu'il veut, ainsi que le nombre maximum de jetons d'entrée qu'il est prêt à payer.
 
-Dans les deux cas, le trader doit d'abord donner à ce contrat périphérique une indemnité lui permettant de les transférer.
+Dans les deux cas, le trader doit d'abord donner à ce contrat périphérique une autorisation pour lui permettre de les transférer.
 
 ```solidity
     function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
@@ -1501,7 +1514,7 @@ Ces quatre variantes impliquent toutes des échanges entre ETH et des jetons. La
     function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual {
 ```
 
-C'est la fonction interne pour échanger les jetons associés à des frais de transfert ou de stockage pour résoudre ([ce problème](https://github.com/Uniswap/uniswap-interface/issues/835)).
+C'est la fonction interne pour échanger les jetons qui ont des frais de transfert ou de stockage pour résoudre ([ce problème](https://github.com/Uniswap/uniswap-interface/issues/835)).
 
 ```solidity
         for (uint i; i < path.length - 1; i++) {
@@ -1510,16 +1523,16 @@ C'est la fonction interne pour échanger les jetons associés à des frais de tr
             IUniswapV2Pair pair = IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output));
             uint amountInput;
             uint amountOutput;
-            { // scope to avoid stack too deep errors
+            { // portée pour éviter les erreurs de pile trop profonde
             (uint reserve0, uint reserve1,) = pair.getReserves();
             (uint reserveInput, uint reserveOutput) = input == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
             amountInput = IERC20(input).balanceOf(address(pair)).sub(reserveInput);
             amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput);
 ```
 
-En raison des frais de transfert, nous ne pouvons pas compter sur la fonction `getAmountsOut` pour nous dire combien nous tirons de chaque transfert (la façon dont nous le faisons avant d'appeler le `_swap` original). Au lieu de cela, nous devons d'abord transférer et ensuite voir combien de jetons nous avons récupérés.
+En raison des frais de transfert, nous ne pouvons pas nous fier à la fonction `getAmountsOut` pour nous dire combien nous obtenons de chaque transfert (comme nous le faisons avant d'appeler le `_swap` original). Au lieu de cela, nous devons d'abord transférer et ensuite voir combien de jetons nous avons récupérés.
 
-Remarque : En théorie, nous pourrions simplement utiliser cette fonction au lieu de `_swap`, mais dans certains cas (par exemple, si le transfert s'achève parce qu'il n'y a pas assez à la fin pour atteindre le minimum requis) cela finirait par coûter plus en gaz. Les jetons de frais de transfert sont assez rares, donc bien que nous devions les prendre en compte, il n'est pas nécessaire de supposer que tous les swaps passent par au moins un d'entre eux.
+Remarque : En théorie, nous pourrions simplement utiliser cette fonction au lieu de `_swap`, mais dans certains cas (par exemple, si le transfert est annulé parce qu'il n'y a pas assez à la fin pour atteindre le minimum requis), cela finirait par coûter plus de gaz. Les jetons avec frais de transfert sont assez rares. Bien que nous devions les prendre en charge, il n'est pas nécessaire que tous les échanges partent du principe qu'ils en impliquent au moins un.
 
 ```solidity
             }
@@ -1598,10 +1611,10 @@ Remarque : En théorie, nous pourrions simplement utiliser cette fonction au lie
     }
 ```
 
-Ce sont les mêmes variants utilisés pour les jetons normaux, mais ils appellent à la place `_swapSupportingFeeOnTransferTokens`.
+Ce sont les mêmes variantes utilisées pour les jetons normaux, mais elles appellent `_swapSupportingFeeOnTransferTokens` à la place.
 
 ```solidity
-    // **** LIBRARY FUNCTIONS ****
+    // **** FONCTIONS DE LA BIBLIOTHÈQUE ****
     function quote(uint amountA, uint reserveA, uint reserveB) public pure virtual override returns (uint amountB) {
         return UniswapV2Library.quote(amountA, reserveA, reserveB);
     }
@@ -1648,38 +1661,38 @@ Ce sont les mêmes variants utilisés pour les jetons normaux, mais ils appellen
 }
 ```
 
-Ces fonctions ne sont que des proxy qui appellent les fonctions [UniswapV2Library](#uniswapV2library).
+Ces fonctions sont simplement des proxys qui appellent les [fonctions d'UniswapV2Library](#uniswapV2library).
 
 ### UniswapV2Migrator.sol {#UniswapV2Migrator}
 
-Ce contrat a été utilisé pour migrer les échanges de l'ancienne v1 vers la v2. Maintenant qu'ils ont été migrés, ce n'est plus pertinent.
+Ce contrat a été utilisé pour migrer les échanges de l'ancienne v1 vers la v2. Maintenant qu'ils ont été migrés, il n'est plus pertinent.
 
 ## Les bibliothèques {#libraries}
 
-La bibliothèque [SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math) est bien documentée et il n'y a pas lieu donc ici de le faire.
+La [bibliothèque SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math) est bien documentée, il n'est donc pas nécessaire de la documenter ici.
 
-### Mathématiques {#Math}
+### Math {#Math}
 
-Cette bibliothèque contient des fonctions mathématiques qui ne sont pas habituelement nécessaires dans le code Solidity. Elles ne font donc pas partie du langage.
+Cette bibliothèque contient des fonctions mathématiques qui ne sont pas habituellement nécessaires dans le code Solidity. Elles ne font donc pas partie du langage.
 
 ```solidity
 pragma solidity =0.5.16;
 
-// a library for performing various math operations
+// une bibliothèque pour effectuer diverses opérations mathématiques
 
 library Math {
     function min(uint x, uint y) internal pure returns (uint z) {
         z = x < y ? x : y;
     }
 
-    // babylonian method (https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
+    // méthode babylonienne (https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
     function sqrt(uint y) internal pure returns (uint z) {
         if (y > 3) {
             z = y;
             uint x = y / 2 + 1;
 ```
 
-Commencez avec x comme une estimation supérieure à la racine carrée (c'est la raison pour laquelle nous devons traiter 1-3 comme des cas spéciaux).
+Commencez avec x comme une estimation supérieure à la racine carrée (c'est la raison pour laquelle nous devons traiter 1-3 comme des cas particuliers).
 
 ```solidity
             while (x < z) {
@@ -1687,7 +1700,7 @@ Commencez avec x comme une estimation supérieure à la racine carrée (c'est la
                 x = (y / x + x) / 2;
 ```
 
-Obtenez une estimation plus précise, la moyenne de l'estimation précédente et le nombre dont nous essayons de trouver la racine carrée divisés par l'estimation précédente. Répétez jusqu'à ce que la nouvelle estimation ne soit pas inférieure à celle existante. Pour de plus amples informations : [voir ici](https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method).
+Obtenez une estimation plus précise, la moyenne de l'estimation précédente et le nombre dont nous essayons de trouver la racine carrée divisée par l'estimation précédente. Répétez jusqu'à ce que la nouvelle estimation ne soit pas inférieure à celle existante. Pour plus de détails, [voir ici](https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method).
 
 ```solidity
             }
@@ -1703,17 +1716,17 @@ Nous ne devrions jamais avoir besoin de la racine carrée de zéro. Les racines
 }
 ```
 
-### Fractions de points fixes (UQ112x112) {#FixedPoint}
+### Fractions à point fixe (UQ112x112) {#FixedPoint}
 
-Cette bibliothèque gère les fractions qui ne font normalement pas partie de l'arithmétique Ethereum. Elle réalise cela en encodant le nombre _x_ en _x\*2^112_. Cela nous permet d'utiliser l'addition originale et les opcodes de soustraction sans aucun changement.
+Cette bibliothèque gère les fractions qui ne font normalement pas partie de l'arithmétique Ethereum. Elle le fait en encodant le nombre _x_ comme _x\*2^112_. Cela nous permet d'utiliser les codes d'opérations d'addition et de soustraction d'origine sans modification.
 
 ```solidity
 pragma solidity =0.5.16;
 
-// a library for handling binary fixed point numbers (https://wikipedia.org/wiki/Q_(number_format))
+// une bibliothèque pour la gestion des nombres à virgule fixe binaires (https://wikipedia.org/wiki/Q_(number_format))
 
-// range: [0, 2**112 - 1]
-// resolution: 1 / 2**112
+// plage : [0, 2**112 - 1]
+// résolution : 1 / 2**112
 
 library UQ112x112 {
     uint224 constant Q112 = 2**112;
@@ -1722,25 +1735,25 @@ library UQ112x112 {
 `Q112` est l'encodage pour un.
 
 ```solidity
-    // encode a uint112 as a UQ112x112
+    // encode un uint112 en UQ112x112
     function encode(uint112 y) internal pure returns (uint224 z) {
-        z = uint224(y) * Q112; // never overflows
+        z = uint224(y) * Q112; // ne provoque jamais de dépassement
     }
 ```
 
-Parce que 'y' est `uint112`, le maximum peut-être 2^112-1. Ce nombre peut toujours être encodé en tant que `UQ112x112`.
+Puisque y est un `uint112`, sa valeur maximale est 2^112-1. Ce nombre peut toujours être encodé en `UQ112x112`.
 
 ```solidity
-    // divide a UQ112x112 by a uint112, returning a UQ112x112
+    // divise un UQ112x112 par un uint112, retournant un UQ112x112
     function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
         z = x / uint224(y);
     }
 }
 ```
 
-Si nous divisons deux valeurs `UQ112x112`, le résultat ne sera plus multiplié par 2^112. Ainsi, nous prenons à la place un entier comme dénominateur. Nous aurions dû utiliser une astuce similaire pour faire la multiplication, mais nous n'avons pas besoin de faire la multiplication de la valeur `UQ112x112`.
+Si nous divisons deux valeurs `UQ112x112`, le résultat n'est plus multiplié par 2^112. Ainsi, nous prenons à la place un entier comme dénominateur. Nous aurions dû utiliser une astuce similaire pour faire la multiplication, mais nous n'avons pas besoin de faire la multiplication de la valeur `UQ112x112`.
 
-### Bibliothèque UniswapV2 {#uniswapV2library}
+### UniswapV2Library {#uniswapV2library}
 
 Cette bibliothèque n'est utilisée que par les contrats périphériques
 
@@ -1754,7 +1767,7 @@ import "./SafeMath.sol";
 library UniswapV2Library {
     using SafeMath for uint;
 
-    // returns sorted token addresses, used to handle return values from pairs sorted in this order
+    // renvoie les adresses des jetons triés, utilisé pour gérer les valeurs de retour des paires triées dans cet ordre
     function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
         require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
         (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
@@ -1762,25 +1775,25 @@ library UniswapV2Library {
     }
 ```
 
-Trie les deux jetons par leurs adresses afin que nous puissions obtenir l'adresse de leur échange en paire. Ceci est nécessaire car sinon nous aurions deux possibilités, une pour les paramètres A,B et un autre pour les paramètres B,A, impliquant deux échanges au lieu d'un.
+Triez les deux jetons par adresse, afin que nous puissions obtenir l'adresse de l'échange de paires pour eux. Ceci est nécessaire car sinon nous aurions deux possibilités, une pour les paramètres A, B et une autre pour les paramètres B, A, ce qui conduirait à deux échanges au lieu d'un seul.
 
 ```solidity
-    // calculates the CREATE2 address for a pair without making any external calls
+    // calcule l'adresse CREATE2 pour une paire sans effectuer d'appels externes
     function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
         (address token0, address token1) = sortTokens(tokenA, tokenB);
         pair = address(uint(keccak256(abi.encodePacked(
                 hex'ff',
                 factory,
                 keccak256(abi.encodePacked(token0, token1)),
-                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
+                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // hachage du code d'initialisation
             ))));
     }
 ```
 
-Cette fonction calcule l'adresse de l'échange en paire pour les deux jetons. Ce contrat est créé en utilisant [l'opcode CREATE2](https://eips.ethereum.org/EIPS/eip-1014) et ainsi nous pouvons calculer l'adresse utilisant le même algorithme si nous connaissons les paramètres qu'il utilise. C'est beaucoup moins cher que de demander à l'usine.
+Cette fonction calcule l'adresse de l'échange en paire pour les deux jetons. Ce contrat est créé en utilisant [le code d'opération CREATE2](https://eips.ethereum.org/EIPS/eip-1014). Nous pouvons donc calculer l'adresse en utilisant le même algorithme si nous connaissons les paramètres qu'il utilise. C'est beaucoup moins cher que de demander à la factory, et
 
 ```solidity
-    // fetches and sorts the reserves for a pair
+    // récupère et trie les réserves pour une paire
     function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
         (address token0,) = sortTokens(tokenA, tokenB);
         (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
@@ -1788,10 +1801,10 @@ Cette fonction calcule l'adresse de l'échange en paire pour les deux jetons. Ce
     }
 ```
 
-Cette fonction retourne les réserves des deux jetons que l'échange en paire possède. Notez qu'il peut recevoir les jetons dans l'ordre et les trier pour un usage interne.
+Cette fonction retourne les réserves des deux jetons que l'échange en paire possède. Notez qu'il peut recevoir les jetons dans n'importe quel ordre, et les trier pour un usage interne.
 
 ```solidity
-    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
+    // étant donné un certain montant d'un actif et des réserves de paires, renvoie un montant équivalent de l'autre actif
     function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
         require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
         require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
@@ -1802,11 +1815,11 @@ Cette fonction retourne les réserves des deux jetons que l'échange en paire po
 Cette fonction vous donne le montant du jeton B que vous obtiendrez en échange du jeton A s'il n'y a pas de frais engagés. Ce calcul prend en compte le fait que le transfert modifie le taux de change.
 
 ```solidity
-    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
+    // étant donné un montant d'entrée d'un actif et des réserves de paires, renvoie le montant de sortie maximum de l'autre actif
     function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
 ```
 
-La fonction `quote` ci-dessus fonctionne bien s'il n'y a pas de frais pour l'utilisation de l'échange en paire. Cependant, s'il existe des frais de change de 0,3 %, le montant que vous obtenez est inférieur. Cette fonction calcule le montant après les frais de change.
+La fonction `quote` ci-dessus fonctionne bien s'il n'y a pas de frais pour l'utilisation de l'échange en paire. Cependant, s'il existe des frais de change de 0,3 %, le montant que vous obtenez réellement est inférieur. Cette fonction calcule le montant après les frais de change.
 
 ```solidity
 
@@ -1819,10 +1832,10 @@ La fonction `quote` ci-dessus fonctionne bien s'il n'y a pas de frais pour l'uti
     }
 ```
 
-Solidity ne gère pas nativement les fractions. Ainsi, nous ne pouvons pas simplement multiplier le montant par 0,997. Au lieu de cela, nous multiplions le numérateur par 997 et le dénominateur par 1 000, avec le même effet.
+Solidity ne gère pas nativement les fractions. Ainsi, nous ne pouvons pas simplement multiplier le montant par 0,997. Au lieu de cela, nous multiplions le numérateur par 997 et le dénominateur par 1 000, ce qui a le même effet.
 
 ```solidity
-    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
+    // étant donné un montant de sortie d'un actif et des réserves de paires, renvoie le montant d'entrée requis de l'autre actif
     function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
         require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
         require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
@@ -1836,7 +1849,7 @@ Cette fonction réalise à peu près la même chose, mais elle récupère le mon
 
 ```solidity
 
-    // performs chained getAmountOut calculations on any number of pairs
+    // effectue des calculs de getAmountOut en chaîne sur un nombre quelconque de paires
     function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
         require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
         amounts = new uint[](path.length);
@@ -1847,7 +1860,7 @@ Cette fonction réalise à peu près la même chose, mais elle récupère le mon
         }
     }
 
-    // performs chained getAmountIn calculations on any number of pairs
+    // effectue des calculs de getAmountIn en chaîne sur un nombre quelconque de paires
     function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
         require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
         amounts = new uint[](path.length);
@@ -1862,16 +1875,16 @@ Cette fonction réalise à peu près la même chose, mais elle récupère le mon
 
 Ces deux fonctions permettent d'identifier les valeurs lorsqu'il est nécessaire de passer par plusieurs échanges de paires.
 
-### Assistant de transfert {#transfer-helper}
+### Aide au transfert {#transfer-helper}
 
-[Cette bibliothèque](https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol) ajoute des vérifications de réussites des transferts ERC-20 et Ethereum pour traiter une annulation et une valeur retournée `false` de la même façon.
+[Cette bibliothèque](https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol) ajoute des contrôles de réussite autour des transferts ERC-20 et Ethereum pour traiter de la même manière une annulation et un retour de valeur `false`.
 
 ```solidity
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.6.0;
 
-// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
+// méthodes d'aide pour interagir avec les jetons ERC20 et envoyer des ETH qui ne renvoient pas systématiquement true/false
 library TransferHelper {
     function safeApprove(
         address token,
@@ -1886,7 +1899,7 @@ library TransferHelper {
 Nous pouvons appeler un autre contrat de deux manières :
 
 - Utiliser une définition d'interface pour créer un appel de fonction
-- Utiliser l'[interface binaire d'application (ABI)](https://docs.soliditylang.org/en/v0.8.3/abi-spec.html) « manuellement » pour créer l'appel. C'est ce que l'auteur du code a décidé de faire.
+- Utiliser l'[interface binaire de l'application (ABI)](https://docs.soliditylang.org/en/v0.8.3/abi-spec.html) « manuellement » pour créer l'appel. C'est ce que l'auteur du code a décidé de faire.
 
 ```solidity
         require(
@@ -1896,7 +1909,7 @@ Nous pouvons appeler un autre contrat de deux manières :
     }
 ```
 
-Pour des raisons de compatibilité ascendante avec un jeton qui a été créé avant la norme ERC-20, un appel ERC-20 peut échouer soit en revenant (dans ce cas `success` sera `false`) soit en réussissant et en retournant une valeur `false` (dans ce cas il y aura une donnée de sortie et si vous la décodez comme un booléen, vous obtenez `false`).
+Pour des raisons de rétrocompatibilité avec les jetons créés avant la norme ERC-20, un appel ERC-20 peut échouer soit en étant annulé (auquel cas `success` est `false`), soit en réussissant mais en retournant une valeur `false` (auquel cas il y a des données de sortie, et si vous les décodez en tant que booléen, vous obtenez `false`).
 
 ```solidity
 
@@ -1915,7 +1928,7 @@ Pour des raisons de compatibilité ascendante avec un jeton qui a été créé a
     }
 ```
 
-Cette fonction implémente [la fonctionnalité transfert de ERC-20](https://eips.ethereum.org/EIPS/eip-20#transfer), qui permet à un compte de dépenser la provision fournie par un autre compte.
+Cette fonction implémente la [fonctionnalité de transfert d'ERC-20](https://eips.ethereum.org/EIPS/eip-20#transfer), qui permet à un compte de dépenser la provision fournie par un autre compte.
 
 ```solidity
 
@@ -1934,7 +1947,7 @@ Cette fonction implémente [la fonctionnalité transfert de ERC-20](https://eips
     }
 ```
 
-Cette fonction implémente [la fonctionnalité transferFrom de ERC-20](https://eips.ethereum.org/EIPS/eip-20#transferfrom), qui permet à un compte de dépenser la provision fournie par un autre compte.
+Cette fonction implémente la [fonctionnalité transferFrom d'ERC-20](https://eips.ethereum.org/EIPS/eip-20#transferfrom), qui permet à un compte de dépenser la provision fournie par un autre compte.
 
 ```solidity
 
@@ -1945,10 +1958,12 @@ Cette fonction implémente [la fonctionnalité transferFrom de ERC-20](https://e
 }
 ```
 
-Cette fonction transfère de l'éther vers un compte. Tout appel à un autre contrat peut tenter d'envoyer l'éther en question. Parce que nous n'avons pas besoin d'appeler une quelconque fonction, nous n'envoyons aucune donnée avec l'appel.
+Cette fonction transfère de l'éther vers un compte. Tout appel à un autre contrat peut tenter d'envoyer de l'éther. Parce que nous n'avons pas besoin d'appeler une quelconque fonction, nous n'envoyons aucune donnée avec l'appel.
 
 ## Conclusion {#conclusion}
 
-Ceci est un article d'environ 50 pages. Si vous êtes arrivé jusqu'ici, félicitations ! Espérons que maintenant vous avez compris les considérations à prendre en compte pour écrire une application réelle (par opposition aux programmes courts d'échantillons) et êtes plus à même d'écrire des contrats pour vos propres utilisations.
+Ceci est un long article d'environ 50 pages. Si vous êtes arrivé jusqu'ici, félicitations ! Espérons que maintenant vous avez compris les considérations à prendre en compte pour écrire une application réelle (par opposition aux programmes d'exemple courts) et que vous êtes mieux à même d'écrire des contrats pour vos propres cas d'utilisation.
 
 Et maintenant, à vous d'écrire quelque chose d'utile et de nous étonner.
+
+[Voir ici pour plus de mon travail](https://cryptodocguy.pro/).
diff --git a/public/content/translations/fr/developers/tutorials/using-websockets/index.md b/public/content/translations/fr/developers/tutorials/using-websockets/index.md
index 3ccb429d597..10c219b08e2 100644
--- a/public/content/translations/fr/developers/tutorials/using-websockets/index.md
+++ b/public/content/translations/fr/developers/tutorials/using-websockets/index.md
@@ -1,22 +1,18 @@
 ---
 title: Utiliser WebSockets
-description: Guide d'utilisation des WebSockets et d'Alchemy pour réaliser des requêtes JSON-RPC et s'abonner à des événements.
+description: "Guide d'utilisation des WebSockets et d'Alchemy pour réaliser des requêtes JSON-RPC et s'abonner à des événements."
 author: "Elan Halpern"
 lang: fr
-tags:
-  - "alchemy"
-  - "websockets"
-  - "requêtes"
-  - "javascript"
+tags: [ "Alchemy", "websockets", "requêtes", "JavaScript" ]
 skill: beginner
-source: Documentation Alchemy
-sourceUrl: https://docs.alchemyapi.io/guides/using-websockets
+source: Alchemy docs
+sourceUrl: https://www.alchemy.com/docs/reference/best-practices-for-using-websockets-in-web3
 published: 2020-12-01
 ---
 
 Il s'agit d'un guide pour débuter avec l'utilisation de WebSockets et d'Alchemy pour effectuer des requêtes sur la blockchain Ethereum.
 
-## WebSockets vs. HTTP {#websockets-vs-http}
+## WebSockets vs HTTP {#websockets-vs-http}
 
 Contrairement à HTTP, avec les WebSockets, il n'est pas nécessaire d'émettre continuellement des demandes lorsque vous souhaitez obtenir des informations spécifiques. WebSockets maintient une connexion réseau pour vous (si cela est fait correctement) et écoute les modifications.
 
@@ -24,11 +20,11 @@ Comme pour toute connexion réseau, vous ne devez pas supposer qu'un WebSocket r
 
 [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) ajoute automatiquement la gestion des erreurs WebSocket et les retente sans configuration nécessaire.
 
-## Essayez le {#try-it-out}
+## Essayez-le {#try-it-out}
 
-Le moyen le plus simple de tester WebSockets est d'installer un outil de lignes de commandes pour créer des requêtes WebSocket telles que [wscat](https://github.com/websockets/wscat). En utilisant wscat, vous pouvez envoyer des requêtes comme suit :
+Le moyen le plus simple de tester les WebSockets est d'installer un outil en ligne de commande pour effectuer des requêtes WebSocket, tel que [wscat](https://github.com/websockets/wscat). En utilisant wscat, vous pouvez envoyer des requêtes comme suit :
 
-_Note : Si vous disposez d'un compte Alchemy, vous pouvez remplacer `demo` par votre propre clé API. [ Créez votre compte Alchemy gratuitement ici !](https://auth.alchemyapi.io/signup)_
+_Note : si vous avez un compte Alchemy, vous pouvez remplacer `demo` par votre propre clé API. [Inscrivez-vous gratuitement pour obtenir un compte Alchemy ici !](https://auth.alchemy.com/signup)_
 
 ```
 wscat -c wss://eth-mainnet.ws.alchemyapi.io/ws/demo
@@ -39,13 +35,13 @@ wscat -c wss://eth-mainnet.ws.alchemyapi.io/ws/demo
 
 ```
 
-## Comment utiliser WebSockets {#how-to-use-websockets}
+## Comment utiliser les WebSockets {#how-to-use-websockets}
 
-Pour commencer, ouvrez un WebSocket en utilisant le lien Websocket pour votre app. Vous pouvez trouver l'URL WebSocket de votre application en ouvrant la page de l'application dans [votre tableau de bord](https://dashboard.alchemyapi.io/) et en cliquant sur « Afficher la clé ». Notez que l'URL de votre application pour WebSockets est différente de son URL pour les demandes HTTP, mais les deux peuvent être trouvées en cliquant sur « Voir la clé ».
+Pour commencer, ouvrez un WebSocket en utilisant le lien Websocket pour votre app. Vous pouvez trouver l'URL WebSocket de votre application en ouvrant la page de l'application dans [votre tableau de bord](https://dashboard.alchemy.com/) et en cliquant sur « Afficher la clé ». Notez que l'URL de votre application pour WebSockets est différente de son URL pour les demandes HTTP, mais les deux peuvent être trouvées en cliquant sur « Voir la clé ».
 
-![Où trouver votre URL WebSocket dans votre tableau de bord Alchemy](./use-websockets.gif)
+![Où trouver l'URL de votre WebSocket dans votre tableau de bord Alchemy](./use-websockets.gif)
 
-Chacune des API listées dans la [Référence de l'API Alchemy](https://docs.alchemyapi.io/documentation/alchemy-api-reference/) peut être utilisée via WebSocket. Pour ce faire, utilisez le même bloc que le corps d'une requête HTTP POST, mais envoyez ce payload à travers le WebSocket.
+Toutes les API répertoriées dans la [référence de l'API Alchemy](https://www.alchemy.com/docs/reference/api-overview) peuvent être utilisées via WebSocket. Pour ce faire, utilisez le même bloc que le corps d'une requête HTTP POST, mais envoyez ce payload à travers le WebSocket.
 
 ## Avec Web3 {#with-web3}
 
@@ -59,7 +55,7 @@ web3.eth.getBlockNumber().then(console.log) // -> 7946893
 
 ## API d'abonnement {#subscription-api}
 
-Lorsque vous êtes connecté avec WebSocket, vous avez accès à deux méthodes supplémentaires : `eth_subscribe` et `eth_unsubscribe`. Ces méthodes vous permettront d'écouter des événements spécifiques et d'être immédiatement averti lorsqu'ils se produisent.
+Lorsque vous êtes connecté via un WebSocket, vous pouvez utiliser deux méthodes supplémentaires : `eth_subscribe` et `eth_unsubscribe`. Ces méthodes vous permettront d'écouter des événements spécifiques et d'être immédiatement averti lorsqu'ils se produisent.
 
 ### `eth_subscribe` {#eth-subscribe}
 
@@ -72,25 +68,25 @@ Crée un nouvel abonnement pour les événements spécifiés. [En savoir plus su
 
 Le premier argument spécifie le type d'événement à écouter. Le deuxième argument contient des options supplémentaires qui dépendent du premier argument. Les différents types de description, leurs options et leurs blocs d'événement sont décrits ci-dessous.
 
-#### Valeur de retour {#returns}
+#### Retours {#returns}
 
-L'identifiant de l'abonnement : cet identifiant sera attaché à chaque événements reçu, et peut également être utilisé pour résilier l'abonnement associé en utilisant `eth_unsubscribe`.
+L'ID de l'abonnement : cet ID sera joint à tous les événements reçus et pourra également être utilisé pour annuler l'abonnement à l'aide de `eth_unsubscribe`.
 
 #### Événements d'abonnement {#subscription-events}
 
 Tant que l'abonnement est actif, vous recevrez des événements sous la forme d'objets avec les propriétés suivantes :
 
-- `jsonrpc` : Toujours « 2.0 »
-- `method` : Toujours « eth_subscription »
-- `params` : Un objet comportant les propriétés suivantes :
-  - `subscription` : L'identifiant de l'abonnement retourné par l'appel de la méthode `eth_subscription` qui a créé cet abonnement.
-  - `result` : Un objet dont le contenu varie en fonction du type d'abonnement.
+- `jsonrpc` : Toujours « 2.0 »
+- `method` : Toujours « eth_subscription »
+- `params` : Un objet avec les champs suivants :
+  - `subscription` : L'ID d'abonnement renvoyé par l'appel `eth_subscribe` qui a créé cet abonnement.
+  - `result` : un objet dont le contenu varie en fonction du type d'abonnement.
 
-#### Types d'abonnement {#subscription-types}
+#### Types d'abonnements {#subscription-types}
 
 1. `alchemy_newFullPendingTransactions`
 
-Retourne les informations de transaction pour toutes les transactions qui sont ajoutées à l'état en attente. Ce type d'abonnement concerne les transactions en attente, de manière similaire à l'appel Web3 standard `web3.eth.subscribe(« pendingTransactions »)`, mais à la différence qu'il émet _des informations complètes sur les transactions_ plutôt que simplement les empreintes numériques.
+Retourne les informations de transaction pour toutes les transactions qui sont ajoutées à l'état en attente. Ce type d'abonnement souscrit aux transactions en attente, de la même manière que l'appel Web3 standard `web3.eth.subscribe("pendingTransactions")`, mais il diffère en ce qu'il émet des _informations de transaction complètes_ plutôt que de simples hachages de transaction.
 
 Exemple :
 
@@ -148,7 +144,7 @@ Exemple :
           "nonce":  "0x084149998194cc5f",
           "number":  "0x1348c9",
           "parentHash":  "0x7736fab79e05dc611604d22470dadad26f56fe494421b5b333de816ce1f25701",
-          "receiptRoot":  "0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36",
+'était un tableau de ces chaînes.          "receiptRoot":  "0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36",
           "sha3Uncles":  "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
           "stateRoot":  "0xb3346685172db67de536d8765c43c31009d0eb3bd9c501c9be3229203f15f378",
           "timestamp":  "0x56ffeff8",
@@ -164,26 +160,26 @@ Exemple :
 
 Émet des journaux concernant les blocs récemment ajoutés qui correspondent aux critères de filtre spécifiés.
 
-Lorsqu'une réorganisation de la chaîne se produit, les logs qui font partie des blocs de l'ancienne chaîne seront à nouveau émis avec la propriété `removed` réglée sur `true`. De plus, les logs qui font partie des blocs de la nouvelle chaîne sont émis, ce qui signifie qu'il est possible de voir les journaux pour la même transaction plusieurs fois dans le cas d'une réorganisation.
+Lorsqu'une réorganisation de la chaîne se produit, les logs qui font partie des blocs de l'ancienne chaîne seront de nouveau émis avec la propriété `removed` définie sur `true`. De plus, les logs qui font partie des blocs de la nouvelle chaîne sont émis, ce qui signifie qu'il est possible de voir les journaux pour la même transaction plusieurs fois dans le cas d'une réorganisation.
 
 Paramètres
 
 1. Un objet avec les propriétés suivantes :
-   - `address` (optionnelle) : soit une chaîne de caractères représentant une adresse soit un tableau de ces chaînes de caractères.
+   - `address` (facultatif) : soit une chaîne de caractères représentant une adresse, soit un tableau de ces chaînes.
      - Seuls les journaux créés par une de ces adresses seront émis.
-   - `topics` : un tableau de spécificateurs de sujet.
+   - `topics` : un tableau de spécificateurs de sujet.
      - Chaque spécificateur de sujet est soit `null`, soit une chaîne de caractères représentant un sujet, soit un tableau de chaînes de caractères.
-     - Chaque position dans le tableau qui n'est pas `null` limite les logs émis à ceux qui ont un des sujets donnés dans cette position.
+     - Chaque position dans le tableau qui n'est pas `null` restreint les logs émis à ceux qui ont l'un des sujets donnés dans cette position.
 
 Quelques exemples de spécifications du sujet :
 
-- `[]` : Tous les sujets sont autorisés.
-- `[A]`: A en première position (et n'importe quoi après).
-- `[null, B]` : N'importe quoi en première position et B en deuxième position (et n'importe quoi après).
-- `[A, B]` : A en première position et B en deuxième position (et n'importe quoi après).
-- `[[A, B], [A, B]]` : (A ou B) en première position et (A ou B) en deuxième position (et n'importe quoi après).
+- `[]` : Tous les sujets sont autorisés.
+- `[A]` : A en première position (et n'importe quoi après).
+- `[null, B]` : N'importe quoi en première position et B en deuxième position (et n'importe quoi après).
+- `[A, B]` : A en première position et B en deuxième position (et n'importe quoi après).
+- `[[A, B], [A, B]]` : (A ou B) en première position et (A ou B) en deuxième position (et n'importe quoi après).
 
-Exemple :
+Exemple :
 
 ```json
 >  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["logs",  {"address":  "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd",  "topics":  ["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}
@@ -215,7 +211,7 @@ Annule un abonnement existant afin qu'aucun événement supplémentaire ne soit
 
 Paramètres
 
-1. ID de l'abonnement, comme précédemment retourné de l'appel `eth_subscribe`.
+1. ID d'abonnement, tel que retourné précédemment par un appel `eth_subscribe`.
 
 Retours
 
@@ -246,4 +242,4 @@ curl https://eth-mainnet.alchemyapi.io/v2/your-api-key
 
 ---
 
-[Inscrivez-vous gratuitement sur Alchemy](https://auth.alchemyapi.io/signup), consultez [notre documentation](https://docs.alchemyapi.io/), et pour les dernières nouvelles, suivez-nous sur [Twitter](https://twitter.com/AlchemyPlatform).
+[Inscrivez-vous gratuitement sur Alchemy](https://auth.alchemy.com), consultez [notre documentation](https://www.alchemy.com/docs/), et pour les dernières actualités, suivez-nous sur [Twitter](https://x.com/AlchemyPlatform).
diff --git a/public/content/translations/fr/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md b/public/content/translations/fr/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
index 994532ecc8b..01b0105b5f6 100644
--- a/public/content/translations/fr/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
+++ b/public/content/translations/fr/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
@@ -1,13 +1,15 @@
 ---
-title: "Waffle: Bouchonnage dynamique et tests de contrats"
-description: Tutoriel Waffle avancé pour utiliser le bouchonnage dynamique et tester les appels de contrat
+title: "Waffle : Bouchonnage dynamique et tests d'appels de contrat"
+description: "Tutoriel Waffle avancé pour utiliser le bouchonnage dynamique et tester les appels de contrat"
 author: "Daniel Izdebski"
 tags:
-  - "waffle"
-  - "contrats intelligents"
-  - "solidity"
-  - "test"
-  - "bouchonnage"
+  [
+    "Waffle",
+    "contrats intelligents",
+    "Solidity",
+    "test",
+    "simulation"
+  ]
 skill: intermediate
 lang: fr
 published: 2020-11-14
@@ -20,19 +22,19 @@ Dans ce tutoriel, vous apprendrez comment :
 - utiliser le bouchonnage dynamique
 - tester les interactions entre contrats intelligents
 
-Prérequis :
+Hypothèses :
 
 - vous savez déjà écrire un simple contrat intelligent en `Solidity`
-- vous vous débrouillez en `JavaScript` et en `TypeScript`
-- vous avez fait d'autres tutoriels `Waffle` ou vous connaissez deux ou trois choses à ce sujet
+- vous vous débrouillez en `JavaScript` et `TypeScript`
+- vous avez suivi d'autres tutoriels `Waffle` ou vous en savez déjà un peu plus à ce sujet
 
 ## Bouchonnage dynamique {#dynamic-mocking}
 
-Pourquoi le bouchonnage dynamique est-il utile ? Eh bien, il nous permet de rédiger des tests unitaires plutôt que des tests d'intégration. Qu'est-ce que cela signifie ? Cela signifie que nous n'avons pas à nous soucier des dépendances des contrats intelligents, donc que nous pouvons tous les tester de façon isolée. Laissez-moi vous montrer comment procéder.
+Pourquoi le bouchonnage dynamique est-il utile ? Eh bien, il nous permet de rédiger des tests unitaires plutôt que des tests d'intégration. Qu'est-ce que cela signifie ? Cela signifie que nous n'avons pas à nous soucier des dépendances des contrats intelligents, nous pouvons donc tous les tester de manière complètement isolée. Laissez-moi vous montrer comment procéder.
 
 ### **1. Projet** {#1-project}
 
-Avant de commencer, nous avons besoin de préparer un simple projet node.js :
+Avant de commencer, nous devons préparer un simple projet node.js :
 
 ```bash
 mkdir dynamic-mocking
@@ -40,23 +42,23 @@ cd dynamic-mocking
 mkdir contracts src
 
 yarn init
-# or if you're using npm
+# ou si vous utilisez npm
 npm init
 ```
 
-Commençons par ajouter typescript et les dépendances de test - mocha & chai :
+Commençons par ajouter TypeScript et les dépendances de test, soit mocha et chai :
 
 ```bash
 yarn add --dev @types/chai @types/mocha chai mocha ts-node typescript
-# or if you're using npm
+# ou si vous utilisez npm
 npm install @types/chai @types/mocha chai mocha ts-node typescript --save-dev
 ```
 
-Maintenant, ajoutons `Waffle` et `ethers`:
+Maintenant, ajoutons `Waffle` et `ethers` :
 
 ```bash
 yarn add --dev ethereum-waffle ethers
-# or if you're using npm
+# ou si vous utilisez npm
 npm install ethereum-waffle ethers --save-dev
 ```
 
@@ -71,9 +73,9 @@ La structure de votre projet devrait ressembler à ceci :
 
 ### **2. Contrat intelligent** {#2-smart-contract}
 
-Pour démarrer un bouchonnage dynamique, nous avons besoin d'un contrat intelligent avec des dépendances. Ne t'inquiètes pas, nous assurons tes arrières !
+Pour commencer le bouchonnage dynamique, nous avons besoin d'un contrat intelligent avec des dépendances. Ne vous inquiétez pas, j'ai ce qu'il vous faut !
 
-Voici un contrat intelligent simple écrit en `Solidity` dont le seul but est de vérifier si nous sommes riches. Il utilise un jeton ERC20 pour vérifier si nous avons suffisamment de jetons. Mettez-le dans `./contracts/AmIRichAlready.sol`.
+Voici un contrat intelligent simple écrit en `Solidity` dont le seul but est de vérifier si nous sommes riches. Il utilise un jeton ERC20 pour vérifier si nous avons suffisamment de jetons. Placez-le dans `./contracts/AmIRichAlready.sol`.
 
 ```solidity
 pragma solidity ^0.6.2;
@@ -97,9 +99,9 @@ contract AmIRichAlready {
 }
 ```
 
-Comme nous voulons utiliser le bouchonnage dynamique, nous n'avons pas besoin de tout l'ERC20, c'est pourquoi nous utilisons l'interface IERC20 avec une seule fonction.
+Comme nous voulons utiliser le bouchonnage dynamique, nous n'avons pas besoin de l'intégralité de l'ERC20. C'est pourquoi nous utilisons l'interface IERC20 avec une seule fonction.
 
-Il est temps de créer ce contrat ! Pour cela, nous utiliserons le `Waffle`. Tout d'abord, nous allons créer un simple fichier de configuration `waffle.json` qui spécifie les options de compilation.
+Il est temps de compiler ce contrat ! Pour cela, nous utiliserons `Waffle`. Tout d'abord, nous allons créer un simple fichier de configuration `waffle.json` qui spécifie les options de compilation.
 
 ```json
 {
@@ -116,11 +118,11 @@ Nous sommes désormais prêts à construire le contrat avec Waffle :
 npx waffle
 ```
 
-Facile, n'est-ce pas? Dans le dossier `build/`, deux fichiers correspondant au contrat et à l'interface apparaissent. Nous les utiliserons plus tard pour les tests.
+Facile, n'est-ce pas ? Dans le dossier `build/`, deux fichiers correspondant au contrat et à l'interface sont apparus. Nous les utiliserons plus tard pour les tests.
 
 ### **3. Tests** {#3-testing}
 
-Nous allons créer un fichier appelé `AmIRichAlready.test.ts` pour le test actuel. Tout d'abord, nous devons gérer les importations. Nous en aurons besoin pour plus tard:
+Créons un fichier nommé `AmIRichAlready.test.ts` pour y mettre nos tests. Tout d'abord, nous devons gérer les importations. Nous en aurons besoin pour plus tard :
 
 ```typescript
 import { expect, use } from "chai"
@@ -133,34 +135,34 @@ import {
 } from "ethereum-waffle"
 ```
 
-Sauf pour les dépendances JS, nous devons importer le contrat et l'interface précédemment créés :
+Outre les dépendances JS, nous devons importer notre contrat compilé et son interface :
 
 ```typescript
 import IERC20 from "../build/IERC20.json"
 import AmIRichAlready from "../build/AmIRichAlready.json"
 ```
 
-Waffle utilise `chai` pour le test. Cependant, avant de pouvoir l'utiliser, nous devons injecter les matchers de Waffle dans le chai lui-même :
+Waffle utilise `chai` pour les tests. Cependant, avant de pouvoir l'utiliser, nous devons injecter les matchers de Waffle dans chai lui-même :
 
 ```typescript
 use(solidity)
 ```
 
-Nous devons implémenter la fonction `beforeEach()` qui réinitialisera l'état du contrat avant chaque test. Réfléchissons d'abord à ce dont nous avons besoin. Pour déployer un contrat, nous avons besoin de deux choses: un wallet et un contrat ERC20 déployé pour le passer comme argument pour le contrat `AmIRichAlready`.
+Nous devons implémenter la fonction `beforeEach()` qui réinitialisera l'état du contrat avant chaque test. Réfléchissons d'abord à ce dont nous avons besoin. Pour déployer un contrat, nous avons besoin de deux choses : un portefeuille et un contrat ERC20 déployé pour le passer en argument au contrat `AmIRichAlready`.
 
-Premièrement, créons nous un portefeuille:
+Premièrement, créons un portefeuille :
 
 ```typescript
 const [wallet] = new MockProvider().getWallets()
 ```
 
-Ensuite, nous devons déployer un contrat ERC20. Voici la partie délicate - nous n'avons qu'une seule interface. C'est la partie où Waffle vient nous sauver. Waffle a une fonction magique `deployMockContract()` qui crée un contrat en utilisant uniquement le _abi_ de l'interface :
+Ensuite, nous devons déployer un contrat ERC20. Voici la partie délicate : nous n'avons qu'une interface. C'est là que Waffle vient à notre rescousse. Waffle dispose d'une fonction magique `deployMockContract()` qui crée un contrat en utilisant uniquement l'_abi_ de l'interface :
 
 ```typescript
 const mockERC20 = await deployMockContract(wallet, IERC20.abi)
 ```
 
-Maintenant, avec le wallet et l'ERC20 déployé, nous pouvons continuer et déployer le contrat `AmIRichAlready`:
+Maintenant qu'on a le portefeuille et le contrat ERC20 déployé, nous pouvons déployer le contrat `AmIRichAlready` :
 
 ```typescript
 const contract = await deployContract(wallet, AmIRichAlready, [
@@ -198,37 +200,37 @@ describe("Am I Rich Already", () => {
 })
 ```
 
-Écrivons le premier test pour le contrat `AmIRichalready`. De quoi pensez-vous que notre test devrait traiter? Ouais, vous avez raison! Nous devrions vérifier si nous sommes déjà riches :)
+Écrivons le premier test pour le contrat `AmIRichAlready`. Selon vous, sur quoi notre test devrait-il porter ? Oui, vous avez raison ! Nous devrions vérifier si nous sommes déjà riches :)
 
-Mais attendez une seconde. Comment notre contrat fictif saura-t-il quelles valeurs retourner? Nous n'avons implémenté aucune logique pour la fonction `balanceOf()`. Là encore, Waffle peut nous aider. Notre contrat fictif a de nouveaux trucs fantaisistes maintenant :
+Mais attendez une seconde. Comment notre contrat bouchonné saura-t-il quelles valeurs retourner ? Nous n'avons implémenté aucune logique pour la fonction `balanceOf()`. Là encore, Waffle peut nous aider. Notre contrat bouchonné dispose maintenant de nouvelles fonctionnalités intéressantes :
 
 ```typescript
 await mockERC20.mock.<nameOfMethod>.returns(<value>)
 await mockERC20.mock.<nameOfMethod>.withArgs(<arguments>).returns(<value>)
 ```
 
-Avec cette connaissance, nous pouvons enfin écrire notre premier test :
+Grâce à ces connaissances, nous pouvons enfin écrire notre premier test :
 
 ```typescript
-it("returns false if the wallet has less than 1000000 tokens", async () => {
+it("retourne « faux » si le portefeuille a moins de 1 000 000 de jetons", async () => {
   await mockERC20.mock.balanceOf.returns(utils.parseEther("999999"))
   expect(await contract.check()).to.be.equal(false)
 })
 ```
 
-Décomposons ce test en parties :
+Décomposons ce test en plusieurs parties :
 
-1. Nous avons fixé notre contrat fictif ERC20 pour toujours retourner le solde de 999999 jetons.
-2. Vérifiez si la méthode `contract.check()` retourne `false`.
+1. Nous configurons notre contrat ERC20 bouchonné pour qu'il retourne toujours un solde de 999 999 jetons.
+2. Vérifier si la méthode `contract.check()` retourne `false`.
 
-Nous sommes prêts à allumer la bête :
+Nous sommes prêts à lancer le test :
 
 ![Un test réussi](./test-one.png)
 
-Alors le test fonctionne, mais... il y a encore des choses à améliorer. La fonction `balanceOf()` retournera toujours 99999. Nous pouvons l'améliorer en spécifiant un portefeuille pour lequel la fonction devrait retourner quelque chose - tout comme un contrat réel :
+Le test fonctionne donc, mais... il y a encore une marge d'amélioration. La fonction `balanceOf()` retournera toujours 99999. Nous pouvons l'améliorer en spécifiant un portefeuille pour lequel la fonction doit retourner quelque chose, tout comme un vrai contrat :
 
 ```typescript
-it("returns false if the wallet has less than 1000001 tokens", async () => {
+it("retourne « faux » si le portefeuille a moins de 1 000 001 jetons", async () => {
   await mockERC20.mock.balanceOf
     .withArgs(wallet.address)
     .returns(utils.parseEther("999999"))
@@ -236,10 +238,10 @@ it("returns false if the wallet has less than 1000001 tokens", async () => {
 })
 ```
 
-Jusqu'à présent, nous avons testé seulement le cas où nous ne sommes pas assez riche. Essayons l'inverse:
+Jusqu'à présent, nous n'avons testé que le cas où nous ne sommes pas assez riches. Testons le cas contraire :
 
 ```typescript
-it("returns true if the wallet has at least 1000001 tokens", async () => {
+it("retourne « vrai » si le portefeuille a au moins 1 000 001 jetons", async () => {
   await mockERC20.mock.balanceOf
     .withArgs(wallet.address)
     .returns(utils.parseEther("1000001"))
@@ -247,28 +249,28 @@ it("returns true if the wallet has at least 1000001 tokens", async () => {
 })
 ```
 
-Vous exécutez les tests...
+Vous lancez les tests...
 
 ![Deux tests réussis](test-two.png)
 
-Et voici où tu en es! Notre contrat semble fonctionner comme prévu :)
+... et voilà ! Notre contrat semble fonctionner comme prévu :)
 
 ## Test des appels de contrat {#testing-contract-calls}
 
-Résumons ce qui a été fait jusqu'à présent. Nous avons testé la fonctionnalité de notre contrat `AmIRichalready` et il semble qu'il fonctionne correctement. Cela signifie que nous avons terminé, n'est-ce pas? Pas exactement ! Waffle nous permet de tester encore plus notre contrat. Mais comment exactement ? Eh bien, dans l'arsenal de Waffle, il y a une correspondance entre `calledOnContract()` et `calledOnContractWith()`. Cela va nous permettre de vérifier si notre contrat a appelé le contrat fictif ERC20. Voici un test de base avec l'une de ces correspondance:
+Résumons ce que nous avons fait jusqu'à présent. Nous avons testé la fonctionnalité de notre contrat `AmIRichAlready` et il semble fonctionner correctement. Cela signifie que nous avons terminé, n'est-ce pas ? Pas tout à fait ! Waffle nous permet de tester notre contrat de manière encore plus approfondie. Mais comment exactement ? Eh bien, dans l'arsenal de Waffle, il y a les matchers `calledOnContract()` et `calledOnContractWith()`. Ils nous permettront de vérifier si notre contrat a bien appelé le contrat ERC20 bouchonné. Voici un test de base avec l'un de ces matchers :
 
 ```typescript
-it("checks if contract called balanceOf on the ERC20 token", async () => {
+it("vérifie si le contrat a appelé balanceOf sur le jeton ERC20", async () => {
   await mockERC20.mock.balanceOf.returns(utils.parseEther("999999"))
   await contract.check()
   expect("balanceOf").to.be.calledOnContract(mockERC20)
 })
 ```
 
-Nous pouvons aller encore plus loin et améliorer ce test avec l'autre matcher dont nous vous avons parlé:
+Nous pouvons aller encore plus loin et améliorer ce test avec l'autre matcher dont je vous ai parlé :
 
 ```typescript
-it("checks if contract called balanceOf with certain wallet on the ERC20 token", async () => {
+it("vérifie si le contrat a appelé balanceOf avec un certain portefeuille sur le jeton ERC20", async () => {
   await mockERC20.mock.balanceOf
     .withArgs(wallet.address)
     .returns(utils.parseEther("999999"))
@@ -281,18 +283,18 @@ Vérifions si les tests sont corrects :
 
 ![Trois tests réussis](test-three.png)
 
-Super, tous les tests sont verts.
+Super, tous les tests sont au vert.
 
-Tester des appels de contrats avec Waffle est super facile. Et voici la meilleure partie. Ces matchers fonctionnent à la fois avec des contrats normaux et fictifs ! C'est parce que Waffle enregistre et filtre les appels EVM plutôt que d'injecter du code, comme c'est le cas des bibliothèques de test populaires pour d'autres technologies.
+Tester les appels de contrat avec Waffle est super facile. Et voici le meilleur. Ces matchers fonctionnent aussi bien avec des contrats normaux qu'avec des contrats bouchonnés ! C'est parce que Waffle enregistre et filtre les appels EVM plutôt que d'injecter du code, comme c'est le cas des bibliothèques de test populaires pour d'autres technologies.
 
-## La fin {#the-finish-line}
+## La ligne d'arrivée {#the-finish-line}
 
-Félicitations ! Maintenant vous savez comment utiliser Waffle pour tester dynamiquement les appels de contrats et les contrats fictifs. Il y a beaucoup plus de fonctionnalités intéressantes à découvrir. Je recommande de plonger dans la documentation de Waffle.
+Félicitations ! Vous savez maintenant comment utiliser Waffle pour tester les appels de contrat et pour bouchonner dynamiquement les contrats. Il y a bien d'autres fonctionnalités intéressantes à découvrir. Je vous recommande de vous plonger dans la documentation de Waffle.
 
-La documentation Waffle est disponible [here](https://ethereum-waffle.readthedocs.io/).
+La documentation de Waffle est disponible [ici](https://ethereum-waffle.readthedocs.io/).
 
-Le code source de ce tutoriel est disponible [ici](https://github.com/EthWorks/Waffle/tree/master/examples/dynamic-mocking-and-testing-calls).
+Le code source de ce tutoriel se trouve [ici](https://github.com/EthWorks/Waffle/tree/master/examples/dynamic-mocking-and-testing-calls).
 
-Voici d'autres tutoriels qui pourraient vous intéresser :
+Tutoriels qui pourraient également vous intéresser :
 
 - [Tester des contrats intelligents avec Waffle](/developers/tutorials/waffle-test-simple-smart-contract/)
diff --git a/public/content/translations/fr/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md b/public/content/translations/fr/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
index b4715e9ca5e..b8a5363ac8d 100644
--- a/public/content/translations/fr/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
+++ b/public/content/translations/fr/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
@@ -1,22 +1,24 @@
 ---
-title: 'Tutoriel pour "dire bonjour au monde" avec hardhat et ethers'
-description: Réalisez votre premier projet Waffle avec hardhat et ethers.js
+title: "Tutoriel Waffle « Hello world » avec Hardhat et Ethers"
+description: "Réalisez votre premier projet Waffle avec Hardhat et ethers.js"
 author: "MiZiet"
 tags:
-  - "waffle"
-  - "contrats intelligents"
-  - "solidité"
-  - "test"
-  - "hardhat"
-  - "ethers.js"
+  [
+    "Waffle",
+    "contrats intelligents",
+    "Solidity",
+    "test",
+    "Hardhat",
+    "ethers.js"
+  ]
 skill: beginner
 lang: fr
 published: 2020-10-16
 ---
 
-Dans ce tutoriel [Waffle](https://ethereum-waffle.readthedocs.io), nous apprendrons comment créer un simple contrat intelligent "Hello world", en utilisant [hardhat](https://hardhat.org/) et [ethers.js](https://docs.ethers.io/v5/). Ensuite nous apprendrons conmment ajouter une nouvelle fonctionnalité à notre contrat intelligent et comment la tester avec « Waffle ».
+Dans ce tutoriel [Waffle](https://ethereum-waffle.readthedocs.io), nous apprendrons à configurer un projet simple de contrat intelligent « Hello world », en utilisant [Hardhat](https://hardhat.org/) et [ethers.js](https://docs.ethers.io/v5/). Ensuite, nous apprendrons comment ajouter une nouvelle fonctionnalité à notre contrat intelligent et comment la tester avec Waffle.
 
-Commençons par créer un nouveau projet :
+Commençons par créer un nouveau projet :
 
 ```bash
 yarn init
@@ -28,7 +30,7 @@ ou
 npm init
 ```
 
-et l'installation des paquets nécessaires :
+et installez les paquets requis :
 
 ```bash
 yarn add -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
@@ -40,7 +42,7 @@ ou
 npm install -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
 ```
 
-L'étape suivante est la création d'un projet hardhat basique en exécutant `npx hardhat`.
+L'étape suivante consiste à créer un projet d'exemple Hardhat en exécutant `npx hardhat`.
 
 ```bash
 888    888                      888 888               888
@@ -52,9 +54,9 @@ L'étape suivante est la création d'un projet hardhat basique en exécutant `np
 888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
 888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
 
-👷 Bienvenue dans Hardhat v2.0.3 👷‍
+👷 Welcome to Hardhat v2.0.3 👷‍
 
-? Que voulez vous faire ? …
+? What do you want to do? …
 ❯ Create a sample project
 Create an empty hardhat.config.js
 Quit
@@ -62,7 +64,7 @@ Quit
 
 Sélectionnez `Create a sample project`
 
-Notre structure de projet devrait ressembler à ceci :
+La structure de notre projet devrait ressembler à ceci :
 
 ```
 MyWaffleProject
@@ -73,15 +75,15 @@ MyWaffleProject
 │   └── sample-script.js
 ├── test
 │   └── sample-test.js
-├── .gitattributs
+├── .gitattributes
 ├── .gitignore
 ├── hardhat.config.js
 └── package.json
 ```
 
-### Maintenant, parlons de certains de ces fichiers : {#now-lets-talk}
+### Parlons maintenant de certains de ces fichiers : {#now-lets-talk}
 
-- Greeter.sol - notre contrat intelligent écrit en solidity ;
+- Greeter.sol - notre contrat intelligent écrit en Solidity ;
 
 ```solidity
 contract Greeter {
@@ -103,13 +105,13 @@ greeting = _greeting;
 }
 ```
 
-Notre contrat intelligent peut être divisé en trois parties :
+Notre contrat intelligent peut être divisé en trois parties :
 
-1. constructeur - où nous déclarons une variable de type string appelée `greeting`,
-2. function greet - une fonction qui retournera la valeur `greeting` lorsqu'elle est appelée,
-3. function setGreeting - une fonction qui nous permet de changer la valeur `greeting`.
+1. constructeur - où nous déclarons une variable de type `string` appelée `greeting`,
+2. fonction `greet` - une fonction qui renverra la valeur `greeting` lorsqu'elle est appelée,
+3. fonction `setGreeting` - une fonction qui nous permet de modifier la valeur de `greeting`.
 
-- sample-test.js - notre fichier de tests
+- sample-test.js - notre fichier de tests
 
 ```js
 describe("Greeter", function () {
@@ -126,34 +128,34 @@ describe("Greeter", function () {
 })
 ```
 
-### La prochaîne étape consiste à compiler notre contrat et à exécuter nos tests : {#compiling-and-testing}
+### L'étape suivante consiste à compiler notre contrat et à exécuter les tests : {#compiling-and-testing}
 
-Les tests Waffle utilisent Mocha (un framework de test) avec Chai (une bibliothèque d'assertions). Tout ce que vous avez à faire est d'exécuter `npx hardhat test` et d'attendre que le message suivant apparaisse.
+Les tests Waffle utilisent Mocha (un framework de test) avec Chai (une bibliothèque d'assertions). Il vous suffit d'exécuter `npx hardhat test` et d'attendre que le message suivant s'affiche.
 
 ```bash
-✓ Doit renvoyer le nouveau message de bienvenue une fois qu'il a changé
+✓ Should return the new greeting once it's changed
 ```
 
-### Tout semble bien pour l'instant, ajoutons une certaine complexité à notre projet <Emoji text=":slightly_smiling_face:" size={1}/> {#adding-complexity}
+### Tout semble parfait jusqu'à présent. Ajoutons un peu de complexité à notre projet <Emoji text=":slightly_smiling_face:" size={1}/> {#adding-complexity}
 
-Imaginez une situation où quelqu'un ajoute une chaîne vide comme un salut. Ce ne serait pas un accueil chaleureux, n'est-ce pas ?  
-Veillons à ce que cela ne se produise pas :
+Imaginez que quelqu'un ajoute une chaîne vide en guise de salut. Ce ne serait pas un salut très chaleureux, n'est-ce pas ?  
+Assurons-nous que cela ne se produise pas :
 
-Nous voulons utiliser la version de solidity `revert` lorsque quelqu'un passe une chaîne vide. Une bonne chose est que nous pouvons facilement tester cette fonctionnalité avec la correspondance chai de Waffle `to.be.revertedWith()`.
+Nous voulons utiliser la fonction `revert` de Solidity lorsque quelqu'un transmet une chaîne de caractères vide. Heureusement, nous pouvons facilement tester cette fonctionnalité avec le matcher Chai de Waffle `to.be.revertedWith()`.
 
 ```js
 it("Should revert when passing an empty string", async () => {
   const Greeter = await ethers.getContractFactory("Greeter")
   const greeter = await Greeter.deploy("Hello, world!")
 
-  wait greeter.deployed()
+  await greeter.deployed()
   await expect(greeter.setGreeting("")).to.be.revertedWith(
     "Greeting should not be empty"
   )
 })
 ```
 
-Il semblerait que notre nouveau test n'ait pas réussi :
+Il semblerait que notre nouveau test n'ait pas réussi :
 
 ```bash
 Deploying a Greeter with greeting: Hello, world!
@@ -168,13 +170,13 @@ Changing greeting from 'Hello, world!' to ''
   1 failing
 ```
 
-Implémentons cette fonctionnalité dans notre contrat intelligent :
+Implémentons cette fonctionnalité dans notre contrat intelligent :
 
 ```solidity
 require(bytes(_greeting).length > 0, "Greeting should not be empty");
 ```
 
-Maintenant, notre fonction setGreeting ressemble à ceci :
+Maintenant, notre fonction `setGreeting` ressemble à ceci :
 
 ```solidity
 function setGreeting(string memory _greeting) public {
@@ -184,7 +186,7 @@ greeting = _greeting;
 }
 ```
 
-Exécutons les tests à nouveau :
+Exécutons les tests à nouveau :
 
 ```bash
 ✓ Should return the new greeting once it's changed (1467ms)
@@ -197,6 +199,6 @@ Félicitations ! Vous y êtes arrivé :)
 
 ### Conclusion {#conclusion}
 
-Nous avons réalisé un projet simple avec Waffle, Hardhat et ethers.js. Nous avons appris comment mettre en place un projet, ajouter un test et implémenter de nouvelles fonctionnalités.
+Nous avons réalisé un projet simple avec Waffle, Hardhat et ethers.js. Nous avons appris à configurer un projet, à ajouter un test et à implémenter de nouvelles fonctionnalités.
 
-Pour plus d'excellents correspondants chai pour tester vos contrats intelligents, consultez la [documentation officielle de Waffle](https://ethereum-waffle.readthedocs.io/en/latest/matchers.html).
+Pour découvrir d'autres matchers Chai très utiles pour tester vos contrats intelligents, consultez la [documentation officielle de Waffle](https://ethereum-waffle.readthedocs.io/en/latest/matchers.html).
diff --git a/public/content/translations/fr/developers/tutorials/waffle-test-simple-smart-contract/index.md b/public/content/translations/fr/developers/tutorials/waffle-test-simple-smart-contract/index.md
index 13ee9082e20..f4e47509d28 100644
--- a/public/content/translations/fr/developers/tutorials/waffle-test-simple-smart-contract/index.md
+++ b/public/content/translations/fr/developers/tutorials/waffle-test-simple-smart-contract/index.md
@@ -1,12 +1,8 @@
 ---
-title: Test d'un contrat intelligent simple avec la bibliothèque Waffle
-description: Tutoriel pour débutants
+title: "Test d'un contrat intelligent simple avec la bibliothèque Waffle"
+description: "Tutoriel pour débutants"
 author: Ewa Kowalska
-tags:
-  - "contrats intelligents"
-  - "solidity"
-  - "Waffle"
-  - "test"
+tags: [ "contrats intelligents", "Solidity", "Waffle", "test" ]
 skill: beginner
 lang: fr
 published: 2021-02-26
@@ -15,33 +11,34 @@ published: 2021-02-26
 ## Dans ce tutoriel, vous apprendrez à {#in-this-tutorial-youll-learn-how-to}
 
 - Tester les modifications du solde du portefeuille
-- Tester l'émission d'événements avec les arguments spécifiés
-- Confirmer qu'une transaction a été annulée
+- Tester l'émission d'événements avec des arguments spécifiés
+- Affirmer qu'une transaction a été annulée
 
-## Hypothèses {#assumptions}
+## Prérequis {#assumptions}
 
 - Vous pouvez créer un nouveau projet JavaScript ou TypeScript
-- Vous avez une expérience de base en matière de tests JavaScript
-- Vous avez utilisé des gestionnaires de paquets comme yarn ou npm
-- Vous possédez des connaissances de base en matière de contrats intelligents et de Solidity
+- Vous avez une certaine expérience de base des tests en JavaScript
+- Vous avez déjà utilisé des gestionnaires de paquets comme yarn ou npm
+- Vous possédez des connaissances très élémentaires sur les contrats intelligents et Solidity
 
-## Premiers pas {#getting-started}
+## Mise en route {#getting-started}
 
-Le tutoriel décrit l'installation et l'exécution du test en utilisant yarn, mais il n'y a pas de problème si vous préférez npm - je fournirai les références appropriées à la documentation officielle de Waffle.[](https://ethereum-waffle.readthedocs.io/en/latest/index.html)
+Le tutoriel présente la configuration et l'exécution du test à l'aide de yarn, mais il n'y a aucun problème si vous préférez utiliser npm. Je vous fournirai les références appropriées dans la [documentation](https://ethereum-waffle.readthedocs.io/en/latest/index.html) officielle de Waffle.
 
-### Installer les dépendances {#install-dependencies}
+## Installer les dépendances {#install-dependencies}
 
-[Ajoutez](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation) dépendances ethereum-waffle et typescript aux dépendances de développement de votre projet.
+[Ajoutez](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation) les dépendances ethereum-waffle et typescript aux dépendances de développement de votre projet.
 
 ```bash
 yarn add --dev ethereum-waffle ts-node typescript @types/jest
 ```
 
-### Exemple de contrat intelligent {#example-smart-contract}
+## Exemple de contrat intelligent {#example-smart-contract}
 
-Au cours du tutoriel, nous allons travailler sur un exemple de contrat intelligent simple - EtherSplitter. Il ne fait pas grand-chose à part permettre à quelqu'un d'envoyer des wei et de les répartir équitablement entre deux destinataires prédéfinis. La fonction de séparation nécessite que le nombre de wei soit pair, sinon elle s'inverse. Pour les deux destinataires, il effectue un transfert de wei suivi de l'émission de l'événement Transfert.
+Pendant le tutoriel, nous travaillerons sur un exemple de contrat intelligent simple : EtherSplitter. Il ne fait pas grand-chose, à part permettre à n'importe qui d'envoyer des wei et de les répartir équitablement entre deux destinataires prédéfinis.
+La fonction de répartition exige que le nombre de wei soit pair, sinon la transaction sera annulée. Pour les deux destinataires, il effectue un transfert de wei suivi de l'émission de l'événement Transfert.
 
-Placez le fragment de code EtherSplitter dans `src/EtherSplitter.sol`.
+Placez l'extrait de code d'EtherSplitter dans `src/EtherSplitter.sol`.
 
 ```solidity
 pragma solidity ^0.6.0;
@@ -58,7 +55,7 @@ contract EtherSplitter {
     }
 
     function split() public payable {
-        require(msg.value % 2 == 0, 'Uneven wei amount not allowed');
+        require(msg.value % 2 == 0, 'Montant de wei impair non autorisé');
         receiver1.transfer(msg.value / 2);
         emit Transfer(msg.sender, receiver1, msg.value / 2);
         receiver2.transfer(msg.value / 2);
@@ -67,7 +64,7 @@ contract EtherSplitter {
 }
 ```
 
-### Compiler le contrat {#compile-the-contract}
+## Compiler le contrat {#compile-the-contract}
 
 Pour [compiler](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#compiling-the-contract) le contrat, ajoutez l'entrée suivante au fichier package.json :
 
@@ -77,7 +74,7 @@ Pour [compiler](https://ethereum-waffle.readthedocs.io/en/latest/getting-started
   }
 ```
 
-Ensuite, créez un fichier de configuration avec Waffle, dans le répertoire principal des projets, - `waffle.json` - puis collez-y la configuration suivante :
+Ensuite, créez le fichier de configuration Waffle dans le répertoire racine du projet, `waffle.json`, puis collez-y la configuration suivante :
 
 ```json
 {
@@ -88,11 +85,11 @@ Ensuite, créez un fichier de configuration avec Waffle, dans le répertoire pri
 }
 ```
 
-Exécutez `yarn build`. Cela fera apparaître le dossier `build` avec le contrat compilé EtherSplitter au format JSON.
+Exécutez `yarn build`. En conséquence, le répertoire `build` apparaîtra avec le contrat EtherSplitter compilé au format JSON.
 
-### Configuration du test {#test-setup}
+## Configuration du test {#test-setup}
 
-Tester avec Waffle nécessite d'utiliser des correspondances Chai et Mocha, vous devez donc [les ajouter](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests) à votre projet. Lancez la mise à jour de votre paquet package.json, et ajoutez le `texte`d'entrée, dans la partie modèle:
+Les tests avec Waffle nécessitent l'utilisation des matchers Chai et de Mocha. Vous devez donc les [ajouter](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests) à votre projet. Mettez à jour votre fichier package.json et ajoutez l'entrée `test` dans la partie scripts :
 
 ```json
 "scripts": {
@@ -101,11 +98,12 @@ Tester avec Waffle nécessite d'utiliser des correspondances Chai et Mocha, vous
   }
 ```
 
-Si vous voulez [faire](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#running-tests) vos propres tests, exécutez juste le `yarn test` .
+Si vous voulez [exécuter](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#running-tests) vos tests, il suffit de lancer `yarn test`.
 
-## Tests {#testing}
+## Tester {#testing}
 
-Maintenant, créez le dossier `test` et créez le nouveau fichier `test\EtherSplitter.test.ts`. Copiez le fragment ci-dessous et collez-le dans notre fichier de test.
+Créez maintenant le répertoire `test` et le nouveau fichier `test\EtherSplitter.test.ts`.
+Copiez l'extrait de code ci-dessous et collez-le dans notre fichier de test.
 
 ```ts
 import { expect, use } from "chai"
@@ -126,17 +124,18 @@ describe("Ether Splitter", () => {
     ])
   })
 
-  // add the tests here
+  // ajoutez les tests ici
 })
 ```
 
-Quelques mots avant de commencer. Le fournisseur de services, `MockProvider`, propose une version fictive de la blockchain. Il fournit également des portefeuilles fictifs, qui serviront de base pour tester le contrat intelligent EtherSplitter. Nous pouvons obtenir jusqu'à dix portefeuilles en appelant la méthode `getWallets()` sur le fournisseur. Dans l'exemple, nous avons trois portefeuilles - pour l'expéditeur et pour deux destinataires.
+Quelques mots avant de commencer.
+Le `MockProvider` propose une version simulée de la blockchain. Il fournit également des portefeuilles simulés qui nous serviront pour tester le contrat EtherSplitter. Nous pouvons obtenir jusqu'à dix portefeuilles en appelant la méthode `getWallets()` sur le fournisseur. Dans l'exemple, nous obtenons trois portefeuilles : un pour l'expéditeur et deux pour les destinataires.
 
-Ensuite, nous déclarons une variable appelée « splitter » - c'est notre contrat fictif EtherSpliter. Il est créé avant chaque exécution d'un test unique par la méthode `deployContract`. Cette méthode simule le déploiement d'un contrat à partir du portefeuille transmis en tant que premier paramètre (le portefeuille de l'expéditeur dans notre cas). Le deuxième paramètre est l'ABI et le bytecode du contrat testé - nous transmettons le fichier json du contrat EtherSplitter compilé à partir du répertoire `build`. Le troisième paramètre est un tableau contenant les arguments du constructeur du contrat qui, dans notre cas, sont les deux adresses des destinataires.
+Ensuite, nous déclarons une variable appelée « splitter ». C'est notre contrat EtherSplitter simulé. Il est créé avant chaque exécution d'un test unique par la méthode `deployContract`. Cette méthode simule le déploiement d'un contrat à partir du portefeuille passé comme premier paramètre (le portefeuille de l'expéditeur dans notre cas). Le deuxième paramètre est l'ABI et le bytecode du contrat testé. Nous y passons le fichier JSON du contrat EtherSplitter compilé à partir du répertoire `build`. Le troisième paramètre est un tableau avec les arguments du constructeur du contrat qui, dans notre cas, sont les deux adresses des destinataires.
 
-### changeBalances {#changebalances}
+## changeBalances {#changebalances}
 
-Tout d'abord, nous vérifierons si la méthode fractionnée modifie réellement les soldes des portefeuilles des destinataires. Si nous divisons 50 wei du compte des expéditeurs, nous nous attendons à ce que les soldes des deux destinataires augmentent de 25 wei. Nous utiliserons la correspondance `changeBalances` de Waffle:
+Tout d'abord, nous vérifierons si la méthode de répartition modifie réellement les soldes des portefeuilles des destinataires. Si nous divisons 50 wei du compte de l'expéditeur, nous nous attendons à ce que les soldes des deux destinataires augmentent de 25 wei. Nous utiliserons le matcher `changeBalances` de Waffle :
 
 ```ts
 it("Changes accounts balances", async () => {
@@ -147,7 +146,8 @@ it("Changes accounts balances", async () => {
 })
 ```
 
-Comme premier paramètre de la correspondance, nous transmettons un tableau de portefeuilles de destinataires, et comme deuxième, un tableau d'augmentations attendues sur les comptes correspondants. Si nous voulions vérifier le solde d'un portefeuille spécifique, nous pourrions également utiliser la correspondance `changeBalance` , qui ne nécessite pas de transmettre des tableaux, comme dans l'exemple ci-dessous:
+Comme premier paramètre du matcher, nous passons un tableau des portefeuilles des destinataires, et comme second, un tableau des augmentations attendues sur les comptes correspondants.
+Si nous voulions vérifier le solde d'un portefeuille spécifique, nous pourrions également utiliser le matcher `changeBalance`, qui ne nécessite pas de passer des tableaux, comme dans l'exemple ci-dessous :
 
 ```ts
 it("Changes account balance", async () => {
@@ -158,42 +158,42 @@ it("Changes account balance", async () => {
 })
 ```
 
-Notez que dans les deux cas de `changeBalance` et `changeBalances`, nous transmettons la fonction de séparation comme callback car le correspondant a besoin d'accéder à l'état des balances avant et après l'appel.
+Notez que dans les deux cas de `changeBalance` et `changeBalances`, nous passons la fonction de répartition en tant que rappel, car le matcher doit accéder à l'état des soldes avant et après l'appel.
 
-Nous allons ensuite déterminer si l'événement Transfert a été émis après chaque transfert de wei. Nous allons passer à une autre correspondance de Waffle :
+Ensuite, nous allons tester si l'événement Transfer a été émis après chaque transfert de wei. Nous allons nous tourner vers un autre matcher de Waffle :
 
-### Emit {#emit}
+## Émission {#emit}
 
 ```ts
-it("Emits event on the transfer to the first receiver", async () => {
+it("Émet un événement lors du transfert vers le premier destinataire", async () => {
   await expect(splitter.split({ value: 50 }))
     .to.emit(splitter, "Transfer")
     .withArgs(sender.address, receiver1.address, 25)
 })
 
-it("Emits event on the transfer to the second receiver", async () => {
+it("Émet un événement lors du transfert vers le second destinataire", async () => {
   await expect(splitter.split({ value: 50 }))
     .to.emit(splitter, "Transfer")
     .withArgs(sender.address, receiver2.address, 25)
 })
 ```
 
-La correspondance `emit` nous permet de vérifier si un contrat a émis un événement en appelant une méthode. En tant que paramètres pour la corrrespondance `emit`, nous fournissons le contrat fictif que nous prévoyons pour émettre l'événement, ainsi que le nom de cet événement. Dans notre cas, le contrat fictif est `splitter` et le nom de l'événement `Transfer`. Nous pouvons également vérifier les valeurs précises des arguments avec lesquels l'événement a été émis - nous transmettons autant d'arguments au `withArgs` correspondant, comme le prévoit notre déclaration d'événement. Dans le cas du contrat EtherSpliter, nous passons les adresses de l'expéditeur et du destinataire avec le montant en wei transféré.
+Le matcher `emit` nous permet de vérifier si un contrat a émis un événement en appelant une méthode. En tant que paramètres du matcher `emit`, nous fournissons le contrat simulé qui, selon nos prévisions, émettra l'événement, ainsi que le nom de cet événement. Dans notre cas, le contrat simulé est `splitter` et le nom de l'événement est `Transfer`. Nous pouvons également vérifier les valeurs précises des arguments avec lesquels l'événement a été émis. Nous passons autant d'arguments au matcher `withArgs` que notre déclaration d'événement en attend. Dans le cas du contrat EtherSplitter, nous passons les adresses de l'expéditeur et du destinataire ainsi que le montant en wei transféré.
 
-### revertedWith {#revertedwith}
+## revertedWith {#revertedwith}
 
-Comme dernier exemple, nous allons vérifier si la transaction a été annulée en cas de nombre impair de wei. Nous allons utiliser la correspondance `revertedWith` :
+Comme dernier exemple, nous vérifierons si la transaction a été annulée en cas de nombre impair de wei. Nous utiliserons le matcher `revertedWith` :
 
 ```ts
 it("Reverts when Vei amount uneven", async () => {
   await expect(splitter.split({ value: 51 })).to.be.revertedWith(
-    "Uneven wei amount not allowed"
+    "Montant de wei impair non autorisé"
   )
 })
 ```
 
-Le test, s'il est accepté, nous assurera que la transaction a bien été annulée. Cependant, il doit également y avoir une correspondance exacte entre les messages que nous avons passés dans la déclaration `require` et le message attendu dans `revertedWith`. Si nous revenons au code du contrat EtherSpliter, dans la déclaration `require` pour le montant wei, nous fournissons le message: "Uneven wei amount not allowed". Cela correspond au message que nous attendons dans notre test. Si elles n'étaient pas égales, le test échouerait.
+Le test, s'il est concluant, nous assurera que la transaction a bien été annulée. Cependant, il doit également y avoir une correspondance exacte entre les messages que nous avons passés dans l'instruction `require` et le message que nous attendons dans `revertedWith`. Si nous retournons au code du contrat EtherSplitter, dans l'instruction `require` pour le montant en wei, nous fournissons le message : « Montant de wei impair non autorisé ». Cela correspond au message que nous attendons dans notre test. S'ils n'étaient pas égaux, le test échouerait.
 
 ## Félicitations ! {#congratulations}
 
-Vous avez fait votre premier (grand) pas vers les tests des contrats intelligents avec Waffle !
+Vous avez fait votre premier grand pas vers le test de contrats intelligents avec Waffle !
diff --git a/public/content/translations/fr/developers/tutorials/yellow-paper-evm/index.md b/public/content/translations/fr/developers/tutorials/yellow-paper-evm/index.md
index 6e5416116c8..6fc43109ff1 100644
--- a/public/content/translations/fr/developers/tutorials/yellow-paper-evm/index.md
+++ b/public/content/translations/fr/developers/tutorials/yellow-paper-evm/index.md
@@ -1,207 +1,220 @@
 ---
-title: Comprendre le livre Jaune des spécifications d'EVM
-description: Comprendre la partie du Livre Jaune, les spécifications formelles pour Ethereum, qui explique la machine virtuelle Ethereum (EVM).
+title: "Comprendre les spécifications de l'EVM du Livre jaune"
+description: "Comprendre la partie du Livre jaune, les spécifications formelles pour Ethereum, qui explique la machine virtuelle Ethereum (EVM)."
 author: "qbzzt"
-tags:
-  - "evm"
+tags: [ "evm" ]
 skill: intermediate
 lang: fr
 published: 2022-05-15
 ---
 
-[Le Livre Jaune](https://ethereum.github.io/yellowpaper/paper.pdf) est la spécification formelle d'Ethereum. Sauf là où il a été modifié par [le processus d'EIP](/eips/), il contient la description exacte du fonctionnement de tout. Il est rédigé sous forme de document mathématique, qui inclut une terminologie que les programmeurs pourraient ne pas connaître. Dans ce document, vous apprendrez comment le lire, et par extension, d'autres documents mathématiques liés.
+[Le Livre jaune](https://ethereum.github.io/yellowpaper/paper.pdf) est la spécification formelle pour Ethereum. Sauf là où il a été modifié par [le processus EIP](/eips/), il contient la description exacte du fonctionnement de tout. Il est rédigé sous forme de document mathématique, qui inclut une terminologie que les programmeurs pourraient ne pas connaître. Dans ce document, vous apprendrez comment le lire et, par extension, d'autres documents mathématiques connexes.
 
-## Quel Livre Jaune ? {#which-yellow-paper}
+## Quel Livre jaune ? {#which-yellow-paper}
 
-Comme presque tout le reste dans Ethereum, le Livre Jaune évolue avec le temps. Afin de pouvoir se référer à une version spécifique, j'ai [téléchargé la version actuelle au moment de la rédaction](yellow-paper-berlin.pdf). Les numéros de section, de page et d'équation que j'utilise se référeront à cette version. Il est recommandé de l'avoir ouvert dans une autre fenêtre pendant la lecture de ce document.
+Comme presque tout le reste dans Ethereum, le Livre jaune évolue avec le temps. Afin de pouvoir se référer à une version spécifique, j'ai téléversé [la version actuelle au moment de la rédaction](yellow-paper-berlin.pdf). Les numéros de section, de page et d'équation que j'utilise se référeront à cette version. Il est recommandé de l'avoir ouvert dans une autre fenêtre pendant la lecture de ce document.
 
 ### Pourquoi l'EVM ? {#why-the-evm}
 
-Le livre jaune original a été rédigé dès le début du développement d'Ethereum. Il décrit le mécanisme de consensus original basé sur la preuve de travail qui était initialement utilisé pour sécuriser le réseau. Cependant, Ethereum a abandonné la preuve de travail et a commencé à utiliser un consensus basé sur la preuve d'enjeu en septembre 2022. Ce tutoriel se concentrera sur les parties du livre jaune définissant la Machine Virtuelle Ethereum. L'EVM n'a pas été modifié par la transition vers la preuve d'enjeu (à l'exception de la valeur de réponse de l'opcode DIFFICULTY).
+Le Livre jaune original a été rédigé au tout début du développement d'Ethereum. Il décrit le mécanisme de consensus original basé sur la preuve de travail qui était initialement utilisé pour sécuriser le réseau. Cependant, Ethereum a abandonné la preuve de travail et a commencé à utiliser un consensus basé sur la preuve d'enjeu en septembre 2022. Ce tutoriel se concentrera sur les parties du Livre jaune qui définissent la machine virtuelle Ethereum. L'EVM est resté inchangé suite à la transition vers la preuve d'enjeu (à l'exception de la valeur de retour de l'opcode DIFFICULTY).
 
 ## 9 Modèle d'exécution {#9-execution-model}
 
-Cette section (p. 12-14) comprend la majeure partie de la définition de l'EVM.
+Cette section (p. 12-14) inclut la majeure partie de la définition de l'EVM.
 
-Le terme _état du système_ comprend tout ce que vous devez savoir sur le système pour le faire fonctionner. Dans un ordinateur classique, cela signifie la mémoire, le contenu des registres, etc.
+Le terme _état du système_ inclut tout ce que vous devez savoir sur le système pour le faire fonctionner. Dans un ordinateur typique, cela signifie la mémoire, le contenu des registres, etc.
 
-Une [machine de Turing](https://en.wikipedia.org/wiki/Turing_machine) est un modèle de calcul. En substance, c'est une version simplifiée d'un ordinateur, qui s’est avéré avoir la même capacité d'exécuter des calculs qu'un ordinateur normal (tout ce qu'un ordinateur peut calculer, une machine de Turing peut le calculer et vice versa). Ce modèle facilite la preuve de divers théorèmes sur ce qui est et n'est pas calculable.
+Une [machine de Turing](https://en.wikipedia.org/wiki/Turing_machine) est un modèle de calcul. Il s'agit essentiellement d'une version simplifiée d'un ordinateur, dont il est prouvé qu'elle a la même capacité à effectuer des calculs qu'un ordinateur normal (tout ce qu'un ordinateur peut calculer, une machine de Turing peut le calculer et vice-versa). Ce modèle facilite la preuve de divers théorèmes sur ce qui est et ce qui n'est pas calculable.
 
-Le terme [Turing-complet](https://en.wikipedia.org/wiki/Turing_completeness) désigne un ordinateur qui peut exécuter les mêmes calculs qu'une machine de Turing. Les machines de Turing peuvent entrer dans des boucles infinies, et l'EVM ne le peut pas car elle manquerait de gaz, elle est donc seulement quasi-Turing-complète.
+Le terme [Turing-complet](https://en.wikipedia.org/wiki/Turing_completeness) désigne un ordinateur qui peut effectuer les mêmes calculs qu'une machine de Turing. Les machines de Turing peuvent entrer dans des boucles infinies, ce que l'EVM ne peut pas faire, car il serait à court de gaz. Il est donc seulement quasi-Turing-complet.
 
-## 9.1 Les bases {#91-basics}
+## 9.1 Notions de base {#91-basics}
 
-Cette section présente les bases de l'EVM et comment il se compare à d'autres modèles computationnels.
+Cette section présente les bases de l'EVM et sa comparaison avec d'autres modèles de calcul.
 
-Une [machine pile](https://en.wikipedia.org/wiki/Stack_machine) est un ordinateur qui stocke les données intermédiaires non pas dans des registres, mais dans une [**pile**](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)). C'est l'architecture privilégiée pour les machines virtuelles car elle est facile à mettre en œuvre, ce qui signifie que les bugs et les vulnérabilités de sécurité sont beaucoup moins probables. La mémoire dans la pile est divisée en mots de 256 bits. Ce choix a été fait car il est pratique pour les opérations cryptographiques centrales d'Ethereum telles que le hachage Keccak-256 et les calculs de courbes elliptiques. La taille maximale de la pile est de 1024 octets. Lorsque les opcodes sont exécutés, ils prennent généralement leurs paramètres depuis la pile. Il existe des opcodes spécifiquement pour réorganiser les éléments dans la pile, tels que `POP` (retire l'élément du haut de la pile), `DUP_N` (duplique le N-ième élément dans la pile), etc.
+Une [machine à pile](https://en.wikipedia.org/wiki/Stack_machine) est un ordinateur qui stocke des données intermédiaires non pas dans des registres, mais dans une [**pile**](https://en.wikipedia.org/wiki/Stack_\(abstract_data_type\)). C'est l'architecture privilégiée pour les machines virtuelles, car elle est facile à mettre en œuvre, ce qui signifie que les bogues et les vulnérabilités de sécurité sont beaucoup moins probables. La mémoire de la pile est divisée en mots de 256 bits. Ce choix a été fait, car il est pratique pour les opérations cryptographiques de base d'Ethereum telles que le hachage Keccak-256 et les calculs sur les courbes elliptiques. La taille maximale de la pile est de 1024 éléments (1024 x 256 bits). Lorsque des opcodes sont exécutés, ils obtiennent généralement leurs paramètres depuis la pile. Il existe des opcodes spécifiques pour réorganiser les éléments dans la pile tels que `POP` (retire un élément du sommet de la pile), `DUP_N` (duplique le Nième élément de la pile), etc.
 
-L'EVM possède également un espace volatile appelé **mémoire**, qui est utilisé pour stocker des données pendant l'exécution. Cette mémoire est organisée en mots de 32 octets. Tous les emplacements mémoire sont initialisés à zéro. Si vous exécutez ce code [Yul](https://docs.soliditylang.org/en/latest/yul.html) pour ajouter un mot à la mémoire, il remplira 32 octets de mémoire en remplissant l'espace vide du mot avec des zéros, c'est-à-dire qu'il crée un mot - avec des zéros aux emplacements 0-29, 0x60 à 30, et 0xA7 à 31.
+L'EVM dispose également d'un espace volatile appelé **mémoire** qui est utilisé pour stocker des données pendant l'exécution. Cette mémoire est organisée en mots de 32 octets. Tous les emplacements mémoire sont initialisés à zéro. Si vous exécutez ce code [Yul](https://docs.soliditylang.org/en/latest/yul.html) pour ajouter un mot à la mémoire, il remplira 32 octets de mémoire en complétant l'espace vide du mot avec des zéros, c'est-à-dire qu'il crée un mot avec des zéros aux emplacements 0-29, 0x60 à l'emplacement 30 et 0xA7 à l'emplacement 31.
 
 ```yul
 mstore(0, 0x60A7)
 ```
 
-`mstore` est l'un des trois opcodes que l'EVM fournit pour interagir avec la mémoire - il charge un mot en mémoire. Les deux autres sont `mstore8`, qui charge un seul octet en mémoire, et `mload`, qui déplace un mot de la mémoire à la pile.
+`mstore` est l'un des trois opcodes que l'EVM fournit pour interagir avec la mémoire. Il charge un mot en mémoire. Les deux autres sont `mstore8` qui charge un seul octet en mémoire, et `mload` qui déplace un mot de la mémoire vers la pile.
 
-L'EVM a également un modèle de **stockage** non volatile séparé qui est maintenu dans le système - cette mémoire est organisée en tableaux de mots (par opposition aux tableaux d'octets adressables par mots dans la pile). Ce stockage est l'endroit où les contrats conservent des données persistantes - un contrat ne peut interagir qu'avec son propre stockage. Le stockage est organisé en mappages clé-valeur.
+L'EVM dispose également d'un modèle de **stockage** non volatile distinct qui est maintenu dans le cadre de l'état du système. Cette mémoire est organisée en tableaux de mots (par opposition aux tableaux d'octets adressables par mot dans la pile). Ce stockage est l'endroit où les contrats conservent les données persistantes. Un contrat ne peut interagir qu'avec son propre stockage. Le stockage est organisé en correspondances clé-valeur.
 
-Bien qu'il ne soit pas mentionné dans cette section du Livre Jaune, il est également utile de savoir qu'il existe un quatrième type de mémoire. **Calldata** est une mémoire en lecture seule adressable par octets utilisée pour stocker la valeur passée avec le paramètre de `données` d'une transaction. L'EVM dispose d'opcodes spécifiques pour gérer `calldata`. `calldatasize` renvoie la taille des données. `calldataload` charge les données dans la pile. `calldatacopy` copie les données en mémoire.
+Bien que cela ne soit pas mentionné dans cette section du Livre jaune, il est également utile de savoir qu'il existe un quatrième type de mémoire. **Calldata** est une mémoire en lecture seule adressable par octets, utilisée pour stocker la valeur transmise avec le paramètre `data` d'une transaction. L'EVM a des opcodes spécifiques pour la gestion des `calldata`. `calldatasize` renvoie la taille des données. `calldataload` charge les données dans la pile. `calldatacopy` copie les données en mémoire.
 
-L'architecture standard [Von Neumann](https://en.wikipedia.org/wiki/Von_Neumann_architecture) stocke le code et les données dans la même mémoire. L'EVM ne suit pas cette norme pour des raisons de sécurité - le partage de mémoire volatile rend possible la modification du code programme. Au lieu de cela, le code est sauvegardé dans le stockage.
+L'[architecture Von Neumann](https://en.wikipedia.org/wiki/Von_Neumann_architecture) standard stocke le code et les données dans la même mémoire. L'EVM ne suit pas cette norme pour des raisons de sécurité. Le partage de la mémoire volatile permet de modifier le code du programme. Au lieu de cela, le code est enregistré dans le stockage.
 
-Il n'y a que deux cas où le code est exécuté à partir de la mémoire :
+Il n'y a que deux cas dans lesquels le code est exécuté à partir de la mémoire :
 
-- Lorsqu'un contrat crée un autre contrat (en utilisant [`CREATE`](https://www.evm.codes/#f0) ou [`CREATE2`](https://www.evm.codes/#f5)), le code pour le constructeur de contrat provient de la mémoire.
-- Lors de la création d'un contrat, le code du constructeur s'exécute puis renvoie avec le code du contrat réel, également à partir de la mémoire.
+- Lorsqu'un contrat crée un autre contrat (à l'aide de [`CREATE`](https://www.evm.codes/#f0) ou [`CREATE2`](https://www.evm.codes/#f5)), le code du constructeur de contrat provient de la mémoire.
+- Lors de la création de _n'importe quel_ contrat, le code du constructeur s'exécute, puis renvoie le code du contrat réel, également depuis la mémoire.
 
-Le terme exécution exceptionnelle signifie une exception qui provoque l'arrêt de l'exécution du contrat en cours.
+L'expression « exécution exceptionnelle » désigne une exception qui provoque l'arrêt de l'exécution du contrat en cours.
 
 ## 9.2 Aperçu des frais {#92-fees-overview}
 
-Cette section explique comment les frais de gaz sont calculés. Il y a trois coûts :
+Cette section explique comment les frais de gaz sont calculés. Il existe trois coûts :
 
-### Coût des opcodes {#opcode-cost}
+### Coût de l'opcode {#opcode-cost}
 
-Le coût inhérent à l'opcode spécifique. Pour obtenir cette valeur, trouvez le coût de l'opcode dans l'Annexe H (p. 28, sous l'équation (327)), et trouvez le coût dans l'équation (324). Cela vous donne une fonction de coût, qui dans la plupart des cas utilise des paramètres de l'Annexe G (p. 27).
+Le coût inhérent de l'opcode spécifique. Pour obtenir cette valeur, trouvez le groupe de coût de l'opcode dans l'annexe H (p. 28, sous l'équation (327)), puis trouvez le groupe de coût dans l'équation (324). Cela vous donne une fonction de coût qui, dans la plupart des cas, utilise les paramètres de l'annexe G (p. 27).
 
-Par exemple, l'opcode [`CALLDATACOPY`](https://www.evm.codes/#37) fait partie du groupe _W<sub>copy</sub>_. Le coût de l'opcode pour ce groupe est _G<sub>verylow</sub>+G<sub>copy</sub>×⌈μ<sub>s</sub>[2]÷32⌉_. En regardant l'Annexe G, nous voyons que les deux constantes sont 3, ce qui nous donne _3+3×⌈μ<sub>s</sub>[2]÷32⌉_.
+Par exemple, l'opcode [`CALLDATACOPY`](https://www.evm.codes/#37) est un membre du groupe _W<sub>copy</sub>_. Le coût de l'opcode pour ce groupe est _G<sub>verylow</sub>+G<sub>copy</sub>×⌈μ<sub>s</sub>[2]÷32⌉_. En regardant l'annexe G, nous voyons que les deux constantes sont 3, ce qui nous donne _3+3×⌈μ<sub>s</sub>[2]÷32⌉_.
 
-Nous devons encore décrypter l'expression _⌈μ<sub>s</sub>[2]÷32⌉_. La partie la plus externe, _⌈ \<value\> ⌉_, est la fonction plafond, une fonction qui, étant donnée une valeur, retourne le plus petit entier qui n'est pas inférieur à cette valeur. Par exemple, _⌈2.5⌉ = ⌈3⌉ = 3_. La partie interne est _μ<sub>s</sub>[2]÷32_. En consultant la section 3 (Conventions) à la p. 3, _μ_ représente l'état de la machine. L'état de la machine est défini dans la section 9.4.1 à la p. 13. Selon cette section, l'un des paramètres de l'état de la machine est _s_ pour la pile. En regroupant tout cela, il semble que _μ<sub>s</sub>[2]_ soit l'emplacement n°2 dans la pile. En examinant [l'opcode](https://www.evm.codes/#37), l'emplacement n°2 dans la pile est la taille des données en octets. En regardant les autres opcodes du groupe W<sub>copy</sub>, comme [`CODECOPY`](https://www.evm.codes/#39) et [`RETURNDATACOPY`](https://www.evm.codes/#3e), ils ont également une taille de données au même endroit. Ainsi, _⌈μ<sub>s</sub>[2]÷32⌉_ représente le nombre de mots de 32 octets nécessaires pour stocker les données copiées. En résumé, le coût inhérent de [`CALLDATACOPY`](https://www.evm.codes/#37) est de 3 gas plus 3 par mot de données copiées.
+Nous devons encore déchiffrer l'expression _⌈μ<sub>s</sub>[2]÷32⌉_. La partie la plus externe, _⌈ \<valeur\> ⌉_, est la fonction plafond, une fonction qui, pour une valeur donnée, renvoie le plus petit entier qui n'est pas inférieur à la valeur. Par exemple, _⌈2.5⌉ = ⌈3⌉ = 3_. La partie intérieure est _μ<sub>s</sub>[2]÷32_. En regardant la section 3 (Conventions) à la p. 3, _μ_ est l'état de la machine. L'état de la machine est défini dans la section 9.4.1 à la p. 13. Selon cette section, l'un des paramètres d'état de la machine est _s_ pour la pile. En rassemblant tous ces éléments, il semble que _μ<sub>s</sub>[2]_ soit l'emplacement n°2 dans la pile. En regardant [l'opcode](https://www.evm.codes/#37), l'emplacement n°2 de la pile correspond à la taille des données en octets. Si l'on regarde les autres opcodes du groupe W<sub>copy</sub>, [`CODECOPY`](https://www.evm.codes/#39) et [`RETURNDATACOPY`](https://www.evm.codes/#3e), ils ont aussi une taille de données au même emplacement. Donc _⌈μ<sub>s</sub>[2]÷32⌉_ est le nombre de mots de 32 octets nécessaires pour stocker les données en cours de copie. En résumé, le coût inhérent de [`CALLDATACOPY`](https://www.evm.codes/#37) est de 3 gaz plus 3 par mot de données copié.
 
 ### Coût d'exécution {#running-cost}
 
-Il s'agit du coût d'exécution du code que nous appelons.
+Le coût d'exécution du code que nous appelons.
 
-- Dans le cas de [`CREATE`](https://www.evm.codes/#f0) et [`CREATE2`](https://www.evm.codes/#f5), il s'agit du constructeur du nouveau contrat.
-- Dans le cas de [`CALL`](https://www.evm.codes/#f1), [`CALLCODE`](https://www.evm.codes/#f2), [`STATICCALL`](https://www.evm.codes/#fa), ou [`DELEGATECALL`](https://www.evm.codes/#f4), il s'agit du contrat que nous appelons.
+- Dans le cas de [`CREATE`](https://www.evm.codes/#f0) et [`CREATE2`](https://www.evm.codes/#f5), le constructeur pour le nouveau contrat.
+- Dans le cas de [`CALL`](https://www.evm.codes/#f1), [`CALLCODE`](https://www.evm.codes/#f2), [`STATICCALL`](https://www.evm.codes/#fa) ou [`DELEGATECALL`](https://www.evm.codes/#f4), le contrat que nous appelons.
 
 ### Coût d'expansion de la mémoire {#expanding-memory-cost}
 
-Il s'agit du coût de l'expansion de la mémoire (si nécessaire).
+Le coût de l'expansion de la mémoire (si nécessaire).
 
-Dans l'équation 324, cette valeur est notée _C<sub>mem</sub>(μ<sub>i</sub>')-C<sub>mem</sub>(μ<sub>i</sub>)_. En consultant à nouveau la section 9.4.1, nous voyons que _μ<sub>i</sub>_ représente le nombre de mots en mémoire. Ainsi, _μ<sub>i</sub>_ est le nombre de mots en mémoire avant le opcode et _μ<sub>i</sub>'_ est le nombre de mots en mémoire après l'opcode.
+Dans l'équation 324, cette valeur est écrite comme suit : _C<sub>mem</sub>(μ<sub>i</sub>')-C<sub>mem</sub>(μ<sub>i</sub>)_. En examinant à nouveau la section 9.4.1, nous voyons que _μ<sub>i</sub>_ est le nombre de mots en mémoire. Ainsi, _μ<sub>i</sub>_ est le nombre de mots en mémoire avant l'opcode et _μ<sub>i</sub>'_ est le nombre de mots en mémoire après l'opcode.
 
-La fonction _C<sub>mem</sub>_ est définie dans l'équation 326 : _C<sub>mem</sub>(a) = G<sub>memory</sub> × a + ⌊a<sup>2</sup> ÷ 512⌋_. _⌊x⌋_ est la fonction plancher, une fonction qui, étant donné une valeur, retourne le plus grand entier qui n'est toujours pas supérieur à cette valeur. Par exemple, _⌊2.5⌋ = ⌊2⌋ = 2_. Lorsque _a < √512_, _a<sup>2</sup> < 512_, et le résultat de la fonction plancher est zéro. Ainsi, pour les 22 premiers mots (704 octets), le coût augmente linéairement avec le nombre de mots mémoire requis. Au-delà de ce point, _⌊a<sup>2</sup> ÷ 512⌋_ est positif. Lorsque la mémoire requise est suffisamment élevée, le coût en gas est proportionnel au carré de la quantité de mémoire.
+La fonction _C<sub>mem</sub>_ est définie dans l'équation 326 : _C<sub>mem</sub>(a) = G<sub>memory</sub> × a + ⌊a<sup>2</sup> ÷ 512⌋_. _⌊x⌋_ est la fonction plancher, une fonction qui, pour une valeur donnée, renvoie le plus grand entier qui n'est pas supérieur à la valeur. Par exemple, _⌊2.5⌋ = ⌊2⌋ = 2._ Lorsque _a < √512_, _a<sup>2</sup> < 512_, et le résultat de la fonction plancher est zéro. Ainsi, pour les 22 premiers mots (704 octets), le coût augmente de façon linéaire avec le nombre de mots de mémoire requis. Au-delà de ce point, _⌊a<sup>2</sup> ÷ 512⌋_ est positif. Lorsque la mémoire requise est suffisamment élevée, le coût en gaz est proportionnel au carré de la quantité de mémoire.
 
-**Note** : ces facteurs n'influencent que le coût en gas _inhérent_ - cela ne prend pas en compte le marché des frais ou les pourboires aux validateurs qui déterminent combien un utilisateur final doit payer - il s'agit simplement du coût brut d'exécution d'une opération particulière sur l'EVM.
+**Remarque** : ces facteurs n'influencent que le coût en gaz _inhérent_. Ils ne tiennent pas compte du marché des frais ni des pourboires versés aux validateurs qui déterminent le montant qu'un utilisateur final doit payer. Il s'agit simplement du coût brut de l'exécution d'une opération particulière sur l'EVM.
 
-[Plus d'information sur le gaz](/developers/docs/gas/).
+[En savoir plus sur le gaz](/developers/docs/gas/).
 
 ## 9.3 Environnement d'exécution {#93-execution-env}
 
-L'environnement d'exécution est un tuple, _I_, qui inclut des informations qui ne font pas partie de l'état de la blockchain ou de l'EVM.
-
-| Paramètre       | Opcode pour accéder aux données                                                                                          | Code Solidity pour accéder aux données   |
-| --------------- | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------- |
-| _I<sub>a</sub>_ | [`ADDRESS`](https://www.evm.codes/#30)                                                                                   | `address(this)`                          |
-| _I<sub>o</sub>_ | [`ORIGIN`](https://www.evm.codes/#32)                                                                                    | `tx.origin`                              |
-| _I<sub>p</sub>_ | [`GASPRICE`](https://www.evm.codes/#3a)                                                                                  | `tx.gasprice`                            |
-| _I<sub>d</sub>_ | [`CALLDATALOAD`](https://www.evm.codes/#35), etc.                                                                        | `msg.data`                               |
-| _I<sub>s</sub>_ | [`CALLER`](https://www.evm.codes/#33)                                                                                    | `msg.sender`                             |
-| _I<sub>v</sub>_ | [`CALLVALUE`](https://www.evm.codes/#34)                                                                                 | `msg.value`                              |
-| _I<sub>b</sub>_ | [`CODECOPY`](https://www.evm.codes/#39)                                                                                  | `address(this).code`                     |
-| _I<sub>H</sub>_ | Champs de l'en-tête de bloc, tels que [`NUMBER`](https://www.evm.codes/#43) et [`DIFFICULTY`](https://www.evm.codes/#44) | `block.number`, `block.difficulty`, etc. |
-| _I<sub>e</sub>_ | Profondeur de la pile d'appels pour les appels entre contrats (y compris la création de contrat)                         |                                          |
-| _I<sub>w</sub>_ | L'EVM est-il autorisé à modifier l'état ou s'exécute-t-il de manière statique                                            |                                          |
-
-Quelques autres paramètres sont nécessaires pour comprendre le reste de la section 9 :
-
-| Paramètre | Défini dans la section | Signification                                                                                                                                                                                                                                                |
-| --------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| _σ_       | 2 (p. 2, équation 1)   | L'état de la blockchain                                                                                                                                                                                                                                      |
-| _g_       | 9.3 (p. 13)            | Gaz restant                                                                                                                                                                                                                                                  |
-| _A_       | 6.1 (p. 8)             | Sous-état accumulé (modifications prévues pour la fin de la transaction)                                                                                                                                                                                     |
-| _o_       | 9.3 (p. 13)            | Sortie - le résultat retourné dans le cas d'une transaction interne (quand un contrat en appelle un autre) et des appels à des fonctions d'affichage (quand on demande simplement des informations, il n'est donc pas nécessaire d'attendre une transaction) |
+L'environnement d'exécution est un uplet, _I_, qui inclut des informations ne faisant pas partie de l'état de la blockchain ou de l'EVM.
+
+| Paramètre       | Opcode pour accéder aux données                                                                                       | Code Solidity pour accéder aux données                   |
+| --------------- | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| _I<sub>a</sub>_ | [`ADDRESS`](https://www.evm.codes/#30)                                                                                | `address(this)`                                          |
+| _I<sub>o</sub>_ | [`ORIGIN`](https://www.evm.codes/#32)                                                                                 | `tx.origin`                                              |
+| _I<sub>p</sub>_ | [`GASPRICE`](https://www.evm.codes/#3a)                                                                               | `tx.gasprice`                                            |
+| _I<sub>d</sub>_ | [`CALLDATALOAD`](https://www.evm.codes/#35), etc.                                                     | `msg.data`                                               |
+| _I<sub>s</sub>_ | [`CALLER`](https://www.evm.codes/#33)                                                                                 | `msg.sender`                                             |
+| _I<sub>v</sub>_ | [`CALLVALUE`](https://www.evm.codes/#34)                                                                              | `msg.value`                                              |
+| _I<sub>b</sub>_ | [`CODECOPY`](https://www.evm.codes/#39)                                                                               | `address(this).code`                                     |
+| _I<sub>H</sub>_ | Champs d'en-tête de bloc, tels que [`NUMBER`](https://www.evm.codes/#43) et [`DIFFICULTY`](https://www.evm.codes/#44) | `block.number`, `block.difficulty`, etc. |
+| _I<sub>e</sub>_ | Profondeur de la pile d'appels pour les appels entre contrats (y compris la création de contrat)   |                                                          |
+| _I<sub>w</sub>_ | L'EVM est-il autorisé à modifier l'état, ou s'exécute-t-il de manière statique                                        |                                                          |
+
+Quelques autres paramètres sont nécessaires pour comprendre le reste de la section 9 :
+
+| Paramètre | Défini dans la section                                         | Signification                                                                                                                                                                                                                                                                                     |
+| --------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| _σ_       | 2 (p. 2, équation 1)        | L'état de la blockchain                                                                                                                                                                                                                                                                           |
+| _g_       | 9.3 (p. 13) | Gaz restant                                                                                                                                                                                                                                                                                       |
+| _A_       | 6.1 (p. 8)  | Sous-état accumulé (changements prévus pour la fin de la transaction)                                                                                                                                                                                                          |
+| _o_       | 9.3 (p. 13) | Sortie - le résultat retourné dans le cas d'une transaction interne (lorsqu'un contrat en appelle un autre) et des appels aux fonctions de vue (lorsque vous demandez simplement des informations, il n'est donc pas nécessaire d'attendre une transaction) |
 
 ## 9.4 Aperçu de l'exécution {#94-execution-overview}
 
-Maintenant que nous avons tous les préliminaires, nous pouvons enfin commencer à travailler sur le fonctionnement de l'EVM.
+Maintenant que nous avons tous les préliminaires, nous pouvons enfin commencer à étudier le fonctionnement de l'EVM.
 
-Les équations 137-142 nous donnent les conditions initiales pour faire fonctionner l'EVM :
+Les équations 137-142 nous donnent les conditions initiales pour l'exécution de l'EVM :
 
-| Symbole          | Valeur initiale | Signification                                                                                                                                                                                                                                                                        |
-| ---------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| _μ<sub>g</sub>_  | _g_             | Gaz restant                                                                                                                                                                                                                                                                          |
-| _μ<sub>pc</sub>_ | _0_             | Compteur de programme, l'adresse de la prochaine instruction à exécuter                                                                                                                                                                                                              |
-| _μ<sub>m</sub>_  | _(0, 0, ...)_   | Mémoire, initialisée à zéro                                                                                                                                                                                                                                                          |
-| _μ<sub>i</sub>_  | _0_             | Emplacement mémoire le plus élevé utilisé                                                                                                                                                                                                                                            |
-| _μ<sub>s</sub>_  | _()_            | La pile, initialement vide                                                                                                                                                                                                                                                           |
-| _μ<sub>o</sub>_  | _∅_             | La sortie, un ensemble vide jusqu'à ce que nous nous arrêtions soit avec des données de retour ([`RETURN`](https://www.evm.codes/#f3) ou [`REVERT`](https://www.evm.codes/#fd)) soit sans elle ([`STOP`](https://www.evm.codes/#00) ou [`SELFDESTRUCT`](https://www.evm.codes/#ff)). |
+| Symbole          | Valeur initiale                                                                  | Signification                                                                                                                                                                                                                                                                                                                  |
+| ---------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| _μ<sub>g</sub>_  | _g_                                                                              | Gaz restant                                                                                                                                                                                                                                                                                                                    |
+| _μ<sub>pc</sub>_ | _0_                                                                              | Compteur de programme, l'adresse de la prochaine instruction à exécuter                                                                                                                                                                                                                                                        |
+| _μ<sub>m</sub>_  | _(0, 0, ...)_ | Mémoire, initialisée à zéro                                                                                                                                                                                                                                                                                                    |
+| _μ<sub>i</sub>_  | _0_                                                                              | Emplacement mémoire le plus élevé utilisé                                                                                                                                                                                                                                                                                      |
+| _μ<sub>s</sub>_  | _()_                                                          | La pile, initialement vide                                                                                                                                                                                                                                                                                                     |
+| _μ<sub>o</sub>_  | _∅_                                                                              | La sortie, un ensemble vide jusqu'à ce que nous nous arrêtions avec des données de retour ([`RETURN`](https://www.evm.codes/#f3) ou [`REVERT`](https://www.evm.codes/#fd)) ou sans ([`STOP`](https://www.evm.codes/#00) ou [`SELFDESTRUCT`](https://www.evm.codes/#ff)). |
 
 L'équation 143 nous indique qu'il existe quatre conditions possibles à chaque instant lors de l'exécution, et ce qu'il faut faire avec elles :
 
-1.  `Z(σ,μ,A,I)`. Z représente une fonction qui teste si une opération crée une transition d'état invalide (voir [l'arrêt exceptionnel](#942-exceptional-halting)). Si elle est évaluée à True, le nouvel état est identique à l'ancien (à l'exception du gaz brûlé) car les changements n'ont pas été mis en œuvre.
-2.  Si l'opcode exécuté est [`REVERT`](https://www.evm.codes/#fd), le nouvel état est le même que l'ancien, et une partie du gaz est perdue.
-3.  Si la séquence d'opérations est terminée, comme signifié par un [`RETURN`](https://www.evm.codes/#f3), l'état est mis à jour avec le nouvel état.
-4.  Si nous ne sommes pas à l'une des conditions de fin 1-3, continuer l'exécution.
+1. `Z(σ,μ,A,I)`. Z représente une fonction qui teste si une opération crée une transition d'état non valide (voir [arrêt exceptionnel](#942-exceptional-halting)). Si elle est évaluée à Vrai, le nouvel état est identique à l'ancien (à l'exception du gaz brûlé), car les modifications n'ont pas été appliquées.
+2. Si l'opcode exécuté est [`REVERT`](https://www.evm.codes/#fd), le nouvel état est le même que l'ancien, et une partie du gaz est perdue.
+3. Si la séquence d'opérations est terminée, comme l'indique un [`RETURN`](https://www.evm.codes/#f3)), l'état est mis à jour vers le nouvel état.
+4. Si nous ne sommes pas dans l'une des conditions de fin 1-3, l'exécution continue.
 
-## 9.4.1 Machine à états {#941-machine-state}
+## 9.4.1 État de la machine {#941-machine-state}
 
-Cette section explique la machine à états en détail. Elle spécifie que _w_ est l'opcode actuel. Si _μ<sub>pc</sub>_ est inférieur à _||I<sub>b</sub>||_, la longueur du code, alors ce byte (_I<sub>b</sub>[μ<sub>pc</sub>]_) est l'opcode. Sinon, l'opcode est défini comme [`STOP`](https://www.evm.codes/#00).
+Cette section explique plus en détail l'état de la machine. Elle spécifie que _w_ est l'opcode actuel. Si _μ<sub>pc</sub>_ est inférieur à _||I<sub>b</sub>||_, la longueur du code, alors cet octet (_I<sub>b</sub>[μ<sub>pc</sub>]_) est l'opcode. Sinon, l'opcode est défini comme [`STOP`](https://www.evm.codes/#00).
 
-Comme il s'agit [d'une machine à pile](https://en.wikipedia.org/wiki/Stack_machine), nous devons suivre le nombre d'éléments retirés (_δ_) et insérés (_α_) par chaque opcode.
+Comme il s'agit d'une [machine à pile](https://en.wikipedia.org/wiki/Stack_machine), nous devons suivre le nombre d'éléments retirés (_δ_) et insérés (_α_) par chaque opcode.
 
-## 9.4.2 Arrêt Exceptionnel {#942-exceptional-halt}
+## 9.4.2 Arrêt exceptionnel {#942-exceptional-halt}
 
-Cette section définit la fonction _Z_, qui spécifie quand nous avons une terminaison anormale. Il s'agit d'une fonction [booléenne](https://en.wikipedia.org/wiki/Boolean_data_type), donc elle utilise [_∨_ pour un « ou » logique](https://en.wikipedia.org/wiki/Logical_disjunction) et [_∧_ pour un « et » logique](https://en.wikipedia.org/wiki/Logical_conjunction).
+Cette section définit la fonction _Z_, qui spécifie quand nous avons une fin anormale. Il s'agit d'une fonction [booléenne](https://en.wikipedia.org/wiki/Boolean_data_type), elle utilise donc [_∨_ pour un OU logique](https://en.wikipedia.org/wiki/Logical_disjunction) et [_∧_ pour un ET logique](https://en.wikipedia.org/wiki/Logical_conjunction).
 
 Nous avons un arrêt exceptionnel si l'une de ces conditions est vraie :
 
-- **_μ<sub>g</sub> < C(σ,μ,A,I)_** Comme nous l'avons vu à la section 9.2, _C_ est la fonction qui spécifie le coût en gaz. Il ne reste pas assez de gaz pour couvrir le prochain opcode.
+- **_μ<sub>g</sub> < C(σ,μ,A,I)_**
+  Comme nous l'avons vu dans la section 9.2, _C_ est la fonction qui spécifie le coût du gaz. Il ne reste pas assez de gaz pour couvrir le prochain opcode.
 
-- **_δ<sub>w</sub>=∅_** Si le nombre d'éléments extraits pour un opcode est indéfini, alors l'opcode lui-même est indéfini.
+- **_δ<sub>w</sub>=∅_**
+  Si le nombre d'éléments dépilés pour un opcode est indéfini, l'opcode lui-même est indéfini.
 
-- **_|| μ<sub>s</sub> || < δ<sub>w</sub>_** Sous-alimentation de la pile, pas assez d'éléments dans la pile pour l'opcode actuel.
+- **_|| μ<sub>s</sub> || < δ<sub>w</sub>_**
+  Sous-dépassement de la pile, pas assez d'éléments dans la pile pour l'opcode actuel.
 
-- **_w = JUMP ∧ μ<sub>s</sub>[0]∉D(I<sub>b</sub>)_** L'opcode est [`JUMP`](https://www.evm.codes/#56) et l'adresse n'est pas une [`JUMPDEST`](https://www.evm.codes/#5b). Les sauts ne sont valides _que_ lorsque la destination est une [`JUMPDEST`](https://www.evm.codes/#5b).
+- **_w = JUMP ∧ μ<sub>s</sub>[0]∉D(I<sub>b</sub>)_**
+  L'opcode est [`JUMP`](https://www.evm.codes/#56) et l'adresse n'est pas une [`JUMPDEST`](https://www.evm.codes/#5b). Les sauts ne sont valides _que_ si la destination est une [`JUMPDEST`](https://www.evm.codes/#5b).
 
-- **_w = JUMPI ∧ μ<sub>s</sub>[1]≠0 ∧ μ<sub>s</sub>[0] ∉ D(I<sub>b</sub>)_** L'opcode est [`JUMPI`](https://www.evm.codes/#57), la condition est vraie (non nulle) donc le saut devrait se produire, et l'adresse n'est pas une [`JUMPDEST`](https://www.evm.codes/#5b). Les sauts ne sont valides _que_ lorsque la destination est une [`JUMPDEST`](https://www.evm.codes/#5b).
+- **_w = JUMPI ∧ μ<sub>s</sub>[1]≠0 ∧ μ<sub>s</sub>[0] ∉ D(I<sub>b</sub>)_**
+  L'opcode est [`JUMPI`](https://www.evm.codes/#57), la condition est vraie (non nulle), donc le saut doit avoir lieu, et l'adresse n'est pas une [`JUMPDEST`](https://www.evm.codes/#5b). Les sauts ne sont valides _que_ si la destination est une [`JUMPDEST`](https://www.evm.codes/#5b).
 
-- **_w = RETURNDATACOPY ∧ μ<sub>s</sub>[1]+μ<sub>s</sub>[2]>|| μ<sub>o</sub> ||_** L'opcode est [`RETURNDATACOPY`](https://www.evm.codes/#3e). Dans cet opcode, l'élément de pile _μ<sub>s</sub>[1]_ est le décalage pour lire dans le tampon de données retournées, et l'élément de pile _μ<sub>s</sub>[2]_ est la longueur des données. Cette condition se produit lorsque vous essayez de lire au-delà de la fin du tampon de données retournées. Notez qu'il n'y a pas de condition similaire pour les données d'appel ou pour le code lui-même. Lorsque vous essayez de lire au-delà de la fin de ces tampons, vous obtenez simplement des zéros.
+- **_w = RETURNDATACOPY ∧ μ<sub>s</sub>[1]+μ<sub>s</sub>[2]>|| μ<sub>o</sub> ||_**
+  L'opcode est [`RETURNDATACOPY`](https://www.evm.codes/#3e). Dans cet opcode, l'élément de pile _μ<sub>s</sub>[1]_ est le décalage à partir duquel lire dans le tampon des données de retour, et l'élément de pile _μ<sub>s</sub>[2]_ est la longueur des données. Cette condition se produit lorsque vous essayez de lire au-delà de la fin du tampon de données retournées. Notez qu'il n'y a pas de condition similaire pour les données d'appel ou pour le code lui-même. Lorsque vous essayez de lire au-delà de la fin de ces tampons, vous obtenez simplement des zéros.
 
 - **_|| μ<sub>s</sub> || - δ<sub>w</sub> + α<sub>w</sub> > 1024_**
 
-  Débordement de la pile. Si l'exécution de l'opcode entraîne une pile de plus de 1024 éléments, abandonnez.
+  Dépassement de la pile. Si l'exécution de l'opcode entraîne une pile de plus de 1024 éléments, abandonnez.
 
-- **_¬I<sub>w</sub> ∧ W(w,μ)_** Exécutons-nous de manière statique ([¬ est une négation](https://en.wikipedia.org/wiki/Negation) et _I<sub>w</sub>_ est vrai lorsque nous sommes autorisés à modifier l'état de la blockchain) ? Si c'est le cas et que nous essayons une opération qui change l'état, cela ne peut pas se produire.
+- **_¬I<sub>w</sub> ∧ W(w,μ)_**
+  Sommes-nous en train d'exécuter statiquement ([¬ est la négation](https://en.wikipedia.org/wiki/Negation) et _I<sub>w</sub>_ est vrai lorsque nous sommes autorisés à changer l'état de la blockchain) ? Si c'est le cas et que nous essayons une opération qui change l'état, cela ne peut pas se produire.
 
-  La fonction _W(w,μ)_ est définie plus tard dans l'équation 150. _W(w,μ)_ est vraie si l'une de ces conditions est vraie :
+  La fonction _W(w,μ)_ est définie plus loin dans l'équation 150. _W(w,μ)_ est vraie si l'une de ces conditions est vraie :
 
-  - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_** Ces opcodes modifient l'état, soit en créant un nouveau contrat, soit en stockant une valeur, soit en détruisant le contrat actuel.
+  - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_**
+    Ces opcodes modifient l'état, soit en créant un nouveau contrat, en stockant une valeur, soit en détruisant le contrat actuel.
 
-  - **_LOG0≤w ∧ w≤LOG4_** Si nous sommes appelés de manière statique, nous ne pouvons pas émettre d'entrées de journal. Les opcodes de journal sont tous dans la plage entre [`LOG0` (A0)](https://www.evm.codes/#a0) et [`LOG4` (A4)](https://www.evm.codes/#a4). Le nombre après l'opcode de journal spécifie combien de sujets l'entrée de journal contient.
-  - **_w=CALL ∧ μ<sub>s</sub>[2]≠0_** Vous pouvez appeler un autre contrat lorsque vous êtes statique, mais si vous le faites, vous ne pouvez pas lui transférer de l'ETH.
+  - **_LOG0≤w ∧ w≤LOG4_**
+    Si nous sommes appelés de manière statique, nous ne pouvons pas émettre d'entrées de journal.
+    Les opcodes de journal se situent tous dans la plage entre [`LOG0` (A0)](https://www.evm.codes/#a0) et [`LOG4` (A4)](https://www.evm.codes/#a4).
+    Le nombre après l'opcode de journal spécifie combien de sujets l'entrée de journal contient.
 
-- **_w = SSTORE ∧ μ<sub>g</sub> ≤ G<sub>callstipend</sub>_** Vous ne pouvez pas exécuter [`SSTORE`](https://www.evm.codes/#55) à moins d'avoir plus de G<sub>callstipend</sub> (défini à 2300 dans l'Annexe G) de gaz.
+  - **_w=CALL ∧ μ<sub>s</sub>[2]≠0_**
+    Vous pouvez appeler un autre contrat lorsque vous êtes statique, mais si vous le faites, vous ne pouvez pas lui transférer d'ETH.
 
-## 9.4.3 Validité de la Destination de Saut {#943-jump-dest-valid}
+- **_w = SSTORE ∧ μ<sub>g</sub> ≤ G<sub>callstipend</sub>_**
+  Vous ne pouvez pas exécuter [`SSTORE`](https://www.evm.codes/#55) à moins d'avoir plus de G<sub>callstipend</sub> (défini à 2300 dans l'Annexe G) de gaz.
 
-Ici, nous définissons formellement ce que sont les opcodes [`JUMPDEST`](https://www.evm.codes/#5b). Nous ne pouvons pas simplement chercher la valeur de byte 0x5B, car elle pourrait se trouver à l'intérieur d'un PUSH (et donc être une donnée et non un opcode).
+## 9.4.3 Validité de la destination de saut {#943-jump-dest-valid}
 
-Dans l'équation (153), nous définissons une fonction, _N(i,w)_. Le premier paramètre, _i_, est la position de l'opcode. Le second, _w_, est l'opcode lui-même. Si _w∈[PUSH1, PUSH32]_, cela signifie que l'opcode est un PUSH (les crochets définissent une plage qui inclut les points d'extrémité). Dans ce cas, le prochain opcode est à _i+2+(w−PUSH1)_. Pour [`PUSH1`](https://www.evm.codes/#60), nous devons avancer de deux bytes (le PUSH lui-même et la valeur d'un byte), pour [`PUSH2`](https://www.evm.codes/#61) nous devons avancer de trois bytes car c'est une valeur de deux bytes, etc. Tous les autres opcodes EVM ont une longueur d'un byte, donc dans tous les autres cas _N(i,w)=i+1_.
+Ici, nous définissons formellement ce que sont les opcodes [`JUMPDEST`](https://www.evm.codes/#5b). Nous ne pouvons pas simplement chercher la valeur de l'octet 0x5B, car elle pourrait se trouver à l'intérieur d'un PUSH (et donc être une donnée et non un opcode).
 
-Cette fonction est utilisée dans l'équation (152) pour définir _D<sub>J</sub>(c,i)_, qui est [l'ensemble](https://en.wikipedia.org/wiki/Set_(mathematics)) de toutes les destinations de saut valides dans le code _c_, à partir de la position de l'opcode _i_. Cette fonction est définie de manière récursive. Si _i≥||c||_, cela signifie que nous sommes à la fin ou après la fin du code. Nous ne trouverons plus d'autres destinations de saut, donc retournez simplement l'ensemble vide.
+Dans l'équation (153), nous définissons une fonction, _N(i,w)_. Le premier paramètre, _i_, est l'emplacement de l'opcode. Le second, _w_, est l'opcode lui-même. Si _w∈[PUSH1, PUSH32]_, cela signifie que l'opcode est un PUSH (les crochets définissent une plage qui inclut les points d'extrémité). Dans ce cas, l'opcode suivant se trouve à _i+2+(w−PUSH1)_. Pour [`PUSH1`](https://www.evm.codes/#60), nous devons avancer de deux octets (le PUSH lui-même et la valeur d'un octet), pour [`PUSH2`](https://www.evm.codes/#61), nous devons avancer de trois octets parce que c'est une valeur de deux octets, etc. Tous les autres opcodes EVM ont une longueur d'un seul octet, donc dans tous les autres cas _N(i,w)=i+1_.
+
+Cette fonction est utilisée dans l'équation (152) pour définir _D<sub>J</sub>(c,i)_, qui est l'[ensemble](https://en.wikipedia.org/wiki/Set_\(mathematics\)) de toutes les destinations de saut valides dans le code _c_, à partir de l'emplacement de l'opcode _i_. Cette fonction est définie de manière récursive. Si _i≥||c||_, cela signifie que nous sommes à la fin ou après la fin du code. Nous ne trouverons plus d'autres destinations de saut, donc retournez simplement l'ensemble vide.
 
 Dans tous les autres cas, nous examinons le reste du code en passant à l'opcode suivant et en obtenant l'ensemble à partir de celui-ci. _c[i]_ est l'opcode actuel, donc _N(i,c[i])_ est la position du prochain opcode. _D<sub>J</sub>(c,N(i,c[i]))_ est donc l'ensemble des destinations de saut valides qui commence au prochain opcode. Si l'opcode actuel n'est pas un `JUMPDEST`, retournez simplement cet ensemble. Si c'est un `JUMPDEST`, incluez-le dans l'ensemble résultant et retournez-le.
 
 ## 9.4.4 Arrêt normal {#944-normal-halt}
 
-La fonction d'arrêt _H_ peut retourner trois types de valeurs.
+La fonction d'arrêt _H_, peut retourner trois types de valeurs.
 
-- Si nous ne sommes pas dans un opcode d'arrêt, retournez _∅_, l'ensemble vide. Par convention, cette valeur est interprétée comme un booléen faux.
-- Si nous avons un opcode d'arrêt qui ne produit pas de sortie (soit [`STOP`](https://www.evm.codes/#00) ou [`SELFDESTRUCT`](https://www.evm.codes/#ff)), retournez une séquence de bytes de taille zéro comme valeur de retour. Notez que ceci est très différent de l'ensemble vide. Cette valeur signifie que l'EVM s'est vraiment arrêté, il n'y a juste aucune donnée de retour à lire.
-- Si nous avons un opcode d'arrêt qui produit une sortie (soit [`RETURN`](https://www.evm.codes/#f3) ou [`REVERT`](https://www.evm.codes/#fd)), retournez la séquence de bytes spécifiée par cet opcode. Cette séquence est prise de la mémoire, la valeur en haut de la pile (_μ<sub>s</sub>[0]_) est le premier byte, et la valeur après elle (_μ<sub>s</sub>[1]_) est la longueur.
+- Si nous ne sommes pas dans un opcode d'arrêt, retournez ∅, l'ensemble vide. Par convention, cette valeur est interprétée comme un booléen faux.
+- Si nous avons un opcode d'arrêt qui ne produit pas de sortie (soit [`STOP`](https://www.evm.codes/#00) ou [`SELFDESTRUCT`](https://www.evm.codes/#ff)), retournez une séquence d'octets de taille zéro comme valeur de retour. Notez que ceci est très différent de l'ensemble vide. Cette valeur signifie que l'EVM s'est vraiment arrêté, il n'y a juste aucune donnée de retour à lire.
+- Si nous avons un opcode d'arrêt qui produit une sortie (soit [`RETURN`](https://www.evm.codes/#f3) ou [`REVERT`](https://www.evm.codes/#fd)), retournez la séquence d'octets spécifiée par cet opcode. Cette séquence est prise de la mémoire, la valeur en haut de la pile (_μ<sub>s</sub>[0]_) est le premier octet, et la valeur après elle (_μ<sub>s</sub>[1]_) est la longueur.
 
-## H.2 Ensemble d'instructions {#h2-instruction-set}
+## H.2 Jeu d'instructions {#h2-instruction-set}
 
 Avant de passer à la sous-section finale de l'EVM, 9.5, examinons les instructions elles-mêmes. Elles sont définies dans l'Annexe H.2 qui commence à la page 29. Tout ce qui n'est pas spécifié comme changeant avec cet opcode spécifique est censé rester identique. Les variables qui changent sont spécifiées comme \<quelque chose\>′.
 
 Par exemple, examinons l'opcode [`ADD`](https://www.evm.codes/#01).
 
-| Valeur | Mnemonic | δ | α | Description                                               |
-| ------:| -------- | - | - | --------------------------------------------------------- |
-|   0x01 | ADD      | 2 | 1 | Opération d'addition.                                     |
-|        |          |   |   | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[0] + μ<sub>s</sub>[1]_ |
+| Valeur | Mnémonique | δ | α | Description                                                                                                                                                                                                           |
+| -----: | ---------- | - | - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|   0x01 | ADD        | 2 | 1 | Opération d'addition.                                                                                                                                                                                 |
+|        |            |   |   | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[0] + μ<sub>s</sub>[1]_ |
 
 _δ_ est le nombre de valeurs que nous retirons de la pile. Dans ce cas deux, car nous additionnons les deux premières valeurs.
 
@@ -211,31 +224,31 @@ Ainsi, le nouveau sommet de la pile (_μ′<sub>s</sub>[0]_) est la somme de l'a
 
 Au lieu de passer en revue tous les opcodes avec une « liste ennuyeuse », cet article n'explique que les opcodes qui introduisent quelque chose de nouveau.
 
-| Valeur | Mnemonic  | δ | α | Description                                                                                                |
-| ------:| --------- | - | - | ---------------------------------------------------------------------------------------------------------- |
-|   0x20 | KECCAK256 | 2 | 1 | Calculez le hash Keccak-256.                                                                               |
-|        |           |   |   | _μ′<sub>s</sub>[0] ≡ KEC(μ<sub>m</sub>[μ<sub>s</sub>[0] . . . (μ<sub>s</sub>[0] + μ<sub>s</sub>[1] − 1)])_ |
-|        |           |   |   | _μ′<sub>i</sub> ≡ M(μ<sub>i</sub>,μ<sub>s</sub>[0],μ<sub>s</sub>[1])_                                      |
+| Valeur | Mnémonique | δ | α | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| -----: | ---------- | - | - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|   0x20 | KECCAK256  | 2 | 1 | Calculez le hachage Keccak-256.                                                                                                                                                                                                                                                                                                                                                                                                                      |
+|        |            |   |   | _μ′<sub>s</sub>[0] ≡ KEC(μ<sub>m</sub>[μ<sub>s</sub>[0] . . . (μ<sub>s</sub>[0] + μ<sub>s</sub>[1] − 1)])_ |
+|        |            |   |   | _μ′<sub>i</sub> ≡ M(μ<sub>i</sub>,μ<sub>s</sub>[0],μ<sub>s</sub>[1])_                                                                                                                                                                                                                                                                     |
 
 Il s'agit du premier opcode qui accède à la mémoire (dans ce cas, en lecture seule). Cependant, il pourrait dépasser les limites actuelles de la mémoire, nous devons donc mettre à jour _μ<sub>i</sub>._ Nous faisons cela en utilisant la fonction _M_ définie dans l'équation 328 à la page 29.
 
-| Valeur | Mnemonic | δ | α | Description                       |
-| ------:| -------- | - | - | --------------------------------- |
-|   0x31 | BALANCE  | 1 | 1 | Obtenez le solde du compte donné. |
-|        |          |   |   | ...                               |
+| Valeur | Mnémonique | δ | α | Description                                         |
+| -----: | ---------- | - | - | --------------------------------------------------- |
+|   0x31 | BALANCE    | 1 | 1 | Obtenez le solde du compte donné.   |
+|        |            |   |   | ... |
 
-L'adresse dont nous avons besoin pour trouver le solde est _μ<sub>s</sub>[0] mod 2<sup>160</sup>_. Le sommet de la pile est l'adresse, mais comme les adresses ne font que 160 bits, nous calculons la valeur [modulo](https://en.wikipedia.org/wiki/Modulo_operation) 2<sup>160</sup>.
+L'adresse dont nous devons trouver le solde est _μ<sub>s</sub>[0] mod 2<sup>160</sup>_. Le sommet de la pile est l'adresse, mais comme les adresses ne font que 160 bits, nous calculons la valeur [modulo](https://en.wikipedia.org/wiki/Modulo_operation) 2<sup>160</sup>.
 
 Si _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] ≠ ∅_, cela signifie qu'il y a des informations sur cette adresse. Dans ce cas, _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>]<sub>b</sub>_ est le solde de cette adresse. Si _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] = ∅_, cela signifie que cette adresse n'est pas initialisée et le solde est zéro. Vous pouvez voir la liste des champs d'information du compte dans la section 4.1 à la page 4.
 
-La deuxième équation, _A'<sub>a</sub> ≡ A<sub>a</sub> ∪ \{μ<sub>s</sub>[0] mod 2<sup>160</sup>}_, est liée à la différence de coût entre l'accès au stockage chaud (stockage qui a récemment été accédé et est susceptible d'être mis en cache) et le stockage froid (stockage qui n'a pas été accédé et est susceptible de se trouver dans un stockage plus lent qui est plus coûteux à récupérer). _A<sub>a</sub>_ est la liste des adresses précédemment accédées par la transaction, qui devraient donc être moins chères à accéder, comme défini dans la section 6.1 à la page 8. Vous pouvez en savoir plus sur ce sujet dans [l'EIP-2929](https://eips.ethereum.org/EIPS/eip-2929).
+La deuxième équation, _A'<sub>a</sub> ≡ A<sub>a</sub> ∪ \{μ<sub>s</sub>[0] mod 2<sup>160</sup>}_, est liée à la différence de coût entre l'accès au stockage chaud (stockage qui a récemment été accédé et est susceptible d'être mis en cache) et le stockage froid (stockage qui n'a pas été accédé et est susceptible de se trouver dans un stockage plus lent qui est plus coûteux à récupérer). _A<sub>a</sub>_ est la liste des adresses précédemment accédées par la transaction, qui devraient donc être moins chères à accéder, comme défini dans la section 6.1 à la page 8. Vous pouvez en lire plus sur ce sujet dans [l'EIP-2929](https://eips.ethereum.org/EIPS/eip-2929).
 
-| Valeur | Mnemonic | δ  | α  | Description                             |
-| ------:| -------- | -- | -- | --------------------------------------- |
-|   0x8F | DUP16    | 16 | 17 | Duplique le 16e élément de la pile.     |
-|        |          |    |    | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[15]_ |
+| Valeur | Mnémonique | δ  | α  | Description                                                                                                                                     |
+| -----: | ---------- | -- | -- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+|   0x8F | DUP16      | 16 | 17 | Duplique le 16e élément de la pile.                                                                                             |
+|        |            |    |    | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[15]_ |
 
-Notez que pour utiliser un élément de la pile, nous devons le retirer, ce qui signifie que nous devons également retirer tous les éléments de la pile au-dessus de lui. Dans le cas de [`DUP<n>`](https://www.evm.codes/#8f) et [`SWAP<n>`](https://www.evm.codes/#9f), cela signifie devoir retirer puis remettre jusqu'à seize valeurs.
+Notez que pour utiliser un élément de la pile, nous devons le retirer, ce qui signifie que nous devons également retirer tous les éléments de la pile au-dessus de lui. Dans le cas de [`DUP<n>`](https://www.evm.codes/#8f) et [`SWAP<n>`](https://www.evm.codes/#9f), cela signifie avoir à dépiler puis à empiler jusqu'à seize valeurs.
 
 ## 9.5 Le cycle d'exécution {#95-exec-cycle}
 
@@ -250,15 +263,16 @@ L'équation (155) dit qu'étant donné l'état :
 
 Le nouvel état est _(σ', μ', A', I')_.
 
-Les équations (156)-(158) définissent la pile et le changement en elle en raison d'un opcode (_μ<sub>s</sub>_). L'équation (159) est le changement de gaz (_μ<sub>g</sub>_). L'équation (160) est le changement dans le compteur de programme (_μ<sub>pc</sub>_). Enfin, les équations (161)-(164) spécifient que les autres paramètres restent les mêmes, sauf s'ils sont explicitement modifiés par l'opcode.
+Les équations (156)-(158) définissent la pile et le changement qui s'y produit à cause d'un opcode (_μ<sub>s</sub>_). L'équation (159) est le changement de gaz (_μ<sub>g</sub>_). L'équation (160) est le changement dans le compteur de programme (_μ<sub>pc</sub>_). Enfin, les équations (161)-(164) spécifient que les autres paramètres restent les mêmes, sauf s'ils sont explicitement modifiés par l'opcode.
 
 Avec cela, l'EVM est entièrement défini.
 
 ## Conclusion {#conclusion}
 
-La notation mathématique est précise et a permis au Livre Jaune de spécifier chaque détail d'Ethereum. Cependant, elle présente quelques inconvénients :
+La notation mathématique est précise et a permis au Livre jaune de spécifier chaque détail d'Ethereum. Cependant, elle présente quelques inconvénients :
 
-- Elle ne peut être comprise que par les humains, ce qui signifie que [les tests](https://github.com/ethereum/tests) de conformité doivent être écrits manuellement.
-- Les programmeurs comprennent le code informatique. Ils peuvent ou non comprendre la notation mathématique.
+- Elle ne peut être comprise que par les humains, ce qui signifie que les [tests de conformité](https://github.com/ethereum/tests) doivent être écrits manuellement.
+- Les programmeurs comprennent le code informatique.
+  Ils peuvent ou non comprendre la notation mathématique.
 
-Peut-être pour ces raisons, les nouvelles [spécifications de la couche de consensus](https://github.com/ethereum/consensus-specs/blob/master/tests/core/pyspec/README.md) sont écrites en Python. Il existe des [spécifications de la couche d'exécution en Python](https://ethereum.github.io/execution-specs), mais elles ne sont pas complètes. Jusqu'à ce que le Livre Jaune soit également traduit en Python ou dans un langage similaire, le Livre Jaune continuera d'être utilisé, et il est utile de pouvoir le lire.
+Peut-être pour ces raisons, les [spécifications plus récentes de la couche de consensus](https://github.com/ethereum/consensus-specs/blob/master/tests/core/pyspec/README.md) sont écrites en Python. Il existe des [spécifications de la couche d'exécution en Python](https://ethereum.github.io/execution-specs), mais elles ne sont pas complètes. Jusqu'à ce que le Livre jaune soit également traduit en Python ou dans un langage similaire, le Livre jaune continuera d'être utilisé, et il est utile de pouvoir le lire.
diff --git a/public/content/translations/fr/eips/index.md b/public/content/translations/fr/eips/index.md
index 47af6c181ee..d8c9e67a5ba 100644
--- a/public/content/translations/fr/eips/index.md
+++ b/public/content/translations/fr/eips/index.md
@@ -1,32 +1,32 @@
 ---
-title: Propositions d'amélioration d'Ethereum (EIP)
+title: "Propositions d'amélioration d'Ethereum (EIP)"
 description: Les informations de base dont vous avez besoin pour comprendre les EIP
 lang: fr
 ---
 
-# Introduction aux propositions d'amélioration d'Ethereum (EIP) {#introduction-to-ethereum-improvement-proposals}
+# Introduction aux Propositions d'amélioration d'Ethereum (EIP) {#introduction-to-ethereum-improvement-proposals}
 
 ## En quoi consistent les EIP ? {#what-are-eips}
 
-[Les EIP](https://eips.ethereum.org/) sont des normes spécifiant de nouvelles fonctionnalités ou processus potentiels pour Ethereum. Les EIP contiennent les spécifications techniques des modifications proposées et servent de "source de vérité" pour la communauté. Les mises à niveau du réseau et les normes des applications Ethereum sont discutées et développées via le processus EIP.
+Les [Propositions d'amélioration d'Ethereum (EIP)](https://eips.ethereum.org/) sont des normes spécifiant de nouvelles fonctionnalités ou de nouveaux processus potentiels pour Ethereum. Les EIP contiennent les spécifications techniques des modifications proposées et servent de "source de vérité" pour la communauté. Les mises à niveau du réseau et les normes des applications Ethereum sont discutées et développées via le processus EIP.
 
-N'importe qui dans la communauté Ethereum peut créer une EIP. Les directives pour rédiger des EIP sont incluses dans [EIP-1](https://eips.ethereum.org/EIPS/eip-1). Une EIP devrait avant tout fournir une spécification technique concise assortie d'une petite justification. L'auteur de l'EIP est tenu d'obtenir un consensus au sein de la communauté et de répertorier les opinions alternatives. Compte tenu de la barrière technique élevée que représente la soumission d'une EIP bien formulée, la plupart des auteurs d'EIP sont des développeurs d'application ou de protocole.
+N'importe qui dans la communauté Ethereum peut créer une EIP. Les directives pour la rédaction des EIP sont incluses dans [EIP-1](https://eips.ethereum.org/EIPS/eip-1). Une EIP devrait avant tout fournir une spécification technique concise assortie d'une petite justification. L'auteur de l'EIP est tenu d'obtenir un consensus au sein de la communauté et de répertorier les opinions alternatives. Compte tenu de la barrière technique élevée que représente la soumission d'une EIP bien formulée, la plupart des auteurs d'EIP sont des développeurs d'application ou de protocole.
 
 ## Pourquoi les EIP sont-elles importantes ? {#why-do-eips-matter}
 
-Les EIP jouent un rôle central dans la façon dont les modifications sont effectuées et documentées sur Ethereum. Elles permettent aux utilisateurs de proposer, de discuter et d'adopter des modifications. Il existe [différents types d'EIP](https://eips.ethereum.org/EIPS/eip-1#eip-types), y compris les EIP de base destinées aux changements de protocole de faible niveau qui affectent le consensus et nécessitent une mise à jour du réseau comme [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), et les ERC pour les normes d'application comme [EIP-20](https://eips.ethereum.org/EIPS/eip-20) et [EIP-721](https://eips.ethereum.org/EIPS/eip-721).
+Les EIP jouent un rôle central dans la façon dont les modifications sont effectuées et documentées sur Ethereum. Elles permettent aux utilisateurs de proposer, de discuter et d'adopter des modifications. Il existe [différents types d'EIP](https://eips.ethereum.org/EIPS/eip-1#eip-types), y compris les EIP de base pour les changements de protocole de bas niveau qui affectent le consensus et nécessitent une mise à niveau du réseau comme [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), et les ERC pour les normes d'application comme [EIP-20](https://eips.ethereum.org/EIPS/eip-20) et [EIP-721](https://eips.ethereum.org/EIPS/eip-721).
 
-Chaque mise à niveau du réseau consiste en un ensemble d'EIP qui doivent être implémentées par chaque [client Ethereum](/learn/#clients-and-nodes) du réseau. Dès lors, pour maintenir le consensus avec les autres clients du réseau principal Ethereum, les développeurs de clients doivent s'assurer qu'ils ont tous implémenté les EIP requises.
+Chaque mise à niveau du réseau consiste en un ensemble d'EIP qui doivent être implémentées par chaque [client Ethereum](/learn/#clients-and-nodes) sur le réseau. Dès lors, pour maintenir le consensus avec les autres clients du réseau principal Ethereum, les développeurs de clients doivent s'assurer qu'ils ont tous implémenté les EIP requises.
 
 En plus de fournir les spécifications techniques des modifications, les EIP représentent l'unité de la gouvernance sur Ethereum : n'importe qui est libre d'en proposer une, puis divers parties prenantes de la communauté en discutent pour déterminer si elle doit être adoptée comme norme ou incluse dans une mise à niveau du réseau. Les EIP non fondamentales n'ont pas besoin d'être adoptées par toutes les applications (par exemple, il est possible de créer un jeton fongible sans implémenter EIP-20), mais les EIP fondamentales doivent être largement adoptées (dans la mesure où tous les nœuds doivent se mettre à niveau pour continuer à faire partie du même réseau). Les EIP fondamentales nécessitent un consensus plus large au sein de la communauté que les EIP non fondamentales.
 
 ## Historique des EIP {#history-of-eips}
 
-Le dépôt [GitHub des EIP](https://github.com/ethereum/EIPs) a été créé en octobre 2015. Le processus des EIP est basé sur celui des [propositions d'amélioration de Bitcoin (BIP)](https://github.com/bitcoin/bips), lui-même basé sur celui des [propositions d'amélioration de Python (PEP)](https://www.python.org/dev/peps/).
+Le [dépôt GitHub des Propositions d'amélioration d'Ethereum (EIP)](https://github.com/ethereum/EIPs) a été créé en octobre 2015. Le processus EIP est basé sur le processus des [Propositions d'amélioration de Bitcoin (BIP)](https://github.com/bitcoin/bips), qui est lui-même basé sur le processus des [Propositions d'amélioration de Python (PEP)](https://www.python.org/dev/peps/).
 
 Les éditeurs d'EIP ont pour tâche de passer en revue les EIP pour en vérifier la solidité technique, les problèmes de formatage et corriger l'orthographe, la grammaire et le style de code. Martin Becze, Vitalik Buterin, Gavin Wood et quelques autres ont été les éditeurs d'origine des EIP de 2015 à fin 2016.
 
-Les éditeurs d'EIP actuels sont 
+Les éditeurs d'EIP actuels sont
 
 - Alex Beregszaszi (@axic)
 - Gavin John (@Pandapip1)
@@ -44,31 +44,30 @@ Les éditeurs Emeritus EIP sont
 - Nick Savers (@nicksavers)
 - Vitalik Buterin (@vbuterin)
 
-Si vous souhaitez devenir un éditeur EIP, veuillez consulter [EIP-5069](https://eips.ethereum.org/EIPS/eip-5069).
+Si vous souhaitez devenir un éditeur d'EIP, veuillez consulter [EIP-5069](https://eips.ethereum.org/EIPS/eip-5069).
 
-Les éditeurs d'EIP décident du moment où une proposition peut devenir une EIP, et aident les auteurs d'EIP à faire avancer leurs propositions. [Les Ethereum Cat Herders](https://www.ethereumcatherders.com/) aident à organiser des réunions entre les éditeurs d'EIP et la communauté (voir [EIPIP](https://github.com/ethereum-cat-herders/EIPIP)).
+Les éditeurs d'EIP décident du moment où une proposition peut devenir une EIP, et aident les auteurs d'EIP à faire avancer leurs propositions. Les [Ethereum Cat Herders](https://www.ethereumcatherders.com/) aident à organiser des réunions entre les éditeurs d'EIP et la communauté (voir [EIPIP](https://github.com/ethereum-cat-herders/EIPIP)).
 
-Le processus complet de normalisation ainsi que la charte sont détaillés dans le document [EIP-1](https://eips.ethereum.org/EIPS/eip-1)
+Le processus de normalisation complet ainsi que son diagramme sont décrits dans [EIP-1](https://eips.ethereum.org/EIPS/eip-1)
 
-## En savoir plus {#learn-more}
+## En apprendre plus {#learn-more}
 
-Si vous souhaitez en savoir plus sur les EIP, consultez le site [EIPs](https://eips.ethereum.org/) et [EIP-1](https://eips.ethereum.org/EIPS/eip-1). Voici quelques liens utiles :
+Si vous souhaitez en savoir plus sur les EIP, consultez le [site web des EIP](https://eips.ethereum.org/) et [EIP-1](https://eips.ethereum.org/EIPS/eip-1). Voici quelques liens utiles :
 
-- [Une liste de toutes les propositions d'amélioration d'Ethereum (EIP)](https://eips.ethereum.org/all)
+- [Une liste de toutes les Propositions d'amélioration d'Ethereum](https://eips.ethereum.org/all)
 - [Une description de tous les types d'EIP](https://eips.ethereum.org/EIPS/eip-1#eip-types)
-- [Une description de tous les statuts EIP](https://eips.ethereum.org/EIPS/eip-1#eip-process)
+- [Une description de tous les statuts d'EIP](https://eips.ethereum.org/EIPS/eip-1#eip-process)
 
 ### Projets éducatifs communautaires {#community-projects}
 
-- [PEEPanEIP](https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F) — *PEEPanEIP est une série de vidéos éducatives qui traite des propositions d'amélioration d'Ethereum (EIP) et des fonctionnalités clés des prochaines mises à niveau.*
-- [EIPs For Nerds](https://ethereum2077.substack.com/t/eip-research) — *EIPs For Nerds propose des aperçus complets, de style ELI5, de diverses propositions d'amélioration d'Ethereum (EIP), y compris les EIP de base et les EIP de la couche application/infrastructure (ERC), pour éduquer les lecteurs et façonner le consensus autour des changements proposés au protocole Ethereum.*
-- [EIPs.wtf](https://www.eips.wtf/) — *EIPs.wtf fournit des informations supplémentaires sur les propositions d'amélioration d'Ethereum (EIP), y compris leur statut, les détails de leur mise en œuvre, les pull requests associées et les retours de la communauté.*
-- [EIP.Fun](https://eipfun.substack.com/) — *EIP.Fun fournit les dernières nouvelles sur les propositions d'amélioration d'Ethereum (EIP), des mises à jour sur les réunions EIP, et plus encore.*
-- [EIPs Insight](https://eipsinsight.com/) — *EIPs Insight représente l'état du processus des propositions d'amélioration d'Ethereum (EIP) et des statistiques, selon les informations collectées auprès de différentes sources.*
+- [PEEPanEIP](https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F) — _PEEPanEIP est une série de vidéos éducatives qui traite des Propositions d'amélioration d'Ethereum (EIP) et des fonctionnalités clés des prochaines mises à niveau._
+- [EIPs.wtf](https://www.eips.wtf/) — _EIPs.wtf fournit des informations supplémentaires sur les Propositions d'amélioration d'Ethereum (EIP), y compris leur statut, les détails de leur mise en œuvre, les pull requests associées et les retours de la communauté._
+- [EIP.Fun](https://eipfun.substack.com/) — _EIP.Fun fournit les dernières nouvelles sur les Propositions d'amélioration d'Ethereum (EIP), des mises à jour sur les réunions EIP, et plus encore._
+- [EIPs Insight](https://eipsinsight.com/) — _EIPs Insight est une représentation de l'état du processus des Propositions d'amélioration d'Ethereum (EIP) et des statistiques selon les informations collectées auprès de différentes sources._
 
 ## Participer {#participate}
 
-Tout le monde peut créer une EIP. Avant de soumettre une proposition, il est indispensable de lire [EIP-1](https://eips.ethereum.org/EIPS/eip-1) qui décrit le processus EIP et explique comment écrire une EIP et solliciter des commentaires sur [Ethereum Magician](https://ethereum-magicians.org/), où les propositions sont d'abord discutées avec la communauté avant qu'une ébauche ne soit soumise.
+Tout le monde peut créer une EIP. Avant de soumettre une proposition, il faut lire l'[EIP-1](https://eips.ethereum.org/EIPS/eip-1) qui décrit le processus EIP et la manière de rédiger une EIP, et solliciter des commentaires sur le forum [Ethereum Magicians](https://ethereum-magicians.org/), où les propositions sont d'abord discutées avec la communauté avant la soumission d'une ébauche.
 
 ## Références {#references}
 
diff --git a/public/content/translations/fr/energy-consumption/index.md b/public/content/translations/fr/energy-consumption/index.md
index 36366de7ad1..7a4110743ab 100644
--- a/public/content/translations/fr/energy-consumption/index.md
+++ b/public/content/translations/fr/energy-consumption/index.md
@@ -1,14 +1,14 @@
 ---
-title: Consommation énergétique d'Ethereum
-description: L'information de base dont vous avez besoin pour comprendre la consommation énergétique d'Ethereum.
+title: "Consommation énergétique d'Ethereum"
+description: "L'information de base dont vous avez besoin pour comprendre la consommation énergétique d'Ethereum."
 lang: fr
 ---
 
-# Les dépenses énergétiques d'Ethereum {#proof-of-stake-energy}
+# Dépenses énergétiques d'Ethereum {#proof-of-stake-energy}
 
-Ethereum est une blockchain verte. Le mécanisme de consensus par [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) d'Ethereum utilise de l'ETH au lieu [d'énergie pour sécuriser le réseau](/developers/docs/consensus-mechanisms/pow). La consommation énergétique d'Ethereum est approximativement [0.0026 TWh/an](https://carbon-ratings.com/eth-report-2022) pour l'ensemble du réseau.
+Ethereum est une blockchain verte. Le mécanisme de consensus de [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) d'Ethereum utilise des ETH au lieu de [l'énergie pour sécuriser le réseau](/developers/docs/consensus-mechanisms/pow). La consommation d'énergie d'Ethereum est d'environ [~0,0026 TWh/an](https://carbon-ratings.com/eth-report-2022) sur l'ensemble du réseau mondial.
 
-L'estimation de la consommation énergétique d'Ethereum se base sur une étude réalisée par le [CCRI (Crypto Carbon Ratings Institute)](https://carbon-ratings.com). Ils ont généré des estimations détaillées de la consommation d'électricité et de l'empreinte carbone du réseau Ethereum ([voir le rapport](https://carbon-ratings.com/eth-report-2022)). Ils ont mesuré la consommation d'électricité de différents nœuds avec différentes configurations matérielles et différents logiciels clients. Ils ont estimé que les **2,601 MWh** (0.0026 TWh) d'électricité consommés annuellement par le réseau correspond à **870 tonnes CO2e** annuelles en appliquant des facteur régionaux d'ntensité de carbone. Cette valeur change au fur et à mesure que des nœuds entrent et sortent du réseau. Vous pouvez suivre ces variations grâce à [l'Indice de Durabilité du Réseau Blockchain de Cambridge](https://ccaf.io/cbnsi/ethereum) qui offre une estimation moyenne sur 7 jours (notez qu'ils utilisent une méthode légèrement différente pour leurs estimations - plus de détails sont disponibles sur leur site).
+L'estimation de la consommation d'énergie pour Ethereum provient d'une étude du [CCRI (Crypto Carbon Ratings Institute)](https://carbon-ratings.com). Ils ont généré des estimations ascendantes de la consommation d'électricité et de l'empreinte carbone du réseau Ethereum ([voir le rapport](https://carbon-ratings.com/eth-report-2022)). Ils ont mesuré la consommation d'électricité de différents nœuds avec différentes configurations matérielles et différents logiciels clients. Les **2 601 MWh** (0,0026 TWh) estimés pour la consommation annuelle d'électricité du réseau correspondent à des émissions de carbone annuelles de **870 tonnes d'éq. CO2** en appliquant des facteurs d'intensité carbone spécifiques à chaque région. Cette valeur change au fur et à mesure que les nœuds rejoignent et quittent le réseau. Vous pouvez en suivre l'évolution grâce à une estimation moyenne mobile sur 7 jours fournie par le [Cambridge Blockchain network Sustainability Index](https://ccaf.io/cbnsi/ethereum) (notez qu'ils utilisent une méthode légèrement différente pour leurs estimations, dont les détails sont disponibles sur leur site).
 
 Pour replacer la consommation énergétique d'Ethereum dans son contexte, nous pouvons comparer les estimations annualisées d'autres biens et secteurs industriels. Cela nous aide à mieux comprendre si l'estimation pour Ethereum est élevée ou faible.
 
@@ -16,34 +16,34 @@ Pour replacer la consommation énergétique d'Ethereum dans son contexte, nous p
 
 Le tableau ci-dessous montre la consommation énergétique estimée en TWh/an pour Ethereum, comparée à plusieurs autres biens et secteurs. Les estimations fournies proviennent d'informations publiquement disponibles, consultées en juillet 2023, les liens vers les sources sont disponibles dans le tableau ci-dessous.
 
-|                                | Consommation d’énergie annualisée (TWh) | Comparaison avec Ethereum PoS |                                                                                      Source                                                                                       |
-|:------------------------------ |:---------------------------------------:|:-----------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
-| Centres de données globaux     |                   190                   |           73 000 x            |                                    [source](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches)                                    |
-| Bitcoin                        |                   149                   |           53 000 x            |                                                                 [source](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
-| Extraction d'or                |                   131                   |           50 000 x            |                                                                 [source](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
-| Jeux vidéos aux États-Unis\* |                   34                    |           13 000 x            |                 [source](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential)                 |
-| Ethereum PoW                   |                   21                    |            8 100 x            |                                                                    [source](https://ccaf.io/cbnsi/ethereum/1)                                                                     |
-| Google                         |                   19                    |            7 300 x            |                                           [source](https://www.gstatic.com/gumdrop/sustainability/google-2022-environmental-report.pdf)                                           |
-| Netflix                        |                  0,457                  |             176 x             | [source](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) |
-| PayPal                         |                  0,26                   |             100 x             |                                  [source](https://s202.q4cdn.com/805890769/files/doc_downloads/global-impact/CDP_Climate_Change_PayPal-(1).pdf)                                   |
-| Airbnb                         |                  0,02                   |              8 x              |                               [source](https://s26.q4cdn.com/656283129/files/doc_downloads/governance_doc_updated/Airbnb-ESG-Factsheet-(Final).pdf)                               |
-| **Ethereum PoS**               |               **0,0026**                |            **1 x**            |                                                               [source](https://carbon-ratings.com/eth-report-2022)                                                                |
+|                              | Consommation d’énergie annualisée (TWh) | Comparaison avec Ethereum PoS |                                                                                       Source                                                                                      |
+| :--------------------------- | :--------------------------------------------------------: | :---------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| Centres de données globaux   |                             190                            |            73 000 x           |                                    [source](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches)                                    |
+| Bitcoin                      |                             149                            |            53 000 x           |                                                                 [source](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
+| Extraction d'or              |                             131                            |            50 000 x           |                                                                 [source](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
+| Jeux vidéos aux États-Unis\* |                             34                             |            13 000 x           |                 [source](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential)                 |
+| Ethereum PoW                 |                             21                             |            8 100 x            |                                                                     [source](https://ccaf.io/cbnsi/ethereum/1)                                                                    |
+| Google                       |                             19                             |            7 300 x            |                                           [source](https://www.gstatic.com/gumdrop/sustainability/google-2022-environmental-report.pdf)                                           |
+| Netflix                      |                            0,457                           |             176 x             | [source](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) |
+| PayPal                       |                            0,26                            |             100 x             |                                  [source](https://s202.q4cdn.com/805890769/files/doc_downloads/global-impact/CDP_Climate_Change_PayPal-\(1\).pdf)                                 |
+| Airbnb                       |                            0,02                            |              8 x              |                              [source](https://s26.q4cdn.com/656283129/files/doc_downloads/governance_doc_updated/Airbnb-ESG-Factsheet-\(Final\).pdf)                              |
+| **Ethereum PoS**             |                         **0,0026**                         |             **1x**            |                                                                [source](https://carbon-ratings.com/eth-report-2022)                                                               |
 
 \*Comprend les appareils des utilisateurs finaux tels que les PC, les ordinateurs portables et les consoles de jeu.
 
-Obtenir des estimations précises de la consommation d'énergie est difficile, en particulier lorsque ce qui est mesuré a une chaîne d'approvisionnement complexe ou des caractéristiques de déploiement qui influencent son efficacité. Par exemples : les estimations de consommation d'énergie de Netflix et Google varient selon qu'elles incluent uniquement l'énergie utilisée pour entretenir leurs systèmes et fournir du contenu aux utilisateurs (_dépenses directes_) ou qu'elles incluent les dépenses nécessaires pour produire du contenu, gérer les bureaux de l'entreprise, faire de la publicité, etc (_dépenses indirectes_). Les dépenses indirectes pourraient également inclure l'énergie nécessaire à la consommation de contenu sur les appareils des utilisateurs finaux tels que les téléviseurs, les ordinateurs et les téléphones portables.
+Obtenir des estimations précises de la consommation d'énergie est difficile, en particulier lorsque ce qui est mesuré a une chaîne d'approvisionnement complexe ou des caractéristiques de déploiement qui influencent son efficacité. Par exemple, les estimations de la consommation d'énergie pour Netflix et Google varient selon qu'elles incluent uniquement l'énergie utilisée pour maintenir leurs systèmes et fournir du contenu aux utilisateurs (_dépenses directes_) ou qu'elles incluent les dépenses nécessaires pour produire du contenu, gérer les bureaux de l'entreprise, faire de la publicité, etc. (_dépenses indirectes_). Les dépenses indirectes pourraient également inclure l'énergie nécessaire à la consommation de contenu sur les appareils des utilisateurs finaux tels que les téléviseurs, les ordinateurs et les téléphones portables.
 
 Les estimations ci-dessus ne sont pas des comparaisons parfaites. Le montant des dépenses indirectes prises en compte varie selon la source et inclut rarement l'énergie provenant des appareils des utilisateurs finaux. Chaque source sous-jacente contient plus de détails sur ce qui est mesuré.
 
-Le tableau et le graphique ci-dessus comprennent également des comparaisons avec Bitcoin et Ethereum proof-of-work. Il est important de noter que la consommation d'énergie des réseaux de preuve de travail n'est pas statique et elle évolue au jour le jour. Les estimations peuvent également varier considérablement d'une source à l'autre. Le sujet suscite un [débat](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/) nuancé, non seulement sur la quantité d'énergie consommée, mais aussi sur les sources de cette énergie et l'éthique qui s'y rattache. La consommation d'énergie ne correspond pas nécessairement à l'empreinte environnementale, car différents projets peuvent utiliser différentes sources d'énergie, avec une proportion plus ou moins grande d'énergies renouvelables. Par exemple, le [Cambridge Bitcoin Electricity Consumption Index](https://ccaf.io/cbnsi/cbeci/comparisons) indique que la demande du réseau Bitcoin pourrait théoriquement être alimentée par le brûlage de gaz ou par de l'électricité qui serait autrement perdue lors de la transmission et de la distribution. La voie de la durabilité empruntée par Ethereum a consisté à remplacer la partie du réseau gourmande en énergie par une alternative verte.
+Le tableau et le graphique ci-dessus comprennent également des comparaisons avec Bitcoin et Ethereum proof-of-work. Il est important de noter que la consommation d'énergie des réseaux de preuve de travail n'est pas statique et elle évolue au jour le jour. Les estimations peuvent également varier considérablement d'une source à l'autre. Le sujet suscite un [débat](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/) nuancé, non seulement sur la quantité d'énergie consommée, mais aussi sur les sources de cette énergie et l'éthique qui s'y rattache. La consommation d'énergie ne correspond pas nécessairement à l'empreinte environnementale, car différents projets peuvent utiliser différentes sources d'énergie, avec une proportion plus ou moins grande d'énergies renouvelables. Par exemple, le [Cambridge Bitcoin Electricity Consumption Index](https://ccaf.io/cbnsi/cbeci/comparisons) indique que la demande du réseau Bitcoin pourrait théoriquement être alimentée par le torchage de gaz ou par de l'électricité qui serait autrement perdue lors du transport et de la distribution. La voie de la durabilité empruntée par Ethereum a consisté à remplacer la partie du réseau gourmande en énergie par une alternative verte.
 
-Vous pouvez consulter les estimations de la consommation d'énergie et des émissions de carbone pour de nombreuses industries sur le site [Cambridge Blockchain Network Sustainability Index](https://ccaf.io/cbnsi/ethereum).
+Vous pouvez consulter les estimations de la consommation d'énergie et des émissions de carbone pour de nombreuses industries sur le site du [Cambridge Blockchain Network Sustainability Index](https://ccaf.io/cbnsi/ethereum).
 
 ## Estimations par transaction {#per-transaction-estimates}
 
 De nombreux articles estiment les dépenses énergétiques pour les blockchains « par transaction ». Cela peut être trompeur dans la mesure où l'énergie nécessaire pour proposer et valider un bloc est indépendante du nombre de transactions qu'il contient. Une unité de dépense énergétique par transaction implique qu'un nombre moins élevé de transactions entraînerait une moindre dépense énergétique et vice-versa, ce qui n'est pas le cas. En outre, l'estimation par transaction dépend fortement de la façon dont le débit de transaction d'une blockchain est défini, sachant qu'il est possible de jouer avec cette définition pour que la valeur semble plus ou moins grande.
 
-Sur Ethereum par exemple, le débit de transaction n'est pas seulement celui de la couche de base - c'est aussi la somme du débit de transaction de tous ses rollups de « [couche 2](/layer-2/) ». Les couches 2 ne sont généralement pas incluses dans les calculs, mais la prise en compte de l'énergie supplémentaire consommée par les séquenceurs (faible) et du nombre de transactions qu'ils traitent (élevé) réduirait probablement considérablement les estimations par transaction. C'est l'une des raisons pour lesquelles les comparaisons de consommation d'énergie par transaction entre plateformes peuvent être trompeuses.
+Sur Ethereum, par exemple, le débit de transactions n'est pas seulement celui de la couche de base. C'est aussi la somme du débit de transactions de tous ses rollups de « [couche 2](/layer-2/) ». Les couches 2 ne sont généralement pas incluses dans les calculs, mais la prise en compte de l'énergie supplémentaire consommée par les séquenceurs (faible) et du nombre de transactions qu'ils traitent (élevé) réduirait probablement considérablement les estimations par transaction. C'est l'une des raisons pour lesquelles les comparaisons de consommation d'énergie par transaction entre plateformes peuvent être trompeuses.
 
 ## La dette carbone d'Ethereum {#carbon-debt}
 
@@ -51,15 +51,15 @@ Les dépenses énergétiques d'Ethereum sont très faibles, mais cela n'a pas to
 
 Depuis le tout début, Ethereum prévoyait d'implémenter un mécanisme de consensus par preuve d'enjeu, mais il aura fallu des années de recherches et de développement ciblés pour y parvenir sans sacrifier la sécurité et la décentralisation. C'est pourquoi un mécanisme de preuve de travail a été utilisé pour faire démarrer le réseau. Un consensus de preuve de travail exige que les mineurs utilisent leur matériel informatique pour calculer une valeur, en dépensant de l'énergie pendant le processus.
 
-![Comparaison de la consommation d'énergie d'Ethereum avant et après La Fusion, en utilisant la tour Eiffel (300 mètres de haut) sur la gauche pour symboliser la grande consommation d'énergie avant La Fusion, et une petite figurine Lego de 4 cm de haut sur la droite pour représenter la réduction drastique de consommation d'énergie après La Fusion](energy_consumption_pre_post_merge.png)
+![Comparaison de la consommation d'énergie d'Ethereum avant et après la Fusion, avec la Tour Eiffel (330 mètres de haut) à gauche pour symboliser la forte consommation d'énergie avant la Fusion, et une petite figurine Lego de 4 cm de haut à droite pour représenter la réduction spectaculaire de la consommation d'énergie après la Fusion](energy_consumption_pre_post_merge.png)
 
-Le CCRI évalue que La Fusion a réduit la consommation d'électricité annualisée d'Ethereum de plus de **99.988%**. De même, l'empreinte carbone d'Ethereum a été réduite d'environ **99,992%** (de 11 016 000 à 870 tonnes de CO2e). Pour mettre les choses en perspective, la réduction des émissions équivaut à passer de la hauteur de la Tour Eiffel à celle d'une petite figurine en plastique, comme l'illustre la figure ci-dessus. Par conséquent, le coût environnemental de la sécurisation du réseau est considérablement réduit. Dans le même temps, la sécurité du réseau est présumée s'être améliorée.
+Le CCRI estime que la Fusion a réduit la consommation d'électricité annualisée d'Ethereum de plus de **99,988 %**. De même, l'empreinte carbone d'Ethereum a diminué d'environ **99,992 %** (passant de 11 016 000 à 870 tonnes d'éq. CO2). Pour mettre les choses en perspective, la réduction des émissions équivaut à passer de la hauteur de la Tour Eiffel à celle d'une petite figurine en plastique, comme l'illustre la figure ci-dessus. Par conséquent, le coût environnemental de la sécurisation du réseau est considérablement réduit. Dans le même temps, la sécurité du réseau est présumée s'être améliorée.
 
 ## Une couche d'application verte {#green-applications}
 
-Bien que la consommation d'énergie d'Ethereum soit très faible, il existe également une communauté de [**finance régénérative (ReFi)**](/refi/) substantielle, croissante et très active qui construit sur Ethereum. Les applications ReFi utilisent les composants DeFi pour construire des applications financières qui ont des externalités positives au bénéfice de l'environnement. La ReFi fait partie d'un plus large mouvement [« solarpunk »](https://en.wikipedia.org/wiki/Solarpunk) qui est étroitement aligné avec Ethereum et vise à associer progrès technologiques et gérance environnementale. La nature décentralisée, sans permission et composable d'Ethereum en fait la couche de base idéale pour les communautés ReFi et solarpunk.
+Bien que la consommation d'énergie d'Ethereum soit très faible, il existe également une communauté importante, croissante et très active de [**finance régénérative (ReFi)**](/refi/) qui se développe sur Ethereum. Les applications ReFi utilisent les composants DeFi pour construire des applications financières présentant des externalités positives bénéfiques pour l'environnement. La ReFi fait partie d'un mouvement « [solarpunk](https://en.wikipedia.org/wiki/Solarpunk) » plus large, qui est étroitement aligné sur Ethereum et vise à associer le progrès technologique et la gérance environnementale. La nature décentralisée, sans permission et composable d'Ethereum en fait la couche de base idéale pour les communautés ReFi et solarpunk.
 
-Les plateformes de financement de biens publics natifs Web3 telles que [Gitcoin](https://gitcoin.co) exécutent des rondes climatiques pour stimuler la construction écologique sur la couche d'application d'Ethereum. Grâce au développement de ces initiatives (et d'autres comme par exemple [DeSci](/desci/)), Ethereum est en train de devenir une technologie positive sur le plan environnemental et social.
+Des plateformes de financement de biens publics natifs du Web3 telles que [Gitcoin](https://gitcoin.co) organisent des cycles de financement pour le climat afin de stimuler la construction respectueuse de l'environnement sur la couche d'application d'Ethereum. Grâce au développement de ces initiatives (et d'autres, par exemple, [DeSci](/desci/)), Ethereum est en train de devenir une technologie à impact net positif sur les plans environnemental et social.
 
 <Alert variant="update">
 <AlertEmoji text=":evergreen_tree:" />
@@ -70,17 +70,17 @@ Les plateformes de financement de biens publics natifs Web3 telles que [Gitcoin]
 </AlertContent>
 </Alert>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Index de Durabilité des Réseaux Blockchain de Cambridge](https://ccaf.io/cbnsi/ethereum)
-- [Rapport de la Maison-Blanche sur les blockchains de preuve de travail](https://web.archive.org/web/20221109005700/https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf)
-- [Les Émissions d'Ethereum : une estimation de bas à haut](https://kylemcdonald.github.io/ethereum-emissions/) - _Kyle McDonald_
-- [Index de Consommation d'Énergie d'Ethereum](https://digiconomist.net/ethereum-energy-consumption/) - _Digiconomist_
+- [Cambridge Blockchain Network Sustainability Index](https://ccaf.io/cbnsi/ethereum)
+- [Rapport de la Maison Blanche sur les blockchains à preuve de travail](https://web.archive.org/web/20221109005700/https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf)
+- [Émissions d'Ethereum : une estimation ascendante](https://kylemcdonald.github.io/ethereum-emissions/) - _Kyle McDonald_
+- [Indice de consommation d'énergie d'Ethereum](https://digiconomist.net/ethereum-energy-consumption/) - _Digiconomist_
 - [ETHMerge.com](https://ethmerge.com/) - _[@InsideTheSim](https://twitter.com/InsideTheSim)_
 - [La Fusion - Implications sur la consommation d'électricité et l'empreinte carbone du réseau Ethereum](https://carbon-ratings.com/eth-report-2022) - _CCRI_
-- [Consommation énergétique d'Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8)
+- [Consommation d'énergie d'Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8)
 
 ## Sujets connexes {#related-topics}
 
-- [La chaîne phare](/roadmap/beacon-chain)
+- [La Chaîne Phare](/roadmap/beacon-chain)
 - [La Fusion](/roadmap/merge/)
diff --git a/public/content/translations/fr/eth/supply/index.md b/public/content/translations/fr/eth/supply/index.md
new file mode 100644
index 00000000000..8b33b3d1ef3
--- /dev/null
+++ b/public/content/translations/fr/eth/supply/index.md
@@ -0,0 +1,80 @@
+---
+title: "Comprendre l'offre et l'émission d'ETH"
+description: "Un guide adapté aux débutants sur l'offre et l'émission d'ETH, couvrant des concepts clés tels que les EIP, PoS et EIP-1559."
+lang: fr
+---
+
+# Offre et émission d'ETH {#eth-supply-and-issuance}
+
+## Prérequis {#prerequisites}
+
+Cet article est écrit pour les débutants sans connaissances préalables. Cependant, pour bien comprendre le sujet, il est utile d'avoir une compréhension de base des concepts tels que [les Propositions d'amélioration d'Ethereum (EIPs)](/eips/#introduction-to-ethereum-improvement-proposals), [la Preuve de travail (PoW)](/developers/docs/consensus-mechanisms/pow/), [la Preuve d'enjeu (PoS)](/developers/docs/consensus-mechanisms/pos/) et [la mise à niveau London](/ethereum-forks/#london).
+
+## Combien de jetons ETH existe-t-il aujourd'hui ? {#current-eth-supply}
+
+L'offre totale d'ETH est dynamique et change constamment en raison de deux facteurs principaux :
+
+1. **Émission de la preuve d'enjeu (PoS)** : De nouveaux ETH sont créés comme récompenses pour les validateurs qui sécurisent le réseau
+2. **Brûlage EIP-1559** : Une partie des frais de transaction est définitivement retirée de la circulation
+
+Vous pouvez suivre l'offre actuelle et ces changements en temps réel sur des plateformes comme [Ultrasound Money](https://ultrasound.money).
+
+L'offre et l'émission d'Ethereum sont des paramètres essentiels pour comprendre la santé et l'avenir du réseau. Mais que signifie exactement l'émission d'ETH ? Décomposons cela.
+
+## Pourquoi l'offre et l'émission d'ETH sont importantes {#why-eth-supply-matters}
+
+Dans la finance traditionnelle, les banques centrales contrôlent l'offre de monnaie, souvent en imprimant davantage pour stimuler les économies. Ethereum, en revanche, fonctionne selon un système transparent et prévisible régi par son code. Savoir combien d'ETH existent et à quelle vitesse de nouveaux ETH sont émis aide à :
+
+- **Renforcer la confiance**: La communauté Ethereum peut vérifier les données d'offre et d'émission directement sur la blockchain.
+- **Comprendre la valeur**: La relation entre l'émission et les taux de brûlage d'ETH affecte l'inflation ou la déflation de l'ETH, influençant sa valeur au fil du temps.
+- **Suivre la santé du réseau** : Les changements dans l'émission et les taux de brûlage reflètent l'activité et la sécurité du réseau.
+
+## Qu'est-ce que l'émission d'ETH ? {#eth-issuance}
+
+L'émission d'ETH désigne le processus de création de nouveaux ETH comme récompenses pour les validateurs qui sécurisent le réseau Ethereum. Elle est distincte de l'offre totale, qui représente la quantité totale d'ETH en circulation.
+
+### En termes simples :
+
+- **L'émission** ajoute de nouveaux ETH au réseau.
+- **Le brûlage** (introduit par EIP-1559) retire des ETH du réseau en détruisant une partie des frais de transaction.
+
+Ces deux forces déterminent si l'offre d'Ethereum croît (inflationniste) ou diminue (déflationniste) au fil du temps.
+
+## Offre et émission d'ETH aujourd'hui {#eth-supply-today}
+
+Le système de preuve d'enjeu (PoS) d'Ethereum a considérablement réduit l'émission d'ETH par rapport à son ancien modèle de preuve de travail (PoW). Les validateurs, qui immobilisent des ETH pour sécuriser le réseau, reçoivent des ETH comme récompenses. Vous pouvez voir le taux d'émission actuel sur [Ultrasound Money](https://ultrasound.money).
+
+Cependant, ce nombre est dynamique. Grâce à EIP-1559, lorsque l'activité du réseau est élevée, les taux de brûlage d'ETH peuvent dépasser l'émission, créant un effet déflationniste. Par exemple, pendant les périodes de forte demande, comme les lancements de NFT ou l'activité DeFi, plus d'ETH peut être brûlé qu'émis.
+
+### Outils pour suivre l'offre et l'émission d'ETH :
+
+- [Ultrasound Money](https://ultrasound.money) - Suivi en temps réel de l'offre, de l'émission et des taux de brûlage d'ETH
+- [Etherscan](https://etherscan.io) - Explorateur de blocs avec des paramètres d'offre
+
+## Facteurs influençant l'offre et l'émission future d'ETH {#future-eth-supply}
+
+L'offre future d'Ethereum n'est pas fixe, elle dépend de plusieurs variables :
+
+1. **Participation au staking** :
+   - Plus de validateurs rejoignant le réseau signifie que plus de récompenses en ETH sont distribuées.
+   - Moins de validateurs participants peut réduire l'émission.
+   - En savoir plus sur [le staking](/staking/).
+
+2. **Activité du réseau**:
+   - Des volumes de transactions élevés entraînent le brûlage de plus d'ETH, pouvant compenser ou dépasser l'émission.
+   - En savoir plus sur [les frais de gaz](/developers/docs/gas/) et leur impact sur le brûlage.
+
+3. **Mises à jour du protocole**:
+   - Les futures modifications du code d'Ethereum pourraient ajuster les récompenses de staking ou les mécanismes de brûlage, influençant davantage la dynamique de l'offre.
+   - Restez informé avec [la feuille de route Ethereum](/roadmap/).
+
+## Récapitulatif : Offre, émission et perspectives d'ETH {#recap}
+
+Voici un résumé rapide de ce que vous devez savoir sur l'offre et l'émission d'ETH :
+
+- **Offre d'ETH**: Dynamique et en constante évolution, traçable en temps réel via des outils comme [Ultrasound Money](https://ultrasound.money)
+- **Émission sous PoS** : Considérablement réduite par rapport à PoW, avec des récompenses attribuées aux validateurs. Voir les taux actuels sur [Ultrasound Money](https://ultrasound.money)
+- **Rôle d'EIP-1559** : Le brûlage d'ETH peut rendre le réseau déflationniste pendant les périodes de forte activité
+- **Tendances futures** : La participation au staking, la demande du réseau et les mises à jour du protocole façonneront l'offre d'ETH
+
+Comprendre l'émission d'ETH aide à démystifier la valeur d'Ethereum et son potentiel en tant qu'actif déflationniste et décentralisé. Pour plus d'informations détaillées sur l'impact de la Fusion sur l'offre d'ETH, consultez notre analyse détaillée (/roadmap/merge/issuance/). Curieux de l'avenir d'ETH ? Plongez plus loin avec des outils comme [Ultrasound Money](https://ultrasound.money) ou explorez nos [guides sur le staking](/staking/).
\ No newline at end of file
diff --git a/public/content/translations/fr/ethereum-forks/index.md b/public/content/translations/fr/ethereum-forks/index.md
index a68ba7d4f9c..34c47d58c93 100644
--- a/public/content/translations/fr/ethereum-forks/index.md
+++ b/public/content/translations/fr/ethereum-forks/index.md
@@ -1,79 +1,83 @@
 ---
-title: Histoire et fourches d'Ethereum
-description: Historique de la blockchain Ethereum, y compris les avancées majeures, les événements clés et les fourches.
+title: "Chronologie de toutes les fourches Ethereum (de 2014 à aujourd'hui)"
+description: "Historique de la blockchain Ethereum, y compris les avancées majeures, les versions et les fourches."
 lang: fr
 sidebarDepth: 1
 ---
 
-# Historique d'Ethereum {#the-history-of-ethereum}
+# Chronologie de toutes les fourches Ethereum (de 2014 à aujourd'hui) {#the-history-of-ethereum}
 
 Chronologie de tous les jalons, fourches et mises à jour majeures de la blockchain Ethereum.
 
-<ExpandableCard title="En quoi consistent les fourches ?" contentPreview="Changes to the rules of the Ethereum protocol which often include planned technical upgrades.">
+<ExpandableCard title="Que sont les fourches ?" contentPreview="Modifications des règles du protocole Ethereum, incluant souvent des mises à niveau techniques planifiées.">
 
-Les forks existent lorsque des mises à jour ou des changements techniques majeurs doivent être effectués sur le réseau – ils proviennent généralement des [Propositions d'amélioration d'Ethereum (EIP)](/eips/) et modifient les « règles » du protocole.
+Les forks sont nécessaires lorsque des mises à niveau ou des modifications techniques majeures doivent être apportées au réseau. Elles proviennent généralement de [propositions d'amélioration d'Ethereum (EIP)](/eips/) et modifient les « règles » du protocole.
 
-Lorsque des mises à niveau des logiciels traditionnels contrôlés centralement sont nécessaires, la société publie simplement une nouvelle version pour l'utilisateur final. Les blockchains fonctionnent différemment parce qu'il n'existe pas de propriété centralisée. [Les clients Ethereum](/developers/docs/nodes-and-clients/) doivent mettre à jour leur logiciel pour implémenter les nouvelles règles de la fourche. En outre, les créateurs de blocs (les "mineurs" dans l'univers des preuves de travail, les "validateurs" dans celui des preuves d'enjeu) et les nœuds doivent créer des blocs et les valider conformément aux nouvelles règles. [En savoir plus sur les mécanismes de consensus](/developers/docs/consensus-mechanisms/)
+Lorsque des mises à niveau des logiciels traditionnels contrôlés centralement sont nécessaires, la société publie simplement une nouvelle version pour l'utilisateur final. Les blockchains fonctionnent différemment parce qu'il n'existe pas de propriété centralisée. Les [clients Ethereum](/developers/docs/nodes-and-clients/) doivent mettre à jour leur logiciel pour implémenter les nouvelles règles des fourches. En outre, les créateurs de blocs (les "mineurs" dans l'univers des preuves de travail, les "validateurs" dans celui des preuves d'enjeu) et les nœuds doivent créer des blocs et les valider conformément aux nouvelles règles. [En savoir plus sur les mécanismes de consensus](/developers/docs/consensus-mechanisms/)
 
 Ces changements de règles peuvent créer une scission temporaire dans le réseau. De nouveaux blocs peuvent être produits selon les nouvelles règles ou les anciennes. Les fourches font généralement l'objet d'un accord à l'avance afin que les clients adoptent les changements à l'unisson et que la fourche contenant les mises à niveau devienne la chaîne principale. Toutefois, dans de rares cas, les désaccords sur les forks peuvent causer une séparation permanente du réseau – plus particulièrement la création d'Ethereum Classic avec le <a href="#dao-fork">fork DAO</a>.
-
 </ExpandableCard>
 
-<ExpandableCard title="Pourquoi certaines mises à niveau ont-elles plusieurs noms ?" contentPreview="Upgrades names follow a pattern">
+<ExpandableCard title="Pourquoi certaines mises à niveau ont-elles plusieurs noms ?" contentPreview="Les noms des mises à niveau suivent un modèle">
 
 Le logiciel qui sous-tend Ethereum est composé de deux moitiés, connues sous le nom de [couche d'exécution](/glossary/#execution-layer) et de [couche de consensus](/glossary/#consensus-layer).
 
-**Nom des mises à niveau de la couche d'exécution**
-
-Depuis 2021, les mises à niveau de la **couche d'exécution** sont nommées selon les noms de villes ayant accueilli [les précédents Devcon](https://devcon.org/en/past-events/), dans l'ordre chronologique :
-
-| Nom de la mise à niveau | Année du Devcon | Numéro du Devcon | Date de mise à niveau |
-| ----------------------- | --------------- | ---------------- | --------------------- |
-| Berlin                 | 2014            | 0                | 15 avril 2021         |
-| Londres                 | 2015            | I                | 5 août 2021           |
-| Shanghai               | 2016            | II               | 12 avril 2023         |
-| Cancun                 | 2017            | III              | 13 mars 2024          |
-| **Prague**             | 2018            | IV               | À définir – Prochaine   |
-| _Osaka_                | 2019            | V                | À définir               |
-| _Bogota_               | 2022            | VI               | À définir                |
-| _Bangkok_              | 2024            | VII              | À définir                |
-
-**Nom des mises à niveau de la couche de consensus**
-
-Depuis le lancement de la [chaîne phare](/glossary/#beacon-chain), les mises à niveau de la **couche de consensus** sont nommées d'après des étoiles célestes, en suivant l'ordre alphabétique :
-
-| Nom de la mise à niveau                                      | Date de mise à niveau |
-| ------------------------------------------------------------ | ---------------------- |
-| Genèse de la Beacon Chain                                    | 1er décembre 2020      |
-| [Altair](https://fr.wikipedia.org/wiki/Altair)               | 27 octobre 2021        |
-| [Bellatrix](https://fr.wikipedia.org/wiki/Bellatrix)         | 6 septembre 2022       |
-| [Capella](https://fr.wikipedia.org/wiki/Capella)             | 12 avril 2023          |
-| [Deneb](https://fr.wikipedia.org/wiki/Deneb)                 | 13 mars 2024           |
-| [**Electra**](<https:>) | À définir - Prochaine|
-| [_Fulu_](<https:>)         | À déterminer           |
-
-**Dénomination combiné**
-
-Initialement, les mises à niveau des couches d'exécution et de consensus n'étaient pas déployées simultanément. Mais depuis [La Fusion](/roadmap/merge/) réalisée en 2022,  elles sont déployées simultanément. Ainsi, des termes familiers sont apparus pour simplifier les références à ces mises à niveau en utilisant un seul terme conjoint. Cela a commencé avec la mise à niveau _Shanghai-Capella_, communément appelée "**Shapella**", et se poursuit avec la mise à niveau _Cancun-Deneb_(**Dencun**), puis la mise à niveau Prague-Electra_ (**Pectra**).
-
-| Mise à niveau de l'exécution | Mise à niveau du consensus | Nom abrégé |
-| ----------------- | ----------------- | ---------- |
-| Shanghai          | Capella           | "Shapella" |
-| Cancun            | Deneb             | "Dencun"   |
-| Prague            | Electra           | "Pectra"   |
-| Osaka             | Fulu              | "Fusaka"   |
-
+**Dénomination de la mise à niveau de l'exécution**
+
+Depuis 2021, les mises à niveau de la **couche d’exécution** sont nommées d'après les noms des villes des [précédents lieux de la Devcon](https://devcon.org/en/past-events/) par ordre chronologique :
+
+| Nom de la mise à niveau | Année de la Devcon | Numéro de la Devcon | Date de la mise à niveau     |
+| ----------------------- | ------------------ | ------------------- | ---------------------------- |
+| Berlin                  | 2014               | 0                   | 15 avr. 2021 |
+| London                  | 2015               | I                   | 5 août 2021                  |
+| Shanghai                | 2016               | II                  | 12 avr. 2023 |
+| Cancun                  | 2017               | III                 | 13 mars 2024                 |
+| **Prague**              | 2018               | IV                  | À déterminer - Prochaine     |
+| _Osaka_                 | 2019               | V                   | À déterminer                 |
+| _Bogota_                | 2022               | VI                  | À déterminer                 |
+| _Bangkok_               | 2024               | VII                 | À déterminer                 |
+
+**Dénomination de la mise à niveau du consensus**
+
+Depuis le lancement de la [Chaîne phare](/glossary/#beacon-chain), les mises à niveau de la **couche de consensus** sont nommées d'après des étoiles dont les lettres suivent l'ordre alphabétique :
+
+| Nom de la mise à niveau                                       | Date de la mise à niveau      |
+| ------------------------------------------------------------- | ----------------------------- |
+| Origine de la chaîne phare                                    | 1er déc. 2020 |
+| [Altair](https://en.wikipedia.org/wiki/Altair)                | 27 oct. 2021  |
+| [Bellatrix](https://en.wikipedia.org/wiki/Bellatrix)          | 6 sept. 2022  |
+| [Capella](https://en.wikipedia.org/wiki/Capella)              | 12 avr. 2023  |
+| [Deneb](https://en.wikipedia.org/wiki/Deneb)                  | 13 mars 2024                  |
+| [**Electra**](https://en.wikipedia.org/wiki/Electra_\(star\)) | À déterminer - Prochaine      |
+| [_Fulu_](https://en.wikipedia.org/wiki/Fulu_\(star\))         | À déterminer                  |
+
+**Dénomination combinée**
+
+Les mises à niveau de l'exécution et du consensus ont d'abord été déployées à des moments différents, mais après [La Fusion](/roadmap/merge/) en 2022, elles ont été déployées simultanément. Ainsi, des termes familiers sont apparus pour simplifier les références à ces mises à niveau en utilisant un seul terme conjoint. Cela a commencé avec la mise à niveau _Shanghai-Capella_, communément appelée "**Shapella**", et se poursuit avec la mise à niveau _Cancun-Deneb_(**Dencun**), puis la mise à niveau Prague-Electra_ (**Pectra**).
+
+| Mise à niveau de l'exécution | Mise à niveau du consensus | Nom abrégé   |
+| ---------------------------- | -------------------------- | ------------ |
+| Shanghai                     | Capella                    | « Shapella » |
+| Cancun                       | Deneb                      | « Dencun »   |
+| Prague                       | Electra                    | "Pectra"     |
+| Osaka                        | Fulu                       | « Fusaka »   |
 </ExpandableCard>
 
-Passer directement à l'information sur certaines des mises à jour passées particulièrement importantes : [La Chaîne phare](/roadmap/beacon-chain/); [La Fusion](/roadmap/merge/); et [EIP-1559](#london)
+Accédez directement aux informations sur certaines des mises à niveau passées particulièrement importantes : [la Chaîne phare](/roadmap/beacon-chain/) ; [La Fusion](/roadmap/merge/) ; et [EIP-1559](#london)
 
-Vous cherchez les prochaines mises à jour de protocole ? [Découvrez les mises à jour à venir sur la feuille de route Ethereum](/roadmap/).
+Vous cherchez les prochaines mises à jour de protocole ? [En savoir plus sur les mises à niveau à venir sur la feuille de route d'Ethereum](/roadmap/).
 
 <Divider />
 
 ## 2025 {#2025}
 
-### Prague-Electra ("Pectra") {#pectra}
+### Fulu-Osaka (« Fusaka ») {#fusaka}
+
+<NetworkUpgradeSummary name="fusaka" />
+
+[En savoir plus sur Fusaka](/roadmap/fusaka/)
+
+### Prague-Electra (« Pectra ») {#pectra}
 
 <NetworkUpgradeSummary name="pectra" />
 
@@ -81,9 +85,9 @@ La mise à jour Prague-Electra (« Pectra ») a introduit plusieurs amélioratio
 
 La mise en jeu a été améliorée grâce à l’introduction de comptes de capitalisation de validateurs et à un meilleur contrôle des fonds mis en jeu via l’adresse de retrait d’exécution. L'EIP-7251 a augmenté le solde effectif maximal pour un validateur unique à 2048 ETH, améliorant ainsi l'efficacité du capital pour les validateurs. L'EIP-7002 a permis à un compte d'exécution de déclencher en toute sécurité des actions de validation, comme la sortie ou le retrait partiel des fonds, améliorant l’expérience des validateurs d'ETH tout en renforçant la responsabilité des opérateurs de nœuds.
 
-D'autres aspects de la mise à jour avaient pour objectif d'améliorer l'expérience des utilisateurs réguliers. L’EIP-7702 a introduit la possibilité pour un compte classique ne disposant pas de contrat intelligent ([EOA](/glossary/#eoa)) d’exécuter du code de manière similaire à un contrat intelligent. Cela a débloqué une multitude de nouvelles fonctionnalités pour les comptes Ethereum traditionnels, telles que le regroupement de transactions, le parrainage des frais de gaz, l’authentification alternative, le contrôle programmable des dépenses, des mécanismes de récupération de compte, et bien plus encore.
+D'autres aspects de la mise à jour avaient pour objectif d'améliorer l'expérience des utilisateurs réguliers. L'EIP-7702 a permis à un compte ordinaire sans contrat intelligent ([EOA](/glossary/#eoa)) d'exécuter du code de manière similaire à un contrat intelligent. Cela a débloqué une multitude de nouvelles fonctionnalités pour les comptes Ethereum traditionnels, telles que le regroupement de transactions, le parrainage des frais de gaz, l’authentification alternative, le contrôle programmable des dépenses, des mécanismes de récupération de compte, et bien plus encore.
 
-<ExpandableCard title="EIP de Pectra" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de Pectra" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 Meilleure expérience utilisateur :
 
@@ -110,29 +114,28 @@ Améliorations de l'efficacité et de la sécurité du protocole :
   <li><a href="https://eips.ethereum.org/EIPS/eip-2935">EIP-2935</a> - <em>Enregistrer les hachages des blocs historiques dans l'état</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-7549">EIP-7549</a> : <em>Déplacer l'index du comité en dehors de l'Attestation</em></li>
 </ul>
-
 </ExpandableCard>
 
 - [Pectra.wtf](https://pectra.wtf)
-- [Comment Pectra améliorera l'expérience de mise en jeu](https://www.kiln.fi/post/next-ethereum-upgrade-how-pectra-will-enhance-the-staking-experience)
-- [Lire les spécifications de la mise à niveau Electra](https://github.com/ethereum/consensus-specs/tree/master/specs/electra/)
-- [FAQ Prague-Electra ("Pectra")](/roadmap/pectra/)
+- [Comment Pectra améliorera l'expérience de la mise en jeu](https://www.kiln.fi/post/next-ethereum-upgrade-how-pectra-will-enhance-the-staking-experience)
+- [Lire les spécifications de la mise à niveau Electra](https://github.com/ethereum/consensus-specs/blob/master/specs/electra/)
+- [FAQ sur Prague-Electra (« Pectra »)](/roadmap/pectra/)
 
 <Divider />
 
 ## 2024 {#2024}
 
-### Cancun-Deneb ("Dencun") {#dencun}
+### Cancun-Deneb (« Dencun ») {#dencun}
 
 <NetworkUpgradeSummary name="dencun" />
 
 #### Résumé de Cancun {#cancun-summary}
 
-La mise à niveau Cancun contient un ensemble d'améliorations pour l'_exécution_ d'Ethereum destiné à l'amélioration de l'évolutivité, en association avec les mises à niveau de consensus Deneb.
+La mise à niveau Cancun contient un ensemble d'améliorations de l'_exécution_ d'Ethereum visant à améliorer l'évolutivité, en tandem avec les mises à niveau du consensus Deneb.
 
-Cela inclut notamment EIP-4844, connu comme **Proto-Danksharding**, qui réduit significativement le coût du stockage de données pour les rollups de seconde couche. Cela est réalisé grâce à l'introduction de "blobs" de données qui permettent aux rollups d'envoyer des données sur le Réseau principal pendant une courte période de temps. Il en résulte une diminution significative des frais de transactions pour les utilisateurs de rollups de seconde couche.
+Elle inclut notamment l'EIP-4844, connu sous le nom de **Proto-Danksharding**, qui diminue de manière significative le coût du stockage des données pour les rollups de couche 2. Cela est réalisé grâce à l'introduction de "blobs" de données qui permettent aux rollups d'envoyer des données sur le Réseau principal pendant une courte période de temps. Il en résulte une diminution significative des frais de transactions pour les utilisateurs de rollups de seconde couche.
 
-<ExpandableCard title="EIP de Cancun" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de Cancun" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-1153">EIP-1153</a> - <em> Codes d'opération de stockage transitoire</em></li>
@@ -142,13 +145,12 @@ Cela inclut notamment EIP-4844, connu comme **Proto-Danksharding**, qui réduit
   <li><a href="https://eips.ethereum.org/EIPS/eip-6780">EIP-6780</a> - <em><code>SELFDESTRUCT</code> uniquement dans la même transaction</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-7516">EIP-7516</a> - <em><code>BLOBBASEFEE</code> opcode</em></li>
 </ul>
-
 </ExpandableCard>
 
-- [Les rollups de couche 2](/layer-2/)
+- [Rollups de couche 2](/layer-2/)
 - [Proto-Danksharding](/roadmap/scaling/#proto-danksharding)
 - [Danksharding](/roadmap/danksharding/)
-- [Lire les spécifications de la mise à jour Cancun](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md)
+- [Lire la spécification de la mise à niveau Cancun](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md)
 
 #### Résumé de Deneb {#deneb-summary}
 
@@ -156,9 +158,9 @@ La mise à niveau Deneb contient un ensemble d'améliorations du _consensus_ d'E
 
 Les "messages de sortie volontaire" n'expirent plus, donnant ainsi plus de contrôle aux utilisateurs mettant en jeu leurs fonds auprès d'un opérateur de nœud tiers. Avec ce message de sortie signé, les validateurs peuvent déléguer les opérations de noeud tout en maintenant leur capacité de se retirer en toute sécurité et de retirer leurs fonds à tout moment, sans avoir à demander la permission à quiconque.
 
-EIP-7514 apporte une restriction de la distribution d'ETH en limitant le taux de "churn", afin que les validateurs rejoignent le réseau par groupe de huit (8) maximum pour chaque période. Dans la mesure où la distribution de l'ETH est proportionnelle à la totalité des ETH mis en jeu, limiter le nombre de validateurs bloque la _croissance_ d'ETH nouvellement distribués, tout en réduisant les besoins en matériel informatique pour les opérateurs de noeud, aidant ainsi la décentralisation.
+EIP-7514 apporte une restriction de la distribution d'ETH en limitant le taux de "churn", afin que les validateurs rejoignent le réseau par groupe de huit (8) maximum pour chaque période. Comme l'émission d'ETH est proportionnelle au total des ETH mis en jeu, la limitation du nombre de validateurs qui rejoignent le réseau plafonne le _taux de croissance_ des nouveaux ETH émis, tout en réduisant les exigences matérielles pour les opérateurs de nœuds, ce qui favorise la décentralisation.
 
-<ExpandableCard title="EIP de Deneb" contentPreview="Official improvements included in this upgrade">
+<ExpandableCard title="EIP de Deneb" contentPreview="Améliorations officielles incluses dans cette mise à niveau">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-4788">EIP-4788</a> - <em>Racine du bloc phare dans l'EVM</em></li>
@@ -167,17 +169,16 @@ EIP-7514 apporte une restriction de la distribution d'ETH en limitant le taux de
   <li><a href="https://eips.ethereum.org/EIPS/eip-7045">EIP-7045</a> - <em>Augmentation de l'attestation maximale du créneau d'inclusion</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-7514">EIP-7514</a> - <em>Ajout d'une limite maximale de changement par époque</em></li>
 </ul>
-
 </ExpandableCard>
 
-- [Lire les spécifications de la mise à jour Deneb](https://github.com/ethereum/consensus-specs/tree/master/specs/deneb/)
-- [FAQ Cancun-Deneb ("Dencun")](/roadmap/dencun/)
+- [Lire les spécifications de la mise à niveau Deneb](https://github.com/ethereum/consensus-specs/blob/master/specs/deneb/)
+- [FAQ sur Cancun-Deneb (« Dencun »)](/roadmap/dencun/)
 
 <Divider />
 
 ## 2023 {#2023}
 
-### Shanghai-Capella ("Shapella") {#shapella}
+### Shanghai-Capella (« Shapella ») {#shapella}
 
 <NetworkUpgradeSummary name="shapella" />
 
@@ -185,7 +186,7 @@ EIP-7514 apporte une restriction de la distribution d'ETH en limitant le taux de
 
 La mise à jour Shanghai a ouvert la voie à des opérations de retrait et de basculement vers la couche d'exécution Couplée à la mise à jour Capella, cette mise à jour permet aux blocs d'accepter des opérations de retrait, permettant ainsi aux validateurs de retirer leur ETH de la chaîne phare et de le basculer vers la couche d'exécution.
 
-<ExpandableCard title="EIP Shanghai" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de Shanghai" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-3651">EIP-3651</a> – <em>Démarre l'adresse <code>COINBASE</code> </em></li>
@@ -194,10 +195,9 @@ La mise à jour Shanghai a ouvert la voie à des opérations de retrait et de ba
   <li><a href="https://eips.ethereum.org/EIPS/eip-4895">EIP-4895</a> – <em>Retraits de la chaîne phare en tant qu'opérations</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-6049">L'EIP-6049</a> - <em>Désapprouve <code>SELFDESTRUCT</code></em></li>
 </ul>
-
 </ExpandableCard>
 
-- [Lire les spécificités de la mise à jour Shanghai](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md)
+- [Lire la spécification de la mise à niveau Shanghai](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md)
 
 #### Résumé de Capella {#capella-summary}
 
@@ -207,8 +207,8 @@ Cette mise à jour de la couche de consensus a permis aux validateurs, qui n'ava
 
 La mise à jour a également permis la mise en place d'une fonctionnalité de balayage automatique de compte, qui traite continuellement les comptes de validateur pour tout paiement de récompenses ou retrait intégral disponible.
 
-- [En savoir plus sur les retraits de mise en jeu](/staking/withdrawals/).
-- [Lire les spécifications de la mise à jour Capella](https://github.com/ethereum/consensus-specs/tree/master/specs/capella/)
+- [En savoir plus sur les retraits](/staking/withdrawals/).
+- [Lire les spécifications de la mise à niveau Capella](https://github.com/ethereum/consensus-specs/blob/master/specs/capella/)
 
 <Divider />
 
@@ -220,17 +220,16 @@ La mise à jour a également permis la mise en place d'une fonctionnalité de ba
 
 #### Résumé {#paris-summary}
 
-La mise à jour de Paris a été déclenchée par le passage de la blockchain de preuve de travail à une [difficulté totale finale](/glossary/#terminal-total-difficulty) de 5875000000000000000. Cela s'est produit au bloc 15537393 le 15 septembre 2022, déclenchant la mise à jour du bloc suivant. Paris était la transition vers la [La Fusion](/roadmap/merge/) : sa principale fonctionnalité était de désactiver l'algorithme de minage [preuve de travail](/developers/docs/consensus-mechanisms/pow) et sa logique de consensus associée et d'activer la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) à la place. Paris lui-même était une mise à jour vers les [clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) (équivalent de Bellatrix sur la couche de consensus) qui leur permettait de recevoir des instructions depuis leurs [clients de consensus](/developers/docs/nodes-and-clients/#consensus-clients) connectés. Cela nécessitait d'activer un nouvel ensemble de méthodes internes d'API, collectivement connues sous le nom d'[API Moteur](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). C'est sans doute la mise à jour la plus significative de l'histoire d'Ethereum depuis [Homestead](#homestead) !
+La mise à niveau Paris a été déclenchée par la blockchain en preuve de travail qui a dépassé une [difficulté totale terminale](/glossary/#terminal-total-difficulty) de 58750000000000000000000. Cela s'est produit au bloc 15537393 le 15 septembre 2022, déclenchant la mise à jour du bloc suivant. Paris était la transition de [La Fusion](/roadmap/merge/) - sa principale caractéristique était la désactivation de l'algorithme de minage par [preuve de travail](/developers/docs/consensus-mechanisms/pow) et de la logique de consensus associée, et l'activation de la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos) à la place. Paris elle-même était une mise à niveau des [clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) (équivalente à Bellatrix sur la couche de consensus) qui leur permettait de recevoir des instructions de leurs [clients de consensus](/developers/docs/nodes-and-clients/#consensus-clients) connectés. Cela a nécessité l'activation d'un nouvel ensemble de méthodes API internes, collectivement connues sous le nom d'[Engine API](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). C'était sans doute la mise à niveau la plus importante de l'histoire d'Ethereum depuis [Homestead](#homestead) !
 
-- [Lisez la spécification de la mise à jour Paris](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md)
+- [Lire la spécification de la mise à niveau Paris](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md)
 
-<ExpandableCard title="EIP Paris" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de Paris" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-3675">EIP-3675</a> – <em>Mise à niveau du consensus vers la preuve d'enjeu</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-4399">L'EIP-4399</a> – <em>Supplante le code d'opération DIFFICULTY par PREVRANDAO</em></li>
 </ul>
-
 </ExpandableCard>
 
 ---
@@ -241,9 +240,9 @@ La mise à jour de Paris a été déclenchée par le passage de la blockchain de
 
 #### Résumé {#bellatrix-summary}
 
-La mise à jour de Bellatrix était la seconde mise à jour planifiée pour la [Chaîne Phare](/roadmap/beacon-chain), préparant la chaîne à [La Fusion](/roadmap/merge/). Elle porte les pénalités de validateur à leurs valeurs maximales en cas d'inactivité ou d'infractions sanctionnables. Bellatrix inclut également une mise à jour des règles de choix de fourche pour préparer la chaîne à La Fusion et à la transition du dernier bloc de preuve de travail vers le premier bloc de preuve d'enjeu. Cela inclut la sensibilisation des clients de consensus à la [difficulté totale du terminal](/glossary/#terminal-total-difficulty) de 5875000000000000000.
+La mise à niveau Bellatrix était la deuxième mise à niveau planifiée pour la [Chaîne phare](/roadmap/beacon-chain), préparant la chaîne pour [La Fusion](/roadmap/merge/). Elle porte les pénalités de validateur à leurs valeurs maximales en cas d'inactivité ou d'infractions sanctionnables. Bellatrix inclut également une mise à jour des règles de choix de fourche pour préparer la chaîne à La Fusion et à la transition du dernier bloc de preuve de travail vers le premier bloc de preuve d'enjeu. Cela inclut la sensibilisation des clients de consensus à la [difficulté totale terminale](/glossary/#terminal-total-difficulty) de 58750000000000000000000.
 
-- [Lire les spécifications de la mise à niveau Bellatrix](https://github.com/ethereum/consensus-specs/tree/master/specs/bellatrix)
+- [Lire la spécification de la mise à niveau Bellatrix](https://github.com/ethereum/consensus-specs/tree/master/specs/bellatrix)
 
 ---
 
@@ -253,16 +252,15 @@ La mise à jour de Bellatrix était la seconde mise à jour planifiée pour la [
 
 #### Résumé {#gray-glacier-summary}
 
-La mise à niveau Gray Glacier a retardé le déclenchement de la [bombe de difficulté](/glossary/#difficulty-bomb) de trois mois. Il s'agit de la seule modification apportée par cette mise à niveau. En essence, elle est donc très semblable aux mises à niveau [Arrow Glacier](#arrow-glacier) et [Muir Glacier](#muir-glacier). Des changements similaires avaient également été effectués lors des mises à niveau [Byzantium](#byzantium), [Constantinople](#constantinople) et [London](#london).
+La mise à niveau du réseau Gray Glacier a repoussé la [bombe de difficulté](/glossary/#difficulty-bomb) de trois mois. C'est le seul changement introduit dans cette mise à niveau, et il est de nature similaire aux mises à niveau [Arrow Glacier](#arrow-glacier) et [Muir Glacier](#muir-glacier). Des changements similaires ont été effectués sur les mises à niveau du réseau [Byzantium](#byzantium), [Constantinople](#constantinople) et [London](#london).
 
-- [Blog de l'Ethereum Foundation - Annonce de la mise à niveau Gray Glacier](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement)
+- [Blog de l'EF - Annonce de la mise à niveau Gray Glacier](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement/)
 
-<ExpandableCard title="Les EIP de Gray Glacier" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de Gray Glacier" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-5133">EIP-5133</a> – <em>repousse l'explosion de la bombe de difficulté d'ici à septembre 2022</em></li>
 </ul>
-
 </ExpandableCard>
 
 <Divider />
@@ -275,17 +273,16 @@ La mise à niveau Gray Glacier a retardé le déclenchement de la [bombe de diff
 
 #### Résumé {#arrow-glacier-summary}
 
-La mise à niveau Arrow Glacier a retardé le déclenchement de la [bombe de difficulté](/glossary/#difficulty-bomb) de plusieurs mois. Il s'agit de la seule modification apportée par cette mise à niveau. En essence, elle est donc très semblable à la mise à niveau [Muir Glacier](#muir-glacier). Des changements similaires avaient également été effectués lors des mises à niveau [Byzantium](#byzantium), [Constantinople](#constantinople) et [London](#london).
+La mise à niveau du réseau Arrow Glacier a repoussé la [bombe de difficulté](/glossary/#difficulty-bomb) de plusieurs mois. C'est le seul changement introduit dans cette mise à niveau, et il est de nature similaire à la mise à niveau [Muir Glacier](#muir-glacier). Des changements similaires ont été effectués sur les mises à niveau du réseau [Byzantium](#byzantium), [Constantinople](#constantinople) et [London](#london).
 
-- [Blog de l'Ethereum Foundation - Annonce de la mise à niveau Arrow Glacier](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement)
-- [Ethereum Cat Herders - Mise à niveau Ethereum Arrow Glacier](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002)
+- [Blog de l'EF - Annonce de la mise à niveau Arrow Glacier](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement/)
+- [Ethereum Cat Herders - Mise à niveau Arrow Glacier d'Ethereum](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002)
 
-<ExpandableCard title="EIP Arrow Glacier" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP d'Arrow Glacier" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-4345">EIP-4345</a> – <em>reporte la bombe de difficulté jusqu'en juin 2022</em></li>
 </ul>
-
 </ExpandableCard>
 
 ---
@@ -296,15 +293,15 @@ La mise à niveau Arrow Glacier a retardé le déclenchement de la [bombe de dif
 
 #### Résumé {#altair-summary}
 
-La mise à niveau Altair était la première mise à niveau répertoriée pour la [chaîne phare](/roadmap/beacon-chain). La prise en charge des « comités de synchronisation » a été ajoutée, autorisant d'une part les clients légers et augmentant d'autre part les pénalités d'inactivité et de délestage des validateurs à mesure que le système évoluait vers la fusion.
+La mise à niveau Altair était la première mise à niveau planifiée pour la [Chaîne phare](/roadmap/beacon-chain). La prise en charge des « comités de synchronisation » a été ajoutée, autorisant d'une part les clients légers et augmentant d'autre part les pénalités d'inactivité et de délestage des validateurs à mesure que le système évoluait vers la fusion.
 
-- [Lire les spécifications de la mise à niveau Altair](https://github.com/ethereum/consensus-specs/tree/master/specs/altair)
+- [Lire la spécification de la mise à niveau Altair](https://github.com/ethereum/consensus-specs/tree/master/specs/altair)
 
-#### <emoji text=":tada:" size={1} classname="me-2" />Anecdote ! {#altair-fun-fact}
+#### <Emoji text=":tada:" size={1} className="me-2" />Anecdote ! {#altair-fun-fact}
 
 Altair a été la première mise à jour majeure du réseau à disposer d'un délai de mise en œuvre précis. Toutes les mises à niveau antérieures étaient basées sur un numéro de bloc déclaré sur la chaîne de preuve de travail, dans laquelle les durées de blocage varient. La chaîne phare ne nécessite pas de résoudre de preuve de travail, mais fonctionne sur la base d'un système de périodes composées de 32 créneaux de 12 secondes pendant lesquels les validateurs peuvent proposer des blocs. C'est pourquoi nous savions exactement quand nous atteindrions l'époque 74 240 et la date de sortie d'Altair !
 
-- [Durée de blocage](/developers/docs/blocks/#block-time)
+- [Temps de bloc](/developers/docs/blocks/#block-time)
 
 ---
 
@@ -314,36 +311,35 @@ Altair a été la première mise à jour majeure du réseau à disposer d'un dé
 
 #### Résumé {#london-summary}
 
-La mise à niveau London a introduit [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), qui a réorganisé le marché des frais de transaction, ainsi que des changements dans le traitement des remboursements de gaz et le calendrier [Ice Age](/glossary/#ice-age).
+La mise à niveau London a introduit l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), qui a réformé le marché des frais de transaction, ainsi que des changements dans la manière dont les remboursements de gaz sont gérés et le calendrier de l'[Ice Age](/glossary/#ice-age).
 
 #### Qu'est-ce que la mise à niveau de Londres / EIP-1559 ? {#eip-1559}
 
 Avant la mise à jour de Londres, Ethereum avait des blocs de taille fixe. En période de forte demande du réseau, ces blocs fonctionnaient à pleine capacité. En conséquence, les utilisateurs devaient souvent attendre que la demande diminue pour être inclus dans un bloc, ce qui entraînait une mauvaise expérience utilisateur. La mise à niveau de Londres a permis d'introduire des blocs de taille variable dans Ethereum.
 
-Dans le cadre de la [mise à niveau de Londres](/ethereum-forks/#london) d'août 2021, le mode de calcul des frais de transaction sur le réseau Ethereum a été modifié. Avant la mise à niveau de Londres, les frais étaient calculés sans distinguer les frais de `base` et de `priority`, comme suit :
+La manière dont les frais de transaction sur le réseau Ethereum étaient calculés a changé avec [la mise à niveau London](/ethereum-forks/#london) d'août 2021. Avant la mise à niveau London, les frais étaient calculés sans séparer les frais de `base` et de `priorité`, comme suit :
 
 Disons qu'Alice devait payer à Marc la somme d'1 ETH. Dans la transaction, la limite de gaz est de 21 000 unités et le prix du gaz est de 200 gwei.
 
-Les frais totaux auraient été les suivants : `Gas units (limit) * Gas price per unit` (unités de gaz (limite) * Prix du gaz par unité) soit `21 000 * 200 = 4 200 000 gwei` ou 0,0042 ETH
+Le total des frais aurait été de : `Unités de gaz (limite) * Prix du gaz par unité`, c'est-à-dire `21 000 * 200 = 4 200 000 gwei` ou 0,0042 ETH
 
-La mise en œuvre de [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) dans la mise à niveau de Londres a rendu le mécanisme de frais de transaction plus complexe, mais a rendu les frais de gaz plus prévisibles, ce qui s'est traduit par un marché des frais de transaction plus efficace. Les utilisateurs peuvent soumettre des transactions avec un`maxFeePerGas`, correspondant au montant qu'ils sont prêts à payer pour l'exécution de la transaction, et ce, en sachant qu'ils ne paieront pas plus que le prix du marché pour le gaz (`baseFeePerGas`), et qu'ils se feront rembourser tout excédent, moins leur pourboire.
+La mise en œuvre de l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) dans la mise à niveau London a rendu le mécanisme des frais de transaction plus complexe, mais a rendu les frais de gaz plus prévisibles, ce qui a abouti à un marché des frais de transaction plus efficace. Les utilisateurs peuvent soumettre des transactions avec un `maxFeePerGas` correspondant au montant qu'ils sont prêts à payer pour que la transaction soit exécutée, sachant qu'ils ne paieront pas plus que le prix du marché pour le gaz (`baseFeePerGas`), et que tout supplément, moins leur pourboire, leur sera remboursé.
 
-Cette vidéo explique l'EIP-1559 et les avantages qu'elle apporte : [EIP-1559 expliqué](https://www.youtube.com/watch?v=MGemhK9t44Q)
+Cette vidéo explique l'EIP-1559 et les avantages qu'il apporte : [EIP-1559 expliqué](https://www.youtube.com/watch?v=MGemhK9t44Q)
 
-- [Êtes-vous un développeur d'applications décentralisées ? Assurez-vous de mettre à niveau vos bibliothèques et vos outils.](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/london-ecosystem-readiness.md)
-- [Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement)
-- [Lire l'explication du site Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41)
+- [Êtes-vous un développeur de dapps ? Assurez-vous de mettre à niveau vos bibliothèques et vos outils.](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/london-ecosystem-readiness.md)
+- [Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement/)
+- [Lire l'explication d'Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41)
 
-<ExpandableCard title="EIP de London" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de London" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-1559">EIP-1559</a> – <em>améliore le marché des frais de transaction</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-3198">EIP-3198</a> – <em>permet le renvoi de <code>BASEFEE</code> depuis un bloc</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-3529">EIP-3529</a> - <em>réduit les remboursements de gas associés aux opérations de la machine virtuelle d'Ethereum (EVM)</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-3541">EIP-3541</a> - <em>empêche le déploiement de contrats commençant par <code>0xEF</code></em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-3554">EIP-3554</a> – <em>prévoit de repousser l'Ce Age jusqu'au mois de décembre 2021</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3554">EIP-3554</a> – <em>prévoit de repousser l'Ice Age jusqu'au mois de décembre 2021</em></li>
 </ul>
-
 </ExpandableCard>
 
 ---
@@ -356,10 +352,10 @@ Cette vidéo explique l'EIP-1559 et les avantages qu'elle apporte : [EIP-1559 ex
 
 La mise à niveau Berlin a optimisé le coût en gaz de certaines actions EVM et augmenté la prise en charge de plusieurs types de transactions.
 
-- [Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement)
-- [Lire l'explication du site Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80)
+- [Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement/)
+- [Lire l'explication d'Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80)
 
-<ExpandableCard title="EIP de Berlin" contentPreview="Official improvements included in this upgrade.">
+<ExpandableCard title="EIP de Berlin" contentPreview="Améliorations officielles incluses dans cette mise à niveau.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-2565">EIP-2565</a> – <em>revoit à la baisse les coûts en gas ModExp</em></li>
@@ -367,38 +363,37 @@ La mise à niveau Berlin a optimisé le coût en gaz de certaines actions EVM et
   <li><a href="https://eips.ethereum.org/EIPS/eip-2929">L'EIP-2929</a> – <em>revoit ses tarifs en gas à la hausse, pour les codes d'opération d'accès à l'état</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-2930">EIP-2930</a> – <em>ajoute des listes d'accès facultatives</em></li>
 </ul>
-
 </ExpandableCard>
 
 <Divider />
 
 ## 2020 {#2020}
 
-### Origine de la chaîne phare {#beacon-chain-genesis}
+### Genèse de la Chaîne phare {#beacon-chain-genesis}
 
 <NetworkUpgradeSummary name="beaconChainGenesis" />
 
 #### Résumé {#beacon-chain-genesis-summary}
 
-La [chaîne phare](/roadmap/beacon-chain/) avait besoin de 16 384 dépôts de 32 ETH mis en jeu pour être déployée en toute sécurité. Cela s'est produit le 27 novembre, de sorte que la chaîne phare a commencé à produire des blocs le 1er décembre 2020. Ce fut une première étape importante dans la réalisation de la [vision Ethereum](/roadmap/).
+La [Chaîne phare](/roadmap/beacon-chain/) avait besoin de 16 384 dépôts de 32 ETH mis en jeu pour être lancée en toute sécurité. Cela s'est produit le 27 novembre, et la Chaîne phare a commencé à produire des blocs le 1er décembre 2020.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2020/11/27/eth2-quick-update-no-21)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2020/11/27/eth2-quick-update-no-21/)
 
 <DocLink href="/roadmap/beacon-chain/">
-  La chaîne phare
+  La Chaîne phare
 </DocLink>
 
 ---
 
-### Contrat de dépôt de mise en jeu déployé {#staking-deposit-contract}
+### Déploiement du contrat de dépôt de mise en jeu {#staking-deposit-contract}
 
 <NetworkUpgradeSummary name="stakingDepositContractDeployed" />
 
 #### Résumé {#deposit-contract-summary}
 
-Le contrat de dépôt de mise en jeu a introduit la [mise en jeu](/glossary/#staking) dans l'écosystème Ethereum. Bien qu'il s'agisse d'un contrat sur le [réseau principal](/glossary/#mainnet), il a eu des conséquences directes sur le calendrier de lancement de la [chaîne phare](/roadmap/beacon-chain/), une importante [mise à niveau d'Ethereum](/roadmap/).
+Le contrat de dépôt de mise en jeu a introduit la [mise en jeu](/glossary/#staking) dans l'écosystème Ethereum. Bien qu'il s'agisse d'un contrat du [réseau principal](/glossary/#mainnet), il a eu un impact direct sur le calendrier de lancement de la [Chaîne phare](/roadmap/beacon-chain/), une importante [mise à niveau d'Ethereum](/roadmap/).
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2020/11/04/eth2-quick-update-no-19)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2020/11/04/eth2-quick-update-no-19/)
 
 <DocLink href="/staking/">
   Mise en jeu
@@ -412,17 +407,16 @@ Le contrat de dépôt de mise en jeu a introduit la [mise en jeu](/glossary/#sta
 
 #### Résumé {#muir-glacier-summary}
 
-La fourche Muir Glacier a entraîné un report de la [bombe de difficulté](/glossary/#difficulty-bomb). L'augmentation de la difficulté des blocs du mécanisme de consensus de [preuve de travail](/developers/docs/consensus-mechanisms/pow/) menaçait de dégrader l'utilisation d'Ethereum en allongeant les temps d'attente pour l'envoi de transactions et l'utilisation d'applications décentralisées.
+La fourche Muir Glacier a introduit un délai pour la [bombe de difficulté](/glossary/#difficulty-bomb). L'augmentation de la difficulté des blocs du mécanisme de consensus de la [preuve de travail](/developers/docs/consensus-mechanisms/pow/) menaçait de dégrader la facilité d'utilisation d'Ethereum en augmentant les temps d'attente pour l'envoi de transactions et l'utilisation de dapps.
 
-- [Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement)
-- [Lire l'explication du site Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210)
+- [Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement/)
+- [Lire l'explication d'Ethereum Cat Herders](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210)
 
-<ExpandableCard title="Les EIP de Muir Glacier" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP de Muir Glacier" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-2384">EIP-2384</a> – <em>retarde la bombe de difficulté pour 4 000 000 autres blocs, ou ~611 jours.</em></li>
 </ul>
-
 </ExpandableCard>
 
 <Divider />
@@ -437,25 +431,24 @@ La fourche Muir Glacier a entraîné un report de la [bombe de difficulté](/glo
 
 La fourche Istanbul a :
 
-- optimisé le coût de [gaz](/glossary/#gas) de certaines actions dans l'[EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine) ;
+- A optimisé le coût en [gaz](/glossary/#gas) de certaines actions dans l'[EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine).
 - amélioré la résilience face aux attaques par déni de service ;
-- rendu plus performantes les solutions de [mise à l'échelle de la couche 2](/developers/docs/scaling/#layer-2-scaling) basées sur les SNARK et les STARK ;
+- A rendu les solutions de [mise à l'échelle de couche 2](/developers/docs/scaling/#layer-2-scaling) basées sur les SNARK et les STARK plus performantes.
 - permis à Ethereum et Zcash d'interagir ;
 - permis aux contrats d'introduire des fonctions plus créatives.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement/)
 
-<ExpandableCard title="Les EIP d'Istanbul" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP d'Istanbul" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-152">EIP-152</a> – <em>permet à Ethereum de travailler avec une devise préservant la vie privée comme Zcash.</em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-1108">EIP-1108</a> – <em>cryptographie à bas coût pour l'optimisation [des coûts](/glossary/#gas) de gas.</em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-1344">EIP-1344</a> – <em>protège Ethereum contre les attaques replay en ajoutant le code d'opération <code>CHAINID</code> [](/developers/docs/ethereum-stack/#ethereum-virtual-machine).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1108">EIP-1108</a> – <em>cryptographie moins chère pour améliorer les coûts du [gaz](/glossary/#gas).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1344">EIP-1344</a> - <em>protège le réseau Ethereum contre les attaques de relecture en ajoutant <code>CHAINID</code> [opcode](/developers/docs/ethereum-stack/#ethereum-virtual-machine). </em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-1884">EIP-1884</a> – <em>l'optimisation des prix du gaz opcode basée sur la consommation.</em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-2028">EIP-2028</a> – <em>réduit le coût de CallData pour permettre plus de données en blocs – bon pour [la mise à l'échelle de la couche 2](/developers/docs/scaling/#layer-2-scaling).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2028">EIP-2028</a> - <em>réduit le coût de CallData pour permettre plus de données dans les blocs - bon pour [l'évolutivité de la couche 2](/developers/docs/scaling/#layer-2-scaling). </em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-2200">EIP-2200</a> – <em>autres modifications du prix du gaz opcode.</em></li>
 </ul>
-
 </ExpandableCard>
 
 ---
@@ -468,14 +461,14 @@ La fourche Istanbul a :
 
 La fourche Constantinople a :
 
-- Réduit les récompenses pour le [minage des blocs](/developers/docs/consensus-mechanisms/pow/mining/) de 3 à 2 ETH.
-- S'assurer que la blockchain ne se fige pas avant [la mise en œuvre de la preuve d'enjeu](#beacon-chain-genesis).
-- optimisé le coût de [gaz](/glossary/#gas) de certaines actions dans l'[EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine) ;
+- A réduit les récompenses de [minage](/developers/docs/consensus-mechanisms/pow/mining/) de blocs de 3 à 2 ETH.
+- A assuré que la blockchain ne se fige pas avant que la [preuve d'enjeu ne soit mise en œuvre](#beacon-chain-genesis).
+- A optimisé le coût en [gaz](/glossary/#gas) de certaines actions dans l'[EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine).
 - Ajouté la possibilité d'interagir avec des adresses qui n'ont pas encore été créées.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement/)
 
-<ExpandableCard title="Les EIP de Constantinople" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP de Constantinople" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-145">EIP-145</a> – <em>Optimise le coût de certaines actions sur la chaîne.</em></li>
@@ -483,7 +476,6 @@ La fourche Constantinople a :
   <li><a href="https://eips.ethereum.org/EIPS/eip-1052">EIP-1052</a> – <em>introduit l'instruction <code>EXTCODEHASH</code> pour récupérer le hachage du code d'un autre contrat.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-1234">EIP-1234</a> – <em>s'assure que la blockchain ne gèle pas &#39;avant la preuve d'enjeu et réduit les récompenses de 3 à 2 ETH par bloc.</em></li>
 </ul>
-
 </ExpandableCard>
 
 <Divider />
@@ -498,27 +490,26 @@ La fourche Constantinople a :
 
 La fourche Byzantium a :
 
-- réduit les récompenses pour le [minage](/developers/docs/consensus-mechanisms/pow/mining/) des blocs de 5 à 3 ETH ;
-- retardé la [bombe de difficulté](/glossary/#difficulty-bomb) d'un an ;
+- A réduit les récompenses de [minage](/developers/docs/consensus-mechanisms/pow/mining/) de blocs de 5 à 3 ETH.
+- A retardé la [bombe de difficulté](/glossary/#difficulty-bomb) d'un an.
 - ajouté la possibilité d'effectuer des appels sans changement d'état vers d'autres contrats ;
-- ajouté certaines méthodes de cryptographie pour permettre la [mise à l'échelle de la couche 2](/developers/docs/scaling/#layer-2-scaling).
+- A ajouté certaines méthodes de cryptographie pour permettre la [mise à l'échelle de couche 2](/developers/docs/scaling/#layer-2-scaling).
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement/)
 
-<ExpandableCard title="EIP de Byzantium" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP de Byzantium" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-140">EIP-140</a> – <em>ajoute le code d'opération <code>REVERT</code>.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-658">EIP-658</a> – <em>champ de statut ajouté aux reçus de transaction pour indiquer le succès ou l'échec.</em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-196">EIP-196</a> – <em>intègre la courbe elliptique ainsi que les algorithmes de multiplication scalaire, qui permettent d'utiliser [ZK-Snarks](/developers/docs/scaling/zk-rollups/).</em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-197">EIP-197</a> – <em>intègre la courbe elliptique ainsi que les algorithmes de multiplication scalaire, qui permettent d'utiliser [ZK-Snarks](/developers/docs/scaling/zk-rollups/).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-196">EIP-196</a> - <em>ajoute une courbe elliptique et une multiplication scalaire pour permettre [ZK-Snarks](/developers/docs/scaling/zk-rollups/). </em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-197">EIP-197</a> - <em>ajoute une courbe elliptique et une multiplication scalaire pour permettre [ZK-Snarks](/developers/docs/scaling/zk-rollups/). </em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-198">EIP-198</a> – <em>permet la vérification de la signature RSA.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-211">EIP-211</a> – <em>intègre le support pour les valeurs retournées de longueur variable.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-214">L'EIP-214</a> – <em>intègre le code d'opération <code>STATICCALL</code>, ce qui permettra aux autres contrats de ne pas changer l'état des Calls.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-100">EIP-100</a> – <em>change la formule d'ajustement de difficulté.</em></li>
-  <li><a href="https://eips.ethereum.org/EIPS/eip-649">EIP-649</a> – <em>retarde [la bombe de difficulté](/glossary/#difficulty-bomb) de 1 an et réduit la récompense de bloc de 5 à 3 ETH.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-649">EIP-649</a> - <em>retarde la [bombe de difficulté](/glossary/#difficulty-bomb) de 1 an et réduit la récompense de bloc de 5 à 3 ETH. </em></li>
 </ul>
-
 </ExpandableCard>
 
 <Divider />
@@ -537,9 +528,9 @@ La fourche Spurious Dragon a été la deuxième réponse aux attaques par déni
 - « Dégonflage » de l'état de la blockchain ;
 - Ajout de la protection contre les attaques par rejeu.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/)
 
-<ExpandableCard title="EIP de Spurious Dragon" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP de Spurious Dragon" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-155">EIP-155</a> – <em>empêche les transactions d'une chaîne Ethereum d'être rediffusées sur une chaîne alternative, par exemple une transaction de réseau de test en cours de relecture sur la chaîne principale Ethereum.</em></li>
@@ -547,7 +538,6 @@ La fourche Spurious Dragon a été la deuxième réponse aux attaques par déni
   <li><a href="https://eips.ethereum.org/EIPS/eip-161">EIP-161</a> – <em>permet de supprimer les comptes vides ajoutés via les attaques DOS.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-170">EIP-170</a> – <em>modifie la taille de code maximale qu'un contrat sur la blockchain peut avoir – à 24576 octets.</em></li>
 </ul>
-
 </ExpandableCard>
 
 ---
@@ -562,15 +552,14 @@ La fourche Tangerine Whistle a été la première réponse aux attaques par dén
 
 - Résolution des problèmes urgents d'intégrité du réseau concernant les codes d'opération sous-évalués.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork/)
 
-<ExpandableCard title="EIP de Tangerine Whistle" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP de Tangerine Whistle" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-150">EIP-150</a> – <em>Augmente le coût en gaz des codes d'opération qui peuvent être utilisés dans les attaques anti-spam.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-158">EIP-158</a> – <em>réduit la taille de l'état en supprimant un grand nombre de comptes vides qui ont été mis dans l'état à très bas prix en raison de défauts dans les versions précédentes du protocole Ethereum.</em></li>
 </ul>
-
 </ExpandableCard>
 
 ---
@@ -581,13 +570,13 @@ La fourche Tangerine Whistle a été la première réponse aux attaques par dén
 
 #### Résumé {#dao-fork-summary}
 
-La fourche DAO est la réponse à l'[attaque DAO de 2016](https://www.coindesk.com/learn/understanding-the-dao-attack/) au cours de laquelle le contrat non sécurisé d'une [DAO](/glossary/#dao) a été vidé de plus de 3,6 millions d'ETH lors d'un piratage. La fourche a déplacé les fonds du contrat défectueux vers un [nouveau contrat](https://etherscan.io/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754) avec une seule fonction : withdraw (retrait). Toute personne ayant perdu des fonds pouvait retirer 1 ETH pour chaque tranche de 100 jetons DAO dans son portefeuille.
+La fourche DAO était une réponse à l'[attaque de la DAO de 2016](https://www.coindesk.com/learn/understanding-the-dao-attack/) où un contrat [DAO](/glossary/#dao) non sécurisé a été vidé de plus de 3,6 millions d'ETH lors d'un piratage. La fourche a déplacé les fonds du contrat défectueux vers un [nouveau contrat](https://eth.blockscout.com/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754) avec une seule fonction : retrait. Toute personne ayant perdu des fonds pouvait retirer 1 ETH pour chaque tranche de 100 jetons DAO dans son portefeuille.
 
-Ce plan d'action a été voté par la communauté Ethereum. Tout détenteur d'ETH a pu voter via une transaction sur [une plateforme de vote](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). Plus de 85 % des votes étaient favorables à la fourche.
+Ce plan d'action a été voté par la communauté Ethereum. Tout détenteur d'ETH pouvait voter par le biais d'une transaction sur [une plateforme de vote](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). Plus de 85 % des votes étaient favorables à la fourche.
 
 Certains mineurs ont refusé la fourche car l'incident DAO ne résultait pas d'un défaut du protocole. Ils ont ensuite formé [Ethereum Classic](https://ethereumclassic.org/).
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2016/07/20/hard-fork-completed)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2016/07/20/hard-fork-completed/)
 
 ---
 
@@ -599,32 +588,31 @@ Certains mineurs ont refusé la fourche car l'incident DAO ne résultait pas d'u
 
 La fourche Homestead qui regardait vers l'avenir. Elle comprenait plusieurs changements de protocole et un changement de réseau ayant permis à Ethereum de faire d'autres mises à niveau du réseau.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2016/02/29/homestead-release)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2016/02/29/homestead-release/)
 
-<ExpandableCard title="EIP d'Homestead" contentPreview="Official improvements included in this fork.">
+<ExpandableCard title="EIP de Homestead" contentPreview="Améliorations officielles incluses dans cette fourche.">
 
 <ul>
   <li><a href="https://eips.ethereum.org/EIPS/eip-2">EIP-2</a> – <em>modifie le processus de création de contrats.</em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-7">EIP-7</a> – <em>ajoute un nouveau code d'opération : <code>DELEGATECALL</code></em></li>
   <li><a href="https://eips.ethereum.org/EIPS/eip-8">EIP-8</a> – <em>présente DEVP2P, pour faire face aux exigences en matière de compatibilité</em></li>
 </ul>
-
 </ExpandableCard>
 
 <Divider />
 
 ## 2015 {#2015}
 
-### Frontier Thawing {#frontier-thawing}
+### Dégel de Frontier {#frontier-thawing}
 
 <NetworkUpgradeSummary name="frontierThawing" />
 
 #### Résumé {#frontier-thawing-summary}
 
-La fourche Frontier Thawing a levé la [limite de gaz](/glossary/#gas) de 5 000 par [bloc](/glossary/#block) et défini le prix du gaz par défaut à 51 [gwei](/glossary/#gwei). Cela a permis de réaliser des transactions. Les transactions nécessitent 21 000 unités de gaz. La [bombe de difficulté](/glossary/#difficulty-bomb) a été introduite pour assurer une future fourche dure vers la [preuve d'enjeu](/glossary/#pos).
+La fourche de dégel de Frontier a levé la limite de 5 000 [gaz](/glossary/#gas) par [bloc](/glossary/#block) et a fixé le prix du gaz par défaut à 51 [gwei](/glossary/#gwei). Cela a permis de réaliser des transactions. Les transactions nécessitent 21 000 unités de gaz. La [bombe de difficulté](/glossary/#difficulty-bomb) a été introduite pour assurer une future fourche vers la [preuve d'enjeu](/glossary/#pos).
 
-- [Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2015/08/04/the-thawing-frontier)
-- [Lire la mise à jour du protocole Ethereum 1](https://blog.ethereum.org/2015/08/04/ethereum-protocol-update-1)
+- [Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2015/08/04/the-thawing-frontier/)
+- [Lire la mise à jour 1 du protocole Ethereum](https://blog.ethereum.org/2015/08/04/ethereum-protocol-update-1/)
 
 ---
 
@@ -634,37 +622,37 @@ La fourche Frontier Thawing a levé la [limite de gaz](/glossary/#gas) de 5 000
 
 #### Résumé {#frontier-summary}
 
-Frontier était une implémentation réelle, mais sans structure, du projet Ethereum. Elle faisait suite à la phase de tests réussie Olympic. Elle était destinée aux utilisateurs techniques, en particulier aux développeurs. Les [blocs](/glossary/#block) avaient une limite de [gaz](/glossary/#gas) de 5 000. La période « Thawing » a permis aux mineurs de démarrer leurs opérations et aux premiers adoptants d’installer leurs clients sans avoir à « se précipiter ».
+Frontier était une implémentation réelle, mais sans structure, du projet Ethereum. Elle faisait suite à la phase de tests réussie Olympic. Elle était destinée aux utilisateurs techniques, en particulier aux développeurs. Les [blocs](/glossary/#block) avaient une limite de [gaz](/glossary/#gas) de 5 000. La période « Thawing » a permis aux mineurs de démarrer leurs opérations et aux premiers adoptants d’installer leurs clients sans avoir à « se précipiter ».
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2015/07/22/frontier-is-coming-what-to-expect-and-how-to-prepare)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2015/07/22/frontier-is-coming-what-to-expect-and-how-to-prepare/)
 
 <Divider />
 
 ## 2014 {#2014}
 
-### Vente d'ETH {#ether-sale}
+### Vente d'Ether {#ether-sale}
 
 <NetworkUpgradeSummary name="etherSale" />
 
 L'ETH a officiellement été en vente pendant 42 jours. Il était possible d'en acheter avec des BTC.
 
-[Lire l'annonce de l'Ethereum Foundation](https://blog.ethereum.org/2014/07/22/launching-the-ether-sale)
+[Lire l'annonce de la Fondation Ethereum](https://blog.ethereum.org/2014/07/22/launching-the-ether-sale/)
 
 ---
 
-### Publication du Livre jaune {#yellowpaper}
+### Publication du Yellow Paper {#yellowpaper}
 
 <NetworkUpgradeSummary name="yellowpaperRelease" />
 
-Le Livre jaune, rédigé par le Dr Gavin Wood, est une définition technique du protocole Ethereum.
+Le Livre jaune, rédigé par le Dr. Gavin Wood, est une définition technique du protocole Ethereum.
 
-[Voir le Livre jaune](https://github.com/ethereum/yellowpaper)
+[Voir le Yellow Paper](https://github.com/ethereum/yellowpaper)
 
 <Divider />
 
 ## 2013 {#2013}
 
-### Publication du Livre blanc {#whitepaper}
+### Publication du livre blanc {#whitepaper}
 
 <NetworkUpgradeSummary name="whitepaperRelease" />
 
diff --git a/public/content/translations/fr/foundation/index.md b/public/content/translations/fr/foundation/index.md
index d7e88ae5fca..9f2721b6821 100644
--- a/public/content/translations/fr/foundation/index.md
+++ b/public/content/translations/fr/foundation/index.md
@@ -1,6 +1,6 @@
 ---
 title: Ethereum Foundation
-description: L'Ethereum Foundation (EF) est une organisation à but non lucratif destinée à soutenir Ethereum et les technologies qui y sont associées.
+description: "L'Ethereum Foundation (EF) est une organisation à but non lucratif destinée à soutenir Ethereum et les technologies qui y sont associées."
 hideEditButton: true
 lang: fr
 ---
@@ -9,32 +9,32 @@ lang: fr
 
 <Logo/>
 
-L'[Ethereum Foundation](http://ethereum.foundation/) (la fondation Ethereum, EF) est une organisation à but non lucratif vouée à soutenir [Ethereum](/what-is-ethereum/) et les technologies qui y sont associées.
+L'[Ethereum Foundation](http://ethereum.foundation/) (EF) est une organisation à but non lucratif dédiée au soutien d'[Ethereum](/what-is-ethereum/) et des technologies associées.
 
-L'EF n'est pas une entreprise, ni un organisme à but non lucratif traditionnel. Son rôle n'est ni de contrôler ni de diriger Ethereum, ni d'être la seule organisation à financer le développement essentiel des technologies liées à Ethereum. L'EF fait partie d'un [écosystème](/community/) bien plus grand.
+L'EF n'est pas une entreprise, ni un organisme à but non lucratif traditionnel. Son rôle n'est ni de contrôler ni de diriger Ethereum, ni d'être la seule organisation à financer le développement essentiel des technologies liées à Ethereum. L'EF fait partie d'un [écosystème](/community/) beaucoup plus vaste.
 
 ## Initiatives de l'Ethereum Foundation {#ethereum-foundation-initiatives}
 
-### Programme de soutien aux écosystèmes {#ecosystem-support-program}
+### Programme de soutien à l'écosystème {#ecosystem-support-program}
 
-Le [programme de soutien aux écosystèmes](https://esp.ethereum.foundation/) a été créé pour offrir un soutien financier et non financier aux projets et aux entités au sein de la communauté Ethereum élargie, afin d’accélérer la croissance de l’écosystème. Ce programme est une extension du programme de subvention Ethereum d'origine, qui se concentrait principalement sur le financement.
+Le [programme de soutien à l'écosystème](https://esp.ethereum.foundation/) a pour but de fournir un soutien à la fois financier et non financier aux projets et entités de la grande communauté Ethereum, afin d'accélérer la croissance de l'écosystème. Ce programme est une extension du programme de subvention Ethereum d'origine, qui se concentrait principalement sur le financement.
 
-Pour en savoir plus sur le programme de soutien aux écosystèmes, les bénéficiaires des subventions et le processus de demande de subvention, visitez le site [esp.ethereum.foundation](https://esp.ethereum.foundation/). Vous pouvez également consulter le [blog du programme de soutien aux écosystèmes](https://blog.ethereum.org/category/ecosystem-support-program/), ou suivre le compte Twitter [@EF_ESP](https://twitter.com/EF_ESP) pour les dernières nouvelles et annonces.
+Pour en savoir plus sur le programme de soutien à l'écosystème, les anciens bénéficiaires de subventions et le processus de demande de subvention, consultez [esp.ethereum.foundation](https://esp.ethereum.foundation/). Vous pouvez également consulter le [blog du programme de soutien à l'écosystème](https://blog.ethereum.org/category/ecosystem-support-program/) ou suivre [@EF_ESP](https://twitter.com/EF_ESP) pour connaître leurs dernières nouvelles et annonces.
 
 ### Devcon {#devcon}
 
 Depuis 2014, l'Ethereum Foundation organise Devcon, la conférence annuelle pour tous les développeurs, chercheurs, penseurs et créateurs de l'écosystème Ethereum.
 
-Les vidéos des présentations qui ont eu lieu chaque année à la conférence depuis sa création sont disponibles à l'adresse [archive.devcon.org](https://archive.devcon.org/).
+Vous pouvez accéder au contenu vidéo des présentations de la conférence pour chaque année depuis sa création sur [archive.devcon.org](https://archive.devcon.org/).
 
-Pour en savoir plus, consultez le site [devcon.org](https://devcon.org/), le [Blog Devcon](https://devcon.org/en/blogs/) ou suivez [@efdevcon](https://twitter.com/EFDevcon) pour les dernières annonces.
+Pour en savoir plus, consultez [devcon.org](https://devcon.org/), visitez le [blog de la Devcon](https://devcon.org/en/blogs/), ou suivez [@efdevcon](https://twitter.com/EFDevcon) pour les dernières annonces.
 
 ### Programme de bourses {#fellowship-program}
 
 Le [programme de bourses de la Fondation Ethereum](https://fellowship.ethereum.foundation/) est une initiative visant à combler les lacunes en matière de représentation entre les cultures, les nationalités et les classes économiques. Le programme de bourses s'attache à combler ces écarts en identifiant et en soutenant les individus talentueux qui participent à rendre Ethereum plus pertinent, et en éliminant les obstacles à l'entrée pour les personnes sous-représentées et les communautés qui deviendront le futur du Web3.
 
-[Plus d'informations sur fellowship.ethereum.foundation](https://fellowship.ethereum.foundation/).
+[En savoir plus sur fellowship.ethereum.foundation](https://fellowship.ethereum.foundation/).
 
 <br/>
 
-Pour plus de renseignements sur la fondation et ses travaux, visitez le site [ethereum.foundation](http://ethereum.foundation/) ou lisez le [blog de l'Ethereum Foundation](https://blog.ethereum.org/) pour obtenir les dernières actualités et annonces d'EF.
+Pour en savoir plus sur la Fondation et son travail, visitez [ethereum.foundation](http://ethereum.foundation/), ou consultez le [blog de l'Ethereum Foundation](https://blog.ethereum.org/) pour connaître les dernières nouvelles et annonces de l'EF.
diff --git a/public/content/translations/fr/gaming/index.md b/public/content/translations/fr/gaming/index.md
new file mode 100644
index 00000000000..19f8c7fef0c
--- /dev/null
+++ b/public/content/translations/fr/gaming/index.md
@@ -0,0 +1,70 @@
+---
+title: "Jeux en chaîne"
+lang: fr
+template: use-cases
+image: /images/robot-help-bar.png
+sidebarDepth: 2
+summaryPoint1: "Les règles et l'état du jeu peuvent être appliqués par la blockchain, et non par les serveurs d'un studio"
+summaryPoint2: "N'importe qui peut créer des mods, des bots ou des jeux entièrement nouveaux qui se connectent aux mêmes données en chaîne"
+summaryPoint3: "Les L2 spécialisées, comme Redstone, et les frameworks, comme MUD, réduisent suffisamment les coûts pour permettre un gameplay en temps réel"
+buttons:
+  - content: En savoir plus
+    toId: how-gaming-on-ethereum-works
+  - content: Découvrir les Apps
+    toId: popular-games-built-on-ethereum
+    isSecondary: false
+---
+
+## Comment fonctionnent les jeux sur Ethereum {#how-gaming-on-ethereum-works}
+
+Les jeux sur Ethereum se présentent sous diverses formes, allant des jeux qui intègrent la blockchain pour des fonctionnalités spécifiques à ceux où l'univers entier du jeu réside en chaîne. De nombreux jeux utilisent Ethereum pour gérer les actifs du jeu en tant que NFT (jetons non fongibles). Cela permet aux joueurs de posséder réellement des objets numériques uniques, qui peuvent être librement échangés, vendus ou offerts en dehors des limites de l'écosystème d'un unique développeur de jeux. Bien que ces actifs offrent de nouvelles formes d'action pour les joueurs, la logique de base du jeu reste souvent sur des serveurs centralisés.
+
+Les jeux entièrement en chaîne sont des jeux où les mécanismes fondamentaux, et souvent l'univers entier du jeu, sont directement régis par des contrats intelligents sur la blockchain Ethereum (ou ses couches 2). Cela garantit une transparence inégalée. Pas de serveurs centraux, pas d'intermédiaires — uniquement des expériences et des économies transparentes, pilotées par les joueurs.
+
+- Les joueurs possèdent leurs actifs en tant que NFT.
+- Les objets peuvent être librement échangés, offerts ou vendus.
+- La blockchain garantit que les actifs restent accessibles pour toujours.
+
+## L'état actuel du jeu vidéo {#the-current-state-of-gaming}
+
+- **Arrêts fréquents de jeux :** Rien qu'en 2023, [plus de 60 jeux ont été arrêtés](https://tech4gamers.com/game-studios-shut-down-2023/), et 11 studios de jeux ont complètement fermé, ne laissant aux joueurs rien en retour de leurs investissements dans le jeu. Les jeux en chaîne, avec leur logique et leurs actifs sur un réseau décentralisé, peuvent perdurer aussi longtemps que la blockchain existe, offrant un plus haut degré de permanence.
+- **Frustration liée aux actifs verrouillés :** [51 % des joueurs se sentent frustrés](https://www.starknet.io/blog/blockchain-gaming/) de ne pas pouvoir offrir ou revendre les objets qu'ils achètent dans le jeu, et 23 % sont agacés par la difficulté à récupérer l'argent des achats effectués dans le jeu. Les joueurs investissent beaucoup de temps et d'argent pour acquérir des objets dans le jeu, pour finalement découvrir qu'ils ne les possèdent pas vraiment. Le standard NFT d'Ethereum fournit une propriété numérique vérifiable, garantissant que les joueurs contrôlent leurs actifs.
+- **Dépenses élevées sans retour sur investissement :** [Les joueurs dépensent en moyenne 6 425 \$](https://www.starknet.io/blog/blockchain-gaming/) pour des objets virtuels au cours de leur vie, avec 8,74 \$ dépensés par mois ou 104 \$ par an. La propriété en chaîne transforme ces dépenses, qui ne sont plus à fonds perdus, en un investissement dans un actif numérique qui peut être vendu, échangé ou offert, tout comme un objet de collection physique.
+
+## Jeux populaires développés sur Ethereum {#popular-games-built-on-ethereum}
+
+Les développeurs explorent de nouvelles façons de rendre les jeux plus captivants et de dépasser les simples mécanismes de récompense pour approfondir le gameplay basé sur les compétences.
+
+<OnchainGamingProductList list="game" />
+
+## Play-to-Earn (P2E) {#play-to-earn-p2e}
+
+Avec les jeux Play-to-Earn (P2E), vous pouvez gagner des actifs dans le jeu ayant une valeur dans le monde réel. Contrairement aux premiers modèles P2E qui reposaient sur des récompenses non durables, les jeux plus récents se concentrent sur la valeur à long terme. Par exemple, [Wolf Game](https://gam3s.gg/wolf-game/) combine un gameplay stratégique avec une véritable propriété d'actifs numériques. Les joueurs gèrent des moutons et des loups virtuels, gagnant la monnaie du jeu, le WOOL, qui peut être échangé ou vendu.
+
+<OnchainGamingProductList list="p2e" />
+
+## Interopérabilité et jeu inter-chaînes {#interoperability-and-cross-chain-play}
+
+L'une des fonctionnalités les plus puissantes d'Ethereum pour les jeux est sa prise en charge native de l'interopérabilité et de la composabilité. Les jeux traditionnels fonctionnent dans des « jardins clos », verrouillant les actifs et la progression du jeu à un seul titre. Les actifs du jeu, et même la logique de base du jeu, développés sur Ethereum, peuvent potentiellement interagir entre différentes applications et chaînes, sans sacrifier la sécurité. Bien qu'il s'agisse encore d'un écosystème en développement, certains réseaux de jeux basés sur Ethereum sont déjà interopérables et permettent d'utiliser des objets du jeu (NFT) dans plusieurs jeux.
+
+Par exemple, dans Illuvium, [les joueurs peuvent collectionner des créatures appelées Illuvials](https://gam3s.gg/news/illuvium-three-web3-games/), qui sont des NFT. Ces Illuvials peuvent être utilisés dans divers jeux au sein de l'univers Illuvium. Un Illuvial capturé dans Illuvium Overworld peut également être utilisé dans Illuvium Arena pour les combats.
+
+Galaxy Fight Club en est un autre exemple. Dans ce jeu, [les joueurs peuvent utiliser différentes collections de NFT](https://gam3s.gg/galaxy-fight-club/) pour participer à des combats, ce qui signifie que des NFT de divers projets peuvent être utilisés dans le jeu.
+
+## Évolutivité et améliorations des frais de gaz {#scalability-and-gas-fee-improvements}
+
+Une vieille critique des jeux en chaîne était que les blockchains sont trop complexes et lentes pour offrir aux joueurs l'expérience qu'ils attendent. Mais à mesure qu'Ethereum a mûri, des solutions pour réduire considérablement le coût et améliorer les performances des jeux en chaîne ont émergé, rendant viables les expériences interactives et rapides.
+
+Ces avancées sont principalement réalisées grâce à :
+
+- **Transactions sans gaz :** Certaines plateformes et protocoles, y compris ceux qui s'appuient sur Immutable X, offrent la possibilité d'effectuer des transactions comme l'échange ou la frappe de NFT sans frais pour l'utilisateur, rationalisant davantage l'expérience du joueur.
+- **Solutions de mise à l'échelle :** Les L2 d'Ethereum comme Arbitrum, zkSync et Starknet favorisent activement les écosystèmes pour les jeux en chaîne en raison de leur débit élevé et de leurs faibles coûts.
+- **[Écosystème MUD](https://mud.dev/) :** MUD optimise les boîtes à outils de développement d'applications basées sur Ethereum pour le développement de jeux en chaîne, fournissant une gestion d'état plus efficace pour une logique de jeu complexe.
+
+## Débuter avec les jeux Ethereum {#get-started-with-ethereum-gaming}
+
+Se lancer dans les jeux sur Ethereum est plus facile que vous ne le pensez. En quelques étapes seulement, vous pouvez commencer à jouer et à profiter de votre progression :
+
+1. **Configurez un portefeuille de cryptomonnaies :** Vous aurez besoin d'un portefeuille pour gérer vos actifs numériques et interagir avec des applications décentralisées. [Choisir un portefeuille](/wallets/find-wallet/)
+2. **Alimentez votre portefeuille :** Acquérez des Ethers (ETH) ou des jetons pertinents pour le réseau de couche 2 que vous prévoyez d'utiliser.
+3. **Explorez les jeux :** Découvrez des jeux sur des plateformes comme [Orden](https://orden.gg/), [ChainPlay](https://chainplay.gg/chain/ethereum/), [Gam3s.GG](https://gam3s.gg/), [DappRadar](https://dappradar.com/rankings/protocol/ethereum/category/games), [OpenSea](https://opensea.io/) et [PlayToEarn.net](https://playtoearn.com/blockchaingames).
diff --git a/public/content/translations/fr/glossary/index.md b/public/content/translations/fr/glossary/index.md
index 3241f6bc951..b7990345a3b 100644
--- a/public/content/translations/fr/glossary/index.md
+++ b/public/content/translations/fr/glossary/index.md
@@ -1,12 +1,12 @@
 ---
 title: Glossaire Ethereum
-description: Glossaire non-exhaustif des termes (techniques ou non) liés à Ethereum
+description: "Glossaire non-exhaustif des termes (techniques ou non) liés à Ethereum"
 lang: fr
 ---
 
 # Glossaire {#ethereum-glossary}
 
-## \# {#section-numbers}
+## # {#section-numbers}
 
 <GlossaryDefinition term="51%-attack" />
 
@@ -118,6 +118,8 @@ lang: fr
 
 <GlossaryDefinition term="dao" />
 
+<GlossaryDefinition term="desci" />
+
 <GlossaryDefinition term="dex" />
 
 <GlossaryDefinition term="deposit-contract" />
@@ -320,11 +322,11 @@ lang: fr
 
 ## O {#section-o}
 
-<GlossaryDefinition term="off-chain" />
+<GlossaryDefinition term="offchain" />
 
 <GlossaryDefinition term="ommer" />
 
-<GlossaryDefinition term="on-chain" />
+<GlossaryDefinition term="onchain" />
 
 <GlossaryDefinition term="optimistic-rollup" />
 
@@ -440,6 +442,8 @@ lang: fr
 
 <GlossaryDefinition term="token" />
 
+<GlossaryDefinition term="token-factory" />
+
 <GlossaryDefinition term="transaction" />
 
 <GlossaryDefinition term="transaction-fee" />
@@ -474,6 +478,8 @@ lang: fr
 
 <GlossaryDefinition term="wei" />
 
+<GlossaryDefinition term="wrapped-token" />
+
 <Divider />
 
 ## Z {#section-z}
@@ -488,7 +494,7 @@ lang: fr
 
 ## Sources {#sources}
 
-_Fournis pour partie par [Maîtriser Ethereum](https://github.com/ethereumbook/ethereumbook) par [Andreas M. Antonopoulos et Gavin Wood](https://ethereumbook.info), sous licence CC-BY-SA_
+_Fourni en partie par [Mastering Ethereum](https://github.com/ethereumbook/ethereumbook) par [Andreas M. Antonopoulos, Gavin Wood](https://aantonop.com/books/mastering-ethereum) sous licence CC-BY-SA_
 
 <Divider />
 
@@ -496,4 +502,4 @@ _Fournis pour partie par [Maîtriser Ethereum](https://github.com/ethereumbook/e
 
 Il manque quelque chose ? Vous avez remarqué quelque chose d'incorrect ? Aidez-nous à améliorer cette page en contribuant à ce glossaire sur GitHub !
 
-[En savoir plus sur la façon de contribuer](/contributing/adding-glossary-terms)
+[En savoir plus sur la manière de contribuer](/contributing/adding-glossary-terms)
diff --git a/public/content/translations/fr/governance/index.md b/public/content/translations/fr/governance/index.md
index 22b7832cb3f..b833a362f55 100644
--- a/public/content/translations/fr/governance/index.md
+++ b/public/content/translations/fr/governance/index.md
@@ -1,12 +1,12 @@
 ---
 title: Gouvernance d'Ethereum
-description: Une introduction à la façon dont les décisions concernant Ethereum sont prises.
+description: "Une introduction à la façon dont les décisions concernant Ethereum sont prises."
 lang: fr
 ---
 
 # Introduction à la gouvernance d'Ethereum {#introduction}
 
-_Si personne ne possède Ethereum, comment les décisions concernant les changements passés et futurs sur Ethereum sont-elles prises ? On entend par gouvernance d'Ethereum le processus qui permet de prendre des décisions._
+_Si personne ne possède Ethereum, comment les décisions concernant les changements passés et futurs d'Ethereum sont-elles prises ? On entend par gouvernance d'Ethereum le processus qui permet de prendre des décisions._
 
 <Divider />
 
@@ -22,13 +22,13 @@ Aucune personne ne possède ou ne contrôle le protocole d'Ethereum, mais des d
 
 La gouvernance d'Ethereum est le processus par lequel des changements de protocole sont apportés. Il est important de souligner que ce processus n'est pas lié à la façon dont les gens et les applications utilisent le protocole - Ethereum est sans permission. Toute personne, où qu'elle se trouve dans le monde, peut participer aux activités sur la chaîne. Il n'y a aucune règle définie pour qui peut ou ne peut pas construire une application ou envoyer une transaction. Cependant, il existe un processus permettant de proposer des modifications au protocole principal, que les applications décentralisées utilisent. Dans la mesure où un très grand nombre de personnes dépendent de la stabilité d'Ethereum, tout changement fondamental apporté à Ethereum, qu'il soit technique ou social, doit être validé par le plus grand nombre afin de s'assurer qu'il soit sûr et largement soutenu par la communauté.
 
-### Gouvernance sur la chaîne vs hors chaîne {#onchain-vs-offchain}
+### Gouvernance en chaîne et hors chaîne {#onchain-vs-offchain}
 
 La technologie de la blockchain permet de nouvelles capacités de gouvernance, connues sous le nom de gouvernance sur la chaîne. On parle de gouvernance sur la chaîne de blocs lorsque les changements de protocole proposés sont décidés par un vote des parties prenantes, généralement par les détenteurs d'un jeton de gouvernance, et que le vote a lieu sur la blockchain. Avec certaines formes de gouvernance on-chain, les modifications de protocole proposées sont déjà écrites dans le code et implémentées automatiquement si les parties prenantes approuvent les changements en signant une transaction.
 
 L'approche opposée, la gouvernance hors chaîne, est celle où toute décision de changement de protocole se fait par le biais d'un processus informel de discussion sociale, qui, s'il est approuvé, sera mis en œuvre dans le code.
 
-**La gouvernance d'Ethereum a lieu hors chaîne** et implique une grande variété de parties prenantes dans le processus.
+**La gouvernance d'Ethereum se déroule hors chaîne**, avec une grande variété de parties prenantes impliquées dans le processus.
 
 _Bien qu'au niveau du protocole, la gouvernance d'Ethereum se situe hors chaîne, de nombreux cas d'utilisation basés sur Ethereum, tels que les DAO, utilisent la gouvernance sur la chaîne._
 
@@ -40,26 +40,26 @@ _Bien qu'au niveau du protocole, la gouvernance d'Ethereum se situe hors chaîne
 
 ## Qui est impliqué ? {#who-is-involved}
 
-Il y a différentes parties prenantes dans la communauté [Ethereum](/community/), chacune jouant un rôle dans le processus de gouvernance. En partant des parties prenantes les plus éloignées du protocole et en zoomant, nous avons :
+Il existe diverses parties prenantes dans la [communauté Ethereum](/community/), chacune jouant un rôle dans le processus de gouvernance. En partant des parties prenantes les plus éloignées du protocole et en zoomant, nous avons :
 
-- **Détenteurs d'Ether** : ces personnes détiennent une quantité arbitraire d'ETH. [Plus d'infos sur ETH](/what-is-ether/).
-- **Utilisateurs d'application** : ces personnes interagissent avec des applications sur la blockchain Ethereum.
-- **Développeurs d'application/d'outils** : ces personnes écrivent des applications qui sont exécutées sur la blockchain Ethereum (p. ex. DeFi, NFTs, etc.) ou des outils de construction pour interagir avec Ethereum (p. ex. portefeuilles, suites de test, etc.). [Plus d'infos sur les dapps](/apps/).
-- **Opérateurs de nœud** : ces personnes exécutent des nœuds qui propagent des blocs et des transactions, rejetant toute transaction invalide ou bloc qu'ils croisent. [Plus d'infos sur les noeud](/developers/docs/nodes-and-clients/).
-- **Auteurs des EIPs** : ces personnes proposent des modifications au protocole Ethereum, sous la forme de Propositions d'Amélioration Ethereum (dites EIP). [Plus d'infos sur les EIP](/eips/).
+- **Détenteurs d'Ether** : ces personnes détiennent une quantité arbitraire d'ETH. [En savoir plus sur l'ETH](/what-is-ether/).
+- **Utilisateurs d'applications** : ces personnes interagissent avec des applications sur la blockchain Ethereum.
+- **Développeurs d'applications/d'outils** : ces personnes écrivent des applications qui s'exécutent sur la blockchain Ethereum (par exemple, DeFi, NFT, etc.) ou créent des outils pour interagir avec Ethereum (par exemple, des portefeuilles, des suites de tests, etc.). [En savoir plus sur les dapps](/apps/).
+- **Opérateurs de nœuds** : ces personnes exécutent des nœuds qui propagent des blocs et des transactions, rejetant toute transaction ou tout bloc invalide qu'ils rencontrent. [En savoir plus sur les nœuds](/developers/docs/nodes-and-clients/).
+- **Auteurs d'EIP** : ces personnes proposent des modifications du protocole Ethereum, sous la forme de propositions d'amélioration d'Ethereum (EIP). [En savoir plus sur les EIP](/eips/).
 - **Validateurs** : ces personnes exécutent des nœuds qui peuvent ajouter de nouveaux blocs à la blockchain Ethereum.
-- **Développeurs de protocole** (a.k.a. « les développeurs principaux » ) : ces personnes maintiennent les différentes implémentations d'Ethereum (ex. go-ethereum, Nethermind, Besu, Erigon, Reth pour la couche d'exécution ou Prysm, Lighthouse, Nimbus, Teku, Lodestar, Grandine pour la couche de consensus). [Plus de détails sur les clients Ethereum](/developers/docs/nodes-and-clients/).
+- **Développeurs de protocole** (alias « Développeurs principaux ») : ces personnes maintiennent les différentes implémentations d'Ethereum (par exemple, go-ethereum, Nethermind, Besu, Erigon, Reth au niveau de la couche d'exécution ou Prysm, Lighthouse, Nimbus, Teku, Lodestar, Grandine au niveau de la couche de consensus). [En savoir plus sur les clients Ethereum](/developers/docs/nodes-and-clients/).
 
-_Note : Toute personne peut faire partie de plusieurs de ces groupes (par exemple un développeur de protocole peut défendre une EIP, exécuter un validateur de la chaîne phare, et utiliser des applications DeFi). Pour mieux comprendre, il est toutefois plus facile de les distinguer._
+_Remarque : toute personne peut faire partie de plusieurs de ces groupes (par exemple, un développeur de protocole peut défendre une EIP, exécuter un validateur de la chaîne phare et utiliser des applications DeFi). Pour mieux comprendre, il est toutefois plus facile de les distinguer._
 
 <Divider />
 
 ## Qu'est-ce qu'une EIP ? {#what-is-an-eip}
 
-Un processus important utilisé dans la gouvernance Ethereum est la proposition de **Propositions d'amélioration Ethereum (EIP)**. Les EIP sont des normes qui spécifient de nouvelles fonctionnalités ou processus potentiels pour Ethereum. N'importe qui au sein de la communauté Ethereum peut créer une EIP. Si vous souhaitez écrire une EIP ou participer à une revue par les pairs, et/ou la gouvernance, voir :
+Un processus important utilisé dans la gouvernance d'Ethereum est la proposition de **propositions d'amélioration d'Ethereum (EIP)**. Les EIP sont des normes qui spécifient de nouvelles fonctionnalités ou processus potentiels pour Ethereum. N'importe qui au sein de la communauté Ethereum peut créer une EIP. Si vous souhaitez écrire une EIP ou participer à une revue par les pairs, et/ou la gouvernance, voir :
 
 <ButtonLink href="/eips/">
-  Plus d'infos les EIP
+  En savoir plus sur les EIP
 </ButtonLink>
 
 <Divider />
@@ -68,9 +68,9 @@ Un processus important utilisé dans la gouvernance Ethereum est la proposition
 
 Le processus formel d'introduction de modifications au protocole Ethereum est le suivant :
 
-1. **Proposer une EIP Coeur** : tel que décrit dans [EIP-1](https://eips.ethereum.org/EIPS/eip-1#core-eips), la première étape pour proposer officiellement un changement à Ethereum est de le détailler dans une EIP Coeur. Cela servira de spécification officielle pour une EIP que les développeurs de protocoles mettront en œuvre si elle est acceptée.
+1. **Proposer une EIP principale** : comme décrit dans l'[EIP-1](https://eips.ethereum.org/EIPS/eip-1#core-eips), la première étape pour proposer formellement un changement à Ethereum est de le détailler dans une EIP principale. Cela servira de spécification officielle pour une EIP que les développeurs de protocoles mettront en œuvre si elle est acceptée.
 
-2. **Présentez votre EIP aux développeurs de protocole** : une fois que vous avez une EIP Coeur pour laquelle vous avez collecté les retours de la communauté, vous pouvez la présenter aux développeurs de protocoles. Vous pouvez le faire en proposant de la discuter sur un [appel AllCoreDevs](https://github.com/ethereum/execution-specs/tree/master/network-upgrades#getting-the-considered-for-inclusion-cfi-status). Il est probable que certaines discussions auront déjà eu lieu de manière asynchrone sur le forum des [Ethereum Magicians](https://ethereum-magicians.org/) ou dans le [Discord R&D d'Ethereum](https://discord.gg/mncqtgVSVw).
+2. **Présentez votre EIP aux développeurs de protocole** : une fois que vous avez une EIP principale pour laquelle vous avez recueilli les commentaires de la communauté, vous devez la présenter aux développeurs de protocole. Vous pouvez le faire en le proposant pour discussion lors d'un [appel AllCoreDevs](https://github.com/ethereum/execution-specs/tree/master/network-upgrades#getting-the-considered-for-inclusion-cfi-status). Il est probable que certaines discussions aient déjà eu lieu de manière asynchrone sur le [forum Ethereum Magicians](https://ethereum-magicians.org/) ou dans le [Discord R&D d'Ethereum](https://discord.gg/mncqtgVSVw).
 
 > Les résultats potentiels de cette étape sont :
 
@@ -78,11 +78,11 @@ Le processus formel d'introduction de modifications au protocole Ethereum est le
 > - Des modifications techniques seront demandées
 > - Elle peut être rejetée si ce n'est pas une priorité ou si l'amélioration n'est pas assez importante par rapport à l'effort de développement
 
-3. **Itérez vers une proposition finale** : après avoir reçu les commentaires de toutes les parties prenantes concernées, vous devrez probablement apporter des modifications à votre proposition initiale pour améliorer sa sécurité ou mieux répondre aux besoins des différents utilisateurs. Une fois que votre EIP aura incorporé tous les changements que vous croyez nécessaires, vous devrez la présenter à nouveau aux développeurs du protocole. Vous passerez ensuite à l'étape suivante de ce processus, ou de nouvelles préoccupations apparaîtront, nécessitant une nouvelle série d'itérations sur votre proposition.
+3. **Itérer vers une proposition finale :** après avoir reçu les commentaires de toutes les parties prenantes concernées, vous devrez probablement apporter des modifications à votre proposition initiale pour améliorer sa sécurité ou pour mieux répondre aux besoins des différents utilisateurs. Une fois que votre EIP aura incorporé tous les changements que vous croyez nécessaires, vous devrez la présenter à nouveau aux développeurs du protocole. Vous passerez ensuite à l'étape suivante de ce processus, ou de nouvelles préoccupations apparaîtront, nécessitant une nouvelle série d'itérations sur votre proposition.
 
-4. **EIP incluse dans la mise à niveau du réseau** : en supposant que l'EIP soit approuvé, testé et implémenté, il est programmé dans le cadre d'une mise à jour réseau. Étant donné les coûts de coordination élevés des mises à niveau réseau (tout le monde a besoin d'une mise à niveau simultanée), les EIP sont généralement regroupées dans les mises à niveau.
+4. **EIP incluse dans la mise à niveau du réseau** : en supposant que l'EIP soit approuvée, testée et mise en œuvre, elle est programmée dans le cadre d'une mise à niveau du réseau. Étant donné les coûts de coordination élevés des mises à niveau réseau (tout le monde a besoin d'une mise à niveau simultanée), les EIP sont généralement regroupées dans les mises à niveau.
 
-5. **Mise à niveau réseau activée**: après l'activation de la mise à niveau réseau, l'EIP sera en ligne sur le réseau Ethereum. _Remarque : Les mises à jour du réseau sont généralement activées sur des réseaux de test avant d'être activées sur le réseau principal Ethereum._
+5. **Mise à niveau du réseau activée** : après l'activation de la mise à niveau du réseau, l'EIP sera en ligne sur le réseau Ethereum. _Remarque : Les mises à jour du réseau sont généralement activées sur des réseaux de test avant d'être activées sur le réseau principal Ethereum._
 
 Ce flux, bien que très simplifié, donne une vue d'ensemble des étapes significatives pour l'activation d'un changement de protocole sur Ethereum. Voyons maintenant les facteurs informels en jeu au cours de ce processus.
 
@@ -90,7 +90,7 @@ Ce flux, bien que très simplifié, donne une vue d'ensemble des étapes signifi
 
 ### Comprendre les travaux antérieurs {#prior-work}
 
-Les Champions EIP devraient se familiariser avec les travaux et les propositions antérieurs avant de créer une EIP qui peut être sérieusement envisagé pour être déployé sur le réseau principal Ethereum. De cette façon, l'EIP apporte quelque chose de nouveau qui n'a pas été rejeté auparavant. Les trois principaux endroits pour effectuer des recherches sont le [dépôt EIP](https://github.com/ethereum/EIPs), [Magiciens Ethereum](https://ethereum-magicians.org/) et [ethresear.ch](https://ethresear.ch/).
+Les Champions EIP devraient se familiariser avec les travaux et les propositions antérieurs avant de créer une EIP qui peut être sérieusement envisagé pour être déployé sur le réseau principal Ethereum. De cette façon, l'EIP apporte quelque chose de nouveau qui n'a pas été rejeté auparavant. Les trois principaux endroits pour effectuer des recherches à ce sujet sont le [référentiel EIP](https://github.com/ethereum/EIPs), le forum [Ethereum Magicians](https://ethereum-magicians.org/) et le site [ethresear.ch](https://ethresear.ch/).
 
 ### Groupes de travail {#working-groups}
 
@@ -102,13 +102,13 @@ Bien que certaines EIP soient des améliorations techniques simples offrant une
 
 Il n'y a pas de livre de lecture clair sur la manière de gérer les propositions litigieuses. Cette situation résulte de la conception décentralisée d'Ethereum, par laquelle aucun groupe de parties prenantes ne peut contraindre l'autre par la force brute : les développeurs de protocoles peuvent choisir de ne pas implémenter les changements de code ; les opérateurs de nœuds peuvent choisir de ne pas exécuter le dernier client Ethereum ; les équipes d'applications et les utilisateurs peuvent choisir de ne pas réaliser de transactions sur la chaîne. Puisque les développeurs de protocoles n'ont aucun moyen de forcer les gens à adopter les mises à jour de réseau, ils éviteront généralement de mettre en œuvre des EIP là où le conflits l'emporte sur les avantages pour l'ensemble de la communauté.
 
-Les champions EIP sont censés solliciter des commentaires de tous les intervenants pertinents. Si vous vous trouvez le champion d'une EIP litigieuse, vous devriez essayer de vous adresser à des objections pour établir un consensus autour de votre EIP. Compte tenu de la taille et de la diversité de la communauté Ethereum, il n'y a pas de métrique (par ex. un vote de pièce) qui peut être utilisé pour mesurer le consensus de la communauté, et les champions de l'EIP devraient s'adapter aux circonstances de leur proposition.
+Les champions EIP sont censés solliciter des commentaires de tous les intervenants pertinents. Si vous vous trouvez le champion d'une EIP litigieuse, vous devriez essayer de vous adresser à des objections pour établir un consensus autour de votre EIP. Compte tenu de la taille et de la diversité de la communauté Ethereum, il n'existe pas de mesure unique (par exemple, un vote par pièces) qui puisse être utilisée pour évaluer le consensus de la communauté, et les Champions d'EIP sont censés s'adapter aux circonstances de leur proposition.
 
 Au-delà de la sécurité du réseau Ethereum, un poids significatif a historiquement été accordé par les développeurs de protocole sur la valeur des développeurs d'applications/outils et des utilisateurs d'applications. étant donné que leur utilisation et leur développement sur Ethereum sont ce qui rend l'écosystème attractif pour les autres parties prenantes. De plus, les EIP doivent être implémentées dans toutes les implémentations de clients, qui sont gérées par des équipes distinctes. Une partie de ce processus signifie généralement convaincre plusieurs équipes de développeurs de protocoles qu'un changement particulier est précieux et qu'il aide les utilisateurs finaux ou résout un problème de sécurité.
 
 <Divider />
 
-## Gérer les désaccords {#disagreements}
+## Gestion des désaccords {#disagreements}
 
 Avoir de nombreuses parties prenantes ayant des motivations et des croyances différentes signifie que les désaccords ne sont pas rares.
 
@@ -116,11 +116,11 @@ Généralement, les désaccords sont traités avec des discussions de longue dur
 
 ### La fourche DAO {#dao-fork}
 
-Les fourches sont lorsque des mises à niveau techniques majeures ou des modifications doivent être apportées au réseau et modifier les « règles » du protocole. [Les clients Ethereum](/developers/docs/nodes-and-clients/) doivent mettre à jour leur logiciel pour implémenter les nouvelles règles de la fourche.
+Les fourches sont lorsque des mises à niveau techniques majeures ou des modifications doivent être apportées au réseau et modifier les « règles » du protocole. Les [clients Ethereum](/developers/docs/nodes-and-clients/) doivent mettre à jour leur logiciel pour implémenter les nouvelles règles des fourches.
 
-La fourche DAO est la réponse à l'attaque [DAO de 2016](https://www.coindesk.com/learn/understanding-the-dao-attack) où un contrat non sécurisé d'une [DAO](/glossary/#dao) a été vidé de plus de 3,6 millions d'ETH lors d'un piratage. La fourche a transféré les fonds du contrat défectueux à un nouveau contrat permettant à quiconque a perdu des fonds dans le piratage de les récupérer.
+La fourche DAO a été une réponse à [l'attaque de la DAO de 2016](https://www.coindesk.com/learn/understanding-the-dao-attack), au cours de laquelle un contrat de [DAO](/glossary/#dao) non sécurisé a été vidé de plus de 3,6 millions d'ETH lors d'un piratage. La fourche a transféré les fonds du contrat défectueux à un nouveau contrat permettant à quiconque a perdu des fonds dans le piratage de les récupérer.
 
-Ce plan d'action a été voté par la communauté Ethereum. Tout détenteur d'ETH a pu voter via une transaction sur [une plateforme de vote](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). Plus de 85 % des votes étaient favorables à la fourche.
+Ce plan d'action a été voté par la communauté Ethereum. Tout détenteur d'ETH pouvait voter par le biais d'une transaction sur [une plateforme de vote](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). Plus de 85 % des votes étaient favorables à la fourche.
 
 Il est important de noter qu'alors que le protocole a fait une fourche pour annuler le hack, le poids du vote lors de la décision de la fourche est discutable pour quelques raisons :
 
@@ -138,7 +138,7 @@ Regardez-en plus sur le piratage DAO :
 
 <Divider />
 
-### L'utilité de la fourche {#forking-utility}
+### L'utilité des fourches {#forking-utility}
 
 La fourche Ethereum/Ethereum Classic est un excellent exemple de fourche saine. Nous avons eu deux groupes qui étaient assez en désaccord les uns avec les autres sur certaines valeurs fondamentales pour considérer qu'il valait la peine de prendre les risques que comporte la poursuite de leurs actions spécifiques.
 
@@ -152,33 +152,33 @@ Le processus de gouvernance Ethereum négocie souvent la vitesse et l'efficacit
 
 Bien que le développement des spécifications et des implémentations ait toujours été entièrement Open Source, les processus formels utilisés pour proposer les mises à jour décrites ci-dessus n'ont pas été utilisés. Cela a permis de préciser les changements et de parvenir plus rapidmement à un accord entre chercheurs et développeurs.
 
-Lorsque la Chaîne Phare a fusionné avec la couche d'exécution Ethereum le 15 septembre 2022, La Fusion s'est achevée à travers [la mise à jour Paris](/ethereum-forks/#paris). La proposition [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675) est passée de 'Dernier appel' à 'Final', achevant ainsi la transition vers la preuve d'enjeu.
+Lorsque la Chaîne phare a fusionné avec la couche d'exécution d'Ethereum le 15 septembre 2022, La Fusion a été finalisée dans le cadre de la [mise à niveau du réseau Paris](/ethereum-forks/#paris). La proposition [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675) est passée de « Dernier appel » à « Finale », achevant ainsi la transition vers la preuve d'enjeu.
 
 <ButtonLink href="/roadmap/merge/">
-  Plus d'infos sur la fusion
+  En savoir plus sur La Fusion
 </ButtonLink>
 
 <Divider />
 
-## Comment s'impliquer ? {#get-involved}
+## Comment s'impliquer ? S’impliquer {#get-involved}
 
 - [Proposer une EIP](/eips/#participate)
 - [Discuter des propositions actuelles](https://ethereum-magicians.org/)
-- [Impliquez-vous dans la discussion R&D](https://ethresear.ch/)
-- [Rejoignez le Discord Ethereum R&D](https://discord.gg/mncqtgVSVw)
+- [Participer aux discussions R&D](https://ethresear.ch/)
+- [Rejoindre le Discord R&D d'Ethereum](https://discord.gg/mncqtgVSVw)
 - [Exécuter un nœud](/developers/docs/nodes-and-clients/run-a-node/)
-- [Contribuer au développement du client](/developers/docs/nodes-and-clients/#execution-clients)
-- [Programme d’apprentissage pour les développeurs de base](https://blog.ethereum.org/2021/09/06/core-dev-apprenticeship-second-cohort)
+- [Contribuer au développement des clients](/developers/docs/nodes-and-clients/#execution-clients)
+- [Programme d'apprentissage pour développeurs principaux](https://blog.ethereum.org/2021/09/06/core-dev-apprenticeship-second-cohort/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-La gouvernance d'Ethereum n'est pas rigoureusement définie. Divers participants de la communauté ont des points de vue différents à ce sujet. Voici quelques-unes d'entre elles :
+La gouvernance d'Ethereum n'est pas rigoureusement définie. Divers participants de la communauté ont des points de vue différents à ce sujet. Voici quelques-uns d'entre eux :
 
-- [Notes sur la gouvernance de la Blockchain](https://vitalik.eth.limo/general/2017/12/17/voting.html) - _Vitalik Buterin_
-- [Comment fonctionne la gouvernance Ethereum ?](https://cryptotesters.com/blog/ethereum-governance) – _Cryptotesters_
-- [Comment fonctionne la gouvernance Ethereum](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_
-- [Qu'est-ce qu'un développeur de base Ethereum ?](https://hudsonjameson.com/posts/2020-06-22-what-is-an-ethereum-core-developer/) - _Hudson Jameson_
-- [Gouvernance, partie 2 : La ploutocratie est toujours mauvaise](https://vitalik.eth.limo/general/2018/03/28/plutocracy.html) - _Vitalik Buterin_
-- [Aller au-delà de la gouvernance du vote par jeton](https://vitalik.eth.limo/general/2021/08/16/voting3.html) - _Vitalik Buterin_
-- [Comprendre la gouvernance de la blockchain](https://web.archive.org/web/20250124192731/https://research.2077.xyz/understanding-blockchain-governance) - _2077 Research_
-- [Le gouvernement d'Ethereum](https://www.galaxy.com/insights/research/ethereum-governance/) - _Christine Kim_
+- [Notes sur la gouvernance de la blockchain](https://vitalik.eth.limo/general/2017/12/17/voting.html) – _Vitalik Buterin_
+- [Comment fonctionne la gouvernance d'Ethereum ?](https://cryptotesters.com/blog/ethereum-governance) – _Cryptotesters_
+- [Fonctionnement de la gouvernance d'Ethereum](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_
+- [Qu'est-ce qu'un développeur principal d'Ethereum ?](https://hudsonjameson.com/posts/2020-06-22-what-is-an-ethereum-core-developer/) – _Hudson Jameson_
+- [Gouvernance, partie 2 : La ploutocratie, c'est toujours mal](https://vitalik.eth.limo/general/2018/03/28/plutocracy.html) – _Vitalik Buterin_
+- [Aller au-delà de la gouvernance par vote de pièces](https://vitalik.eth.limo/general/2021/08/16/voting3.html) – _Vitalik Buterin_
+- [Comprendre la gouvernance de la blockchain](https://web.archive.org/web/20250124192731/https://research.2077.xyz/understanding-blockchain-governance) – _2077 Research_
+- [Le gouvernement d'Ethereum](https://www.galaxy.com/insights/research/ethereum-governance/) – _Christine Kim_
diff --git a/public/content/translations/fr/guides/how-to-create-an-ethereum-account/index.md b/public/content/translations/fr/guides/how-to-create-an-ethereum-account/index.md
index 0c5bf7731b8..53980f551b2 100644
--- a/public/content/translations/fr/guides/how-to-create-an-ethereum-account/index.md
+++ b/public/content/translations/fr/guides/how-to-create-an-ethereum-account/index.md
@@ -1,6 +1,6 @@
 ---
-title: Comment "créer" un compte Ethereum
-description: Un guide étape par étape sur la création d'un compte Ethereum à l'aide d'un portefeuille.
+title: "Comment « créer » un compte Ethereum"
+description: "Un guide étape par étape sur la création d'un compte Ethereum à l'aide d'un portefeuille."
 lang: fr
 ---
 
@@ -8,13 +8,12 @@ lang: fr
 
 **Tout le monde peut créer un compte Ethereum gratuitement.** Il suffit d'installer une application de portefeuille cryptographique. Les portefeuilles créent et gèrent votre compte Ethereum. Ils permettent d'envoyer des transactions, de vérifier vos soldes et de vous connecter à d'autres applications construites sur Ethereum.
 
-Avec un portefeuille, vous pouvez également vous connecter instantanément à n'importe quel échange de jetons, jeu ou place de marché de [NFT](/glossary/#nft) . Il n'est pas nécessaire de s'inscrire individuellement, un seul compte est partagé pour toutes les applications construites sur Ethereum.
+Avec un portefeuille, vous pouvez également vous connecter instantanément à n'importe quel échange de jetons, à des jeux et à des places de marché de [NFT](/glossary/#nft). Il n'est pas nécessaire de s'inscrire individuellement, un seul compte est partagé pour toutes les applications construites sur Ethereum.
 
 ## Étape 1 : Choisir un portefeuille
 
 Un portefeuille est une application qui vous aide à gérer votre compte Ethereum. Il existe des dizaines de portefeuilles différents : mobiles, de bureau ou même des extensions de navigateur.
 
-
 <ButtonLink href="/wallets/find-wallet/">
   Liste des portefeuilles
 </ButtonLink>
@@ -37,7 +36,7 @@ La première fois que vous ouvrez votre nouveau portefeuille, il vous sera deman
 
 Certaines applications vous demanderont d'enregistrer une "phrase de récupération" secrète (parfois appelée "phrase d'amorçage" ou "mnémonique"). Il est extrêmement important de sauvegarder cette phrase ! Elle est utilisée pour générer votre compte Ethereum et peut être utilisée pour soumettre des transactions.
 
-**Toute personne possédant la phrase peut prendre le contrôle de tous vos fonds.** Ne partagez jamais cette information avec qui que ce soit. Cette phrase doit contenir 12 à 24 mots générés de manière aléatoire (l'ordre des mots est important).
+**Toute personne qui connaît la phrase peut prendre le contrôle de tous vos fonds.** Ne la partagez jamais avec qui que ce soit. Cette phrase doit contenir 12 à 24 mots générés de manière aléatoire (l'ordre des mots est important).
 
 <div>
 <Alert variant="update">
@@ -47,7 +46,7 @@ Certaines applications vous demanderont d'enregistrer une "phrase de récupérat
   <ButtonLink href="/guides/how-to-use-a-wallet">
     Comment utiliser un portefeuille
   </ButtonLink>
- </AlertContent>
+</AlertContent>
 </Alert>
 </div>
 
@@ -61,11 +60,11 @@ Non. Le portefeuille est un outil de gestion qui vous aide à gérer vos comptes
 
 ### Puis-je envoyer des bitcoins à une adresse Ethereum, ou des ethers à une adresse Bitcoin ?
 
-Non, vous ne pouvez pas. Bitcoin et Ether existent sur deux réseaux différents (c'est-à-dire des blockchains différentes), chacun ayant ses propres registres et formats d'adresse. Plusieurs tentatives ont été mises en place pour relier ces deux réseaux, la plus concluante étant actuellement [Bitcoin Emballé ou WBTC](https://www.bitcoin.com/get-started/what-is-wbtc/). Ceci n'est pas une recommandation, car WBTC est une solution de garde (ce qui signifie qu'un groupe restreint de personnes contrôle certaines fonctions critiques) et est fourni ici à titre informatif uniquement.
+Non, vous ne pouvez pas. Bitcoin et Ether existent sur deux réseaux différents (c'est-à-dire des blockchains différentes), chacun ayant ses propres registres et formats d'adresse. Il y a eu plusieurs tentatives pour établir un pont entre les deux réseaux différents, dont la plus active est actuellement le [Wrapped Bitcoin ou WBTC](https://www.bitcoin.com/get-started/what-is-wbtc/). Ceci n'est pas une recommandation, car WBTC est une solution de garde (ce qui signifie qu'un groupe restreint de personnes contrôle certaines fonctions critiques) et est fourni ici à titre informatif uniquement.
 
 ### Si je possède une adresse ETH, est-ce que je peux l'utiliser sur d'autres blockchains ?
 
-Vous pouvez utiliser la même [adresse](/glossary/#address) sur toutes les blockchains qui utilisent un logiciel sous-jacent similaire à Ethereum (« compatible-EVM »). Cette [liste](https://chainlist.org/) vous présente les blockchains que vous pouvez utiliser avec la même adresse. Certaines blockchains, comme Bitcoin, utilisent un ensemble de règles de réseau totalement différentes et vous aurez donc besoin d'une adresse différente fonctionnant sous un autre format. Si vous avez un portefeuille à contrat intelligent, vous devriez consulter son site internet pour vérifier les blockchains prises en charge, car celles-ci ont généralement un champ d'application limité mais plus sûr.
+Vous pouvez utiliser la même [adresse](/glossary/#address) sur toutes les blockchains qui utilisent un logiciel sous-jacent similaire à Ethereum (connues sous le nom de "compatibles EVM"). Cette [liste](https://chainlist.org/) vous montrera quelles blockchains vous pouvez utiliser avec la même adresse. Certaines blockchains, comme Bitcoin, utilisent un ensemble de règles de réseau totalement différentes et vous aurez donc besoin d'une adresse différente fonctionnant sous un autre format. Si vous avez un portefeuille à contrat intelligent, vous devriez consulter son site internet pour vérifier les blockchains prises en charge, car celles-ci ont généralement un champ d'application limité mais plus sûr.
 
 ### Est-il plus sûr de garder mes fonds sur mon portefeuille plutôt que sur un échange ?
 
@@ -73,4 +72,5 @@ Posséder son propre portefeuille signifie que l'on assume la responsabilité de
 
 ### Si je perds mon portefeuille téléphone/matériel, dois-je utiliser à nouveau la même application de portefeuille pour récupérer les fonds perdus ?
 
-Non, vous pouvez utiliser un autre portefeuille. Tant que vous possédez la phrase de récupération, vous pouvez la saisir dans la plupart des portefeuilles et cette action restaurera votre compte. Par contre, soyez prudent si vous avez besoin d'agir en ce sens : il est préférable de s'assurer que vous n'êtes pas connecté à Internet lorsque vous récupérez votre portefeuille, afin que votre phrase de récupération ne soit pas divulguée accidentellement. Il est souvent impossible de récupérer des fonds perdus sans la phrase de récupération.
+Non, vous pouvez utiliser un autre portefeuille. Tant que vous possédez la phrase de récupération, vous pouvez la saisir dans la plupart des portefeuilles et cette action restaurera votre compte.
+Par contre, soyez prudent si vous avez besoin d'agir en ce sens : il est préférable de s'assurer que vous n'êtes pas connecté à Internet lorsque vous récupérez votre portefeuille, afin que votre phrase de récupération ne soit pas divulguée accidentellement. Il est souvent impossible de récupérer des fonds perdus sans la phrase de récupération.
diff --git a/public/content/translations/fr/guides/how-to-id-scam-tokens/index.md b/public/content/translations/fr/guides/how-to-id-scam-tokens/index.md
index 543bb622aa8..a00a9fcab92 100644
--- a/public/content/translations/fr/guides/how-to-id-scam-tokens/index.md
+++ b/public/content/translations/fr/guides/how-to-id-scam-tokens/index.md
@@ -1,36 +1,34 @@
 ---
 title: Comment identifier les jetons frauduleux
-description: Comprendre les jetons frauduleux, comment ils se présentent comme légitimes et comment les éviter.
+description: "Comprendre les jetons frauduleux, comment ils se présentent comme légitimes et comment les éviter."
 lang: fr
 ---
 
 # Comment identifier les jetons frauduleux {#identify-scam-tokens}
 
-Ethereum est couramment utilisé par des groupes pour créer des jetons échangeables ou, dans un certain sens, leur propre monnaie. Ces jetons suivent généralement une norme, [ERC-20](/developers/docs/standards/tokens/erc-20/). Cependant, partout où il existe des cas d'utilisation légitimes qui apportent de la valeur, il y a aussi des criminels qui essaient de voler cette valeur à leur profit.
+Ethereum est couramment utilisé par des groupes pour créer des jetons échangeables ou, dans un certain sens, leur propre monnaie. Ces jetons suivent généralement une norme, [l'ERC-20](/developers/docs/standards/tokens/erc-20/). Cependant, partout où il existe des cas d'utilisation légitimes qui apportent de la valeur, il y a aussi des criminels qui essaient de voler cette valeur à leur profit.
 
 Ils peuvent vous tromper de deux façons :
 
 - **Vente d'un jeton frauduleux**, qui peut ressembler au jeton légitime que vous souhaitez acheter, mais qui est émis par les escrocs et ne vaut rien.
-- **Incitation à signer des transactions frauduleuses**, généralement en vous dirigeant vers leur propre interface utilisateur. Ils pourraient essayer de vous inciter à accorder à leurs contrats une allocation de vos jetons ERC-20, à divulguer des informations sensibles qui leur donneraient accès à vos actifs, etc. Ces interfaces utilisateurs peuvent être des clones presque parfaits de sites honnêtes, mais avec des astuces cachées.
+- **Vous inciter à signer des transactions frauduleuses**, généralement en vous dirigeant vers leur propre interface utilisateur. Ils pourraient essayer de vous inciter à accorder à leurs contrats une allocation de vos jetons ERC-20, à divulguer des informations sensibles qui leur donneraient accès à vos actifs, etc. Ces interfaces utilisateurs peuvent être des clones presque parfaits de sites honnêtes, mais avec des astuces cachées.
 
-Pour illustrer ce que sont les jetons frauduleux et comment les identifier, nous allons examiner un exemple de jeton frauduleux : [`wARB`](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82). Ce jeton tente de ressembler au jeton [`ARB`](https://etherscan.io/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1) légitime.
+Pour illustrer ce que sont les jetons frauduleux et comment les identifier, nous allons examiner un exemple : [`wARB`](https://eth.blockscout.com/token/0xB047c8032b99841713b8E3872F06cF32beb27b82). Ce jeton tente de ressembler au jeton légitime [`ARB`](https://eth.blockscout.com/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1).
 
 <ExpandableCard
-title="Qu'est-ce que ARB?"
+title="Qu'est-ce que l'ARB ?"
 contentPreview=''>
 
-Arbitrum est une organisation qui développe et gère des [rollups optimistiques](/developers/docs/scaling/optimistic-rollups/). Au départ, Arbitrum était organisée comme une entreprise à but lucratif, mais elle a ensuite pris des mesures pour se décentraliser. Dans le cadre de ce processus, un [jeton de gouvernance](/dao/#token-based-membership) échangeable a été créé.
-
+Arbitrum est une organisation qui développe et gère des [optimistic rollups](/developers/docs/scaling/optimistic-rollups/). Au départ, Arbitrum était organisée comme une entreprise à but lucratif, mais elle a ensuite pris des mesures pour se décentraliser. Dans le cadre de ce processus, ils ont émis un [jeton de gouvernance](/dao/#token-based-membership) échangeable.
 </ExpandableCard>
 
 <ExpandableCard
-title="Pourquoi le token malveillant s'appelle-t-il wARB?"
+title="Pourquoi le jeton frauduleux s'appelle-t-il wARB ?"
 contentPreview=''>
 
 Il existe une convention dans Ethereum selon laquelle lorsqu'un actif n'est pas conforme à la norme ERC-20, nous créons une version "enveloppée" de cet actif dont le nom commence par "w". Ainsi, par exemple, nous avons wBTC pour le bitcoin et <a href="https://cointelegraph.com/news/what-is-wrapped-ethereum-weth-and-how-does-it-work">wETH pour l'éther</a>.
 
 Il n'est pas logique de créer une version enveloppée d'un jeton ERC-20 déjà présent sur Ethereum, mais les escrocs s'appuient sur l'apparence de légitimité plutôt que sur la réalité sous-jacente.
-
 </ExpandableCard>
 
 ## Comment fonctionnent les jetons frauduleux ? {#how-do-scam-tokens-work}
@@ -38,16 +36,15 @@ Il n'est pas logique de créer une version enveloppée d'un jeton ERC-20 déjà
 L'objectif d'Ethereum est la décentralisation. Cela signifie qu'il n'y a pas d'autorité centrale qui puisse confisquer vos actifs ou vous empêcher de déployer un contrat intelligent. Mais cela signifie également que les escrocs peuvent déployer n'importe quel contrat intelligent.
 
 <ExpandableCard
-title="Qu'est-ce qu'un contrat intelligent ?"
+title="Que sont les contrats intelligents ?"
 contentPreview=''>
 
-[Les contrats intelligents](/developers/docs/smart-contracts/) sont les programmes qui s'exécutent sur la blockchain Ethereum. Chaque jeton ERC-20, par exemple, est implémenté comme contrat intelligent.
-
+Les [contrats intelligents](/developers/docs/smart-contracts/) sont les programmes qui s'exécutent sur la blockchain Ethereum. Chaque jeton ERC-20, par exemple, est implémenté comme contrat intelligent.
 </ExpandableCard>
 
 Plus précisément, Arbitrum a déployé un contrat qui utilise le symbole `ARB`. Mais cela n'empêche pas d'autres personnes de déployer un contrat qui utilise exactement le même symbole, ou un symbole similaire. Quiconque rédige le contrat définit son contenu.
 
-## Paraître légitime {#appearing-legitimate}
+## Apparence de légitimité {#appearing-legitimate}
 
 Les créateurs de jetons frauduleux ont recours à plusieurs astuces pour paraître légitimes.
 
@@ -55,11 +52,11 @@ Les créateurs de jetons frauduleux ont recours à plusieurs astuces pour paraî
 
 - **Propriétaires légitimes**. Les jetons frauduleux créditent souvent des soldes importants à des adresses qui pourraient vraisemblablement détenir des jetons authentiques.
 
-  Par exemple, regardons à nouveau `wARB`. [Environ 16 % des jetons](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82?a=0x1c8db745abe3c8162119b9ef2c13864cd1fdd72f) sont détenus par une adresse dont la balise publique est [Arbitrum Foundation: Deployer](https://etherscan.io/address/0x1c8db745abe3c8162119b9ef2c13864cd1fdd72f). Il ne s'agit _pas_ d'une fausse adresse, c'est vraiment l'adresse qui a [déployé le vrai contrat ARB sur Ethereum mainnet](https://etherscan.io/tx/0x242b50ab4fe9896cb0439cfe6e2321d23feede7eeceb31aa2dbb46fc06ed2670).
+  Par exemple, examinons à nouveau `wARB`. [Environ 16 % des jetons](https://eth.blockscout.com/token/0xb047c8032b99841713b8e3872f06cf32beb27b82?tab=holders) sont détenus par une adresse dont l'étiquette publique est [Arbitrum Foundation: Deployer](https://eth.blockscout.com/address/0x1C8db745ABe3C8162119b9Ef2c13864Cd1FDD72F). Ce n'est _pas_ une fausse adresse, c'est bien l'adresse qui [a déployé le véritable contrat ARB sur le réseau principal d'Ethereum](https://eth.blockscout.com/tx/0x242b50ab4fe9896cb0439cfe6e2321d23feede7eeceb31aa2dbb46fc06ed2670).
 
   Étant donné que le solde ERC-20 d'une adresse fait partie du stockage du contrat ERC-20, il peut être spécifié par le contrat comme étant ce que souhaite le développeur du contrat. Il est également possible qu'un contrat interdise les transferts afin que les utilisateurs légitimes ne puissent pas se débarrasser de ces jetons frauduleux.
 
-- **Transferts légitimes**. _Les propriétaires légitimes ne paieraient pas pour transférer un jeton frauduleux à d'autres, donc s'il y a des transferts, ils doivent être légitimes, n'est-ce pas ? _ **Faux**. Les événements `Transfert` sont produits par le contrat ERC-20. Un escroc peut facilement rédiger le contrat de manière à ce qu'il produise ces actions.
+- **Transferts légitimes**. _Les propriétaires légitimes ne paieraient pas pour transférer un jeton frauduleux à d'autres, donc s'il y a des transferts, il doit être légitime, n'est-ce pas ?_ **Faux**. Les événements `Transfer` sont produits par le contrat ERC-20. Un escroc peut facilement rédiger le contrat de manière à ce qu'il produise ces actions.
 
 ## Sites web frauduleux {#websites}
 
@@ -71,27 +68,27 @@ Une bonne pratique pour éviter cela est de vérifier soigneusement l'URL des si
 
 1. **Vérifier l'adresse du contrat**. Les jetons légitimes proviennent d'organisations légitimes, et vous pouvez consulter les adresses des contrats sur le site web de l'organisation. Par exemple, [pour `ARB`, vous pouvez consulter les adresses légitimes ici](https://docs.arbitrum.foundation/deployment-addresses#token).
 
-2. **Les jetons réels ont de la liquidité**. Une autre option consiste à examiner la quantité de liquidités disponibles sur [Uniswap](https://uniswap.org/), l'un des protocoles d'échange de jetons les plus courants. Ce protocole utilise des pools de liquidité, dans lesquels les investisseurs déposent leurs jetons dans l'espoir d'un retour sur les frais de transaction.
+2. **Les jetons réels ont de la liquidité**. Une autre option consiste à examiner la taille du pool de liquidités sur [Uniswap](https://uniswap.org/), l'un des protocoles d'échange de jetons les plus courants. Ce protocole utilise des pools de liquidité, dans lesquels les investisseurs déposent leurs jetons dans l'espoir d'un retour sur les frais de transaction.
 
-Les jetons frauduleux ont généralement de minuscules réserves de liquidités, voire aucune, parce que les fraudeurs ne veulent pas risquer des actifs réels. Par exemple, le pool `ARB`/`ETH` Uniswap contient environ un million de dollars ([voir ici pour la valeur à jour](https://info.uniswap.org/#/pools/0x755e5a186f0469583bd2e80d1216e02ab88ec6ca)) et acheter ou vendre une petite quantité ne changera pas le prix :
+Les jetons frauduleux ont généralement de minuscules réserves de liquidités, voire aucune, parce que les fraudeurs ne veulent pas risquer des actifs réels. Par exemple, le pool Uniswap `ARB`/`ETH` contient environ un million de dollars ([voir ici la valeur à jour](https://app.uniswap.org/explore#/pools/0x755e5a186f0469583bd2e80d1216e02ab88ec6ca)) et l'achat ou la vente d'une petite quantité ne va pas en changer le prix :
 
-![Acheter des jetons authentiques](./uniswap-real.png)
+![Acheter un jeton légitime](./uniswap-real.png)
 
-Mais lorsque vous essayez d'acheter le jeton frauduleux `wARB`, même un achat minime modifierait le prix de plus de 90 % :
+Mais lorsque vous essayez d'acheter le jeton frauduleux `wARB`, même un achat minime ferait varier le prix de plus de 90 % :
 
-![Acheter des jetons frauduleux](./uniswap-scam.png)
+![Acheter un jeton frauduleux](./uniswap-scam.png)
 
-Il s'agit d'un autre élément qui montre que `wARB` n'est probablement pas un jeton légitime.
+C'est une preuve supplémentaire qui montre que `wARB` n'est probablement pas un jeton légitime.
 
-3. **Regarder sur Etherscan**. De nombreux jetons frauduleux ont déjà été identifiés et signalés par la communauté. Ces jetons sont [marqués sur Etherscan](https://info.etherscan.com/etherscan-token-reputation/). Bien qu'Etherscan ne soit pas une source de vérité faisant autorité (la nature des réseaux décentralisés fait qu'il ne peut y avoir de source de légitimité faisant autorité), les jetons identifiés par Etherscan comme étant frauduleux sont susceptibles de l'être.
+3. **Regarder sur Etherscan**. De nombreux jetons frauduleux ont déjà été identifiés et signalés par la communauté. De tels jetons sont [signalés dans Etherscan](https://info.etherscan.com/etherscan-token-reputation/). Bien qu'Etherscan ne soit pas une source de vérité faisant autorité (la nature des réseaux décentralisés fait qu'il ne peut y avoir de source de légitimité faisant autorité), les jetons identifiés par Etherscan comme étant frauduleux sont susceptibles de l'être.
 
-   ![Les tokens frauduleux sur Etherscan](./etherscan-scam.png)
+   ![Jeton frauduleux dans Etherscan](./etherscan-scam.png)
 
 ## Conclusion {#conclusion}
 
 Tant qu'il y aura de la valeur dans le monde, il y aura des malfaiteurs qui tenteront de s'en emparer, et dans un monde décentralisé, il n'y a personne d'autre que vous-même pour vous protéger. Suivez ces indications pour vous aider à distinguer les jetons légitimes des arnaques :
 
 - Les jetons malveillants imitent des jetons légitimes en utilisant le même nom, symbole, etc.
-- Les jetons malveillants _ne peuvent pas_ utiliser la même adresse de contrat.
+- Les jetons frauduleux ne _peuvent pas_ utiliser la même adresse de contrat.
 - La meilleure source pour l'adresse légitime du jeton est l'organisation émettrice dudit jeton.
-- À défaut, vous pouvez utiliser des applications populaires et fiables comme [Uniswap](https://app.uniswap.org/#/swap) et [Etherscan](https://etherscan.io/).
+- À défaut, vous pouvez utiliser des applications populaires et fiables telles que [Uniswap](https://app.uniswap.org/#/swap) et [Blockscout](https://eth.blockscout.com/).
diff --git a/public/content/translations/fr/guides/how-to-revoke-token-access/index.md b/public/content/translations/fr/guides/how-to-revoke-token-access/index.md
index ea4e5ebb698..d2d1b98eff4 100644
--- a/public/content/translations/fr/guides/how-to-revoke-token-access/index.md
+++ b/public/content/translations/fr/guides/how-to-revoke-token-access/index.md
@@ -1,16 +1,16 @@
 ---
-title: Comment révoquer l'accès des contrats intelligents à vos fonds crypto
-description: Un guide pratique sur la révocation de l'accès aux jetons de contrat intelligents exploiteurs
+title: "Comment révoquer l'accès des contrats intelligents à vos fonds crypto"
+description: "Un guide pratique sur la révocation de l'accès aux jetons de contrat intelligents exploiteurs"
 lang: fr
 ---
 
 # Comment révoquer l'accès des contrats intelligents à vos fonds crypto
 
-Ce guide va vous enseigner comment visualiser une liste de tous les [contrats intelligents](/glossary/#smart-contract) auxquels vous avez autorisé l'accès à vos fonds et comment les révoquer.
+Ce guide vous apprendra comment afficher la liste de tous les [contrats intelligents](/glossary/#smart-contract) auxquels vous avez autorisé l'accès à vos fonds et comment les révoquer.
 
-Parfois, des développeurs malveillants installent des portes dérobées dans les contrats intelligents, leur permettant d'accéder aux fonds des utilisateurs à leur insu. Souvent, il s'agit de plateformes demandant la permission à l'utilisateur de dépenser un **nombre illimité de jetons** en vue d'économiser de petites quantités de [gaz](/glossary/#gas) à l'avenir, mais cela s'accompagne d'un risque accru.
+Parfois, des développeurs malveillants installent des portes dérobées dans les contrats intelligents, leur permettant d'accéder aux fonds des utilisateurs à leur insu. Souvent, ces plateformes demandent à l'utilisateur la permission de dépenser un **nombre illimité de jetons** pour économiser de petites quantités de [gaz](/glossary/#gas) à l'avenir, mais cela s'accompagne d'un risque accru.
 
-Une fois qu'une plateforme a un droit d'accès illimité à un jeton sur votre [portefeuille](/glossary/#wallet), ils peuvent dépenser tous ces jetons, même si vous avez retiré vos fonds de leur plateforme vers votre portefeuille. Une personne mal intentionnée peut accéder à vos fonds et les retirer, vous laissant sans possibilité de les récupérer.
+Une fois qu'une plateforme dispose de droits d'accès illimités à un jeton sur votre [portefeuille](/glossary/#wallet), elle peut dépenser tous ces jetons, même si vous avez retiré vos fonds de sa plateforme vers votre portefeuille. Une personne mal intentionnée peut accéder à vos fonds et les retirer, vous laissant sans possibilité de les récupérer.
 
 Vos options pour vous protéger sont de ne pas utiliser de ne pas utiliser de nouveaux projets non testés, de n'approuver que ce dont vous avez besoin et de régulièrement contrôler et révoquer les accès qui présentent un risque. Alors, comment fait-on ?
 
@@ -18,8 +18,8 @@ Vos options pour vous protéger sont de ne pas utiliser de ne pas utiliser de no
 
 Plusieurs sites Web vous permettent de visualiser et de révoquer les contrats intelligents connectés à votre adresse. Chacun de ces sites nécessite une connexion à votre portefeuille :
 
-- [Ethallowance](https://ethallowance.com/) (Ethereum)
 - [Etherscan](https://etherscan.io/tokenapprovalchecker) (Ethereum)
+- [Blockscout](https://eth.blockscout.com/apps/revokescout) (Ethereum)
 - [Revoke](https://revoke.cash/) (plusieurs réseaux)
 - [Unrekt](https://app.unrekt.net/) (plusieurs réseaux)
 - [EverRevoke](https://everrise.com/everrevoke/) (plusieurs réseaux)
@@ -42,9 +42,9 @@ Lorsque vous cliquez sur révoquer, vous devriez voir une nouvelle proposition d
 
 Nous vous conseillons de rafraîchir l'outil de révocation après quelques minutes et de reconnecter votre portefeuille pour vérifier à nouveau si le contrat révoqué a disparu de la liste.
 
-<mark>Nous vous recommandons de ne jamais autoriser de projets ayant un accès illimité à vos fonds et de révoquer régulièrement l'intégralité des droits de vos contrats intelligents. La révocation de l'accès aux jetons ne devrait jamais entraîner une perte de fonds, surtout si vous utilisez les outils mentionnés ci-dessus.</mark>
+<mark>Nous vous recommandons de ne jamais autoriser aux projets un accès illimité à vos jetons et de révoquer régulièrement toutes les autorisations de jetons. La révocation de l'accès aux jetons ne devrait jamais entraîner une perte de fonds, surtout si vous utilisez les outils listés ci-dessus.</mark>
 
- <br />
+<br />
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
diff --git a/public/content/translations/fr/guides/how-to-swap-tokens/index.md b/public/content/translations/fr/guides/how-to-swap-tokens/index.md
index 084402116b9..97f74fde160 100644
--- a/public/content/translations/fr/guides/how-to-swap-tokens/index.md
+++ b/public/content/translations/fr/guides/how-to-swap-tokens/index.md
@@ -1,6 +1,6 @@
 ---
-title: Comment échanger des jetons
-description: Un guide pour échanger des jetons sur Ethereum.
+title: "Comment échanger des jetons"
+description: "Un guide pour échanger des jetons sur Ethereum."
 lang: fr
 ---
 
@@ -10,9 +10,9 @@ Fatigué de chercher un échange de cryptomonnaies qui répertorie tous vos jeto
 
 Un échange de jetons implique l'échange de deux actifs différents qui existent sur le réseau Ethereum, par exemple l'échange d'ETH contre du DAI (un jeton [ERC-20](/glossary/#erc-20)). Le processus est à la fois très rapide et peu coûteux. Vous aurez besoin d'un portefeuille de cryptomonnaies pour échanger des jetons.
 
-**Prérequis :**
+**Prérequis :**
 
-- avoir un [portefeuille crypto](/glossary/#wallet) ; si ce n’est pas le cas, vous pouvez suivre ce guide pour découvrir [comment créer un compte Ethereum](/guides/how-to-create-an-ethereum-account/)
+- avoir un [portefeuille crypto](/glossary/#wallet) ; si ce n'est pas le cas, vous pouvez suivre ce guide sur [comment créer un compte Ethereum](/guides/how-to-create-an-ethereum-account/)
 - ajouter des fonds à votre portefeuille
 
 ## 1. Connectez votre portefeuille à l'échange décentralisé (DEX) de votre choix
@@ -24,30 +24,30 @@ Parmi les échanges décentralisés les plus connus :
 - [1Inch](https://app.1inch.io/#/1/unified/swap/ETH/DAI)
 - [Curve](https://www.curve.finance/dex/ethereum/swap/)
 
-Intéressant ? Apprenez-en plus sur ce qu'est la [finance décentralisée (DeFi)](/defi/) et comment ce nouveau type d'échange fonctionne.
+Intéressant ? Apprenez-en davantage sur ce qu'est la [finance décentralisée (DeFi)](/defi/) et sur le fonctionnement de ces nouveaux types d'échanges.
 
 ## 2. Sélectionnez la paire de jetons que vous souhaitez échanger
 
-Par exemple, ETH et DAI. Assurez-vous d'avoir des fonds dans l'un des deux jetons. ![Interface commune pour les échanges](./swap1.png)
+Par exemple, ETH et DAI. Assurez-vous d'avoir des fonds dans l'un des deux jetons.
+![Interface commune pour l'échange](./swap1.png)
 
 ## 3. Entrez le nombre de jetons que vous voulez échanger et cliquez sur échanger
 
 L'échange va calculer automatiquement le nombre de jetons que vous obtiendrez.
 
-![Interface commune pour les échanges](./swap2.png)
+![Interface commune pour l'échange](./swap2.png)
 
 ## 4. Confirmez la transaction
 
 Vérifiez les détails de la transaction. Vérifiez le taux de change et tous les frais annexes pour éviter les mauvaises surprises.
 
-![Interface commune pour examiner la transaction](./swap3.png)
+![Interface commune pour l'examen de la transaction](./swap3.png)
 
 ## 5. Attendez que la transaction soit traitée
 
 Vous pouvez vérifier la progression de la transaction sur n'importe quel explorateur de blockchain. Cette procédure ne devrait pas prendre plus de 10 minutes.
 
-Vous recevez automatiquement les jetons échangés dans votre portefeuille lorsque la transaction est finalisée.
-<br />
+Vous recevez automatiquement les jetons échangés dans votre portefeuille lorsque la transaction est finalisée. <br />
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
diff --git a/public/content/translations/fr/guides/how-to-use-a-bridge/index.md b/public/content/translations/fr/guides/how-to-use-a-bridge/index.md
index def8dd1e8e0..7f3318a4928 100644
--- a/public/content/translations/fr/guides/how-to-use-a-bridge/index.md
+++ b/public/content/translations/fr/guides/how-to-use-a-bridge/index.md
@@ -1,47 +1,47 @@
 ---
-title: Comment transférer des jetons aux réseaux de seconde couche
-description: Un guide expliquant comment déplacer des jetons d'Ethereum vers la couche Layer 2 à l'aide d'un pont (ou bridge).
+title: "Comment transférer des jetons aux réseaux de seconde couche"
+description: "Un guide expliquant comment déplacer des jetons d'Ethereum vers la couche Layer 2 à l'aide d'un pont (ou bridge)."
 lang: fr
 ---
 
 # Comment transférer des jetons aux réseaux de seconde couche
 
-Si le trafic sur Ethereum devient trop important, cela peut devenir coûteux. Une solution possible consiste à créer de nouvelles "layers" : c'est-à-dire des réseaux secondaires qui fonctionnent de manière similaire à Ethereum lui-même. Ces "Layer 2s" aident à réduire la congestion et les coûts sur Ethereum en traitant beaucoup plus de transactions à des frais réduits, et en ne stockant les résultats de ces transactions sur Ethereum que de temps en temps. Ainsi, ces couches secondaires nous permettent de réaliser des transactions plus rapidement et à moindre coût. Beaucoup de projets crypto adopte cette approche pour ces bénéfices. Le moyen le plus simple de déplacer des jetons d'Ethereum vers une "Layer 2" est d'utiliser un pont (bridge).
+Si le trafic sur Ethereum devient trop important, cela peut devenir coûteux. Une solution à cela est de créer de nouvelles "couches" : c'est-à-dire différents réseaux qui fonctionnent de manière similaire à Ethereum lui-même. Ces "Layer 2s" aident à réduire la congestion et les coûts sur Ethereum en traitant beaucoup plus de transactions à des frais réduits, et en ne stockant les résultats de ces transactions sur Ethereum que de temps en temps. Ainsi, ces couches secondaires nous permettent de réaliser des transactions plus rapidement et à moindre coût. Beaucoup de projets crypto adopte cette approche pour ces bénéfices. Le moyen le plus simple de déplacer des jetons d'Ethereum vers une "Layer 2" est d'utiliser un pont (bridge).
 
-**Prérequis :**
+**Prérequis :**
 
-- avoir un portefeuille crypto, vous pouvez suivre ce tutoriel : [Comment créer un compte Ethereum](/guides/how-to-create-an-ethereum-account/)
+- avoir un portefeuille de cryptomonnaies — si vous n'en avez pas, suivez ce guide pour [créer un compte Ethereum](/guides/how-to-create-an-ethereum-account/)
 - ajouter des fonds à votre portefeuille
 
 ## 1. Déterminez le réseau de seconde couche que vous souhaitez utiliser
 
-Vous pouvez en apprendre plus sur les différents projets et des liens importants sur notre [page sur la couche 2](/layer-2/).
+Vous pouvez en apprendre plus sur les différents projets et trouver des liens importants sur notre [page sur la couche 2](/layer-2/).
 
 ## 2. Accédez au pont sélectionné
 
 Quelques exemples de solutions de seconde couche populaires :
 
-- [Pont Arbitrum](https://bridge.arbitrum.io/?l2ChainId=42161)
+- [Pont Arbitrum](https://portal.arbitrum.io/bridge?l2ChainId=42161)
 - [Pont Optimism](https://app.optimism.io/bridge/deposit)
-- [Pont Boba Network](https://gateway.boba.network/)
+- [Pont du réseau Boba](https://hub.boba.network/)
 
 ## 3. Connectez-vous au pont avec votre portefeuille
 
 Assurez-vous que votre portefeuille est connecté au réseau principal Ethereum. Si ce n'est pas le cas, le site vous demandera automatiquement de changer de réseau.
 
-![Interface commune pour transférer des jetons](./bridge1.png)
+![Interface commune pour la mise en pont de jetons](./bridge1.png)
 
 ## 4. Indiquez le montant et transférez les fonds
 
 Vérifiez le montant que vous recevrez sur le réseau de seconde couche et les frais associés pour éviter les mauvaises surprises.
 
-![Interface commune pour transférer des jetons](./bridge2.png)
+![Interface commune pour la mise en pont de jetons](./bridge2.png)
 
 ## 5. Confirmez cette transaction dans votre portefeuille
 
-Vous devrez payer des frais en ETH pour traiter la transaction.
+Vous devrez payer des frais (appelés [gaz](/glossary/#gas)) sous forme d'ETH pour le traitement de la transaction.
 
-![Interface commune pour transférer des jetons](./bridge3.png)
+![Interface commune pour la mise en pont de jetons](./bridge3.png)
 
 ## 6. Attendez que vos fonds soient transférés
 
@@ -49,8 +49,7 @@ Cette opération ne devrait pas prendre plus de 10 minutes.
 
 ## 7. Ajoutez le réseau de la seconde couche sélectionnée sur votre portefeuille (facultatif)
 
-Vous pouvez utiliser chainlist.org pour trouver les détails RPC du réseau. Une fois le réseau ajouté et la transaction terminée, vous devriez voir les jetons dans votre portefeuille.
-<br />
+Vous pouvez utiliser [chainlist.org](http://chainlist.org) pour trouver les détails RPC du réseau. Une fois le réseau ajouté et la transaction terminée, vous devriez voir les jetons dans votre portefeuille. <br />
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
@@ -66,7 +65,7 @@ Vous pouvez utiliser chainlist.org pour trouver les détails RPC du réseau. Une
 
 ### Et si j'ai des fonds sur une plateforme d'échange ?
 
-Il se pourrait que vous puissiez retirer vos fonds directement vers certains réseaux de seconde couche depuis une plateforme d'échange. Consultez notre section “Passer à la couche 2” sur notre [page sur la Couche 2](/layer-2/) pour plus d'information.
+Il se pourrait que vous puissiez retirer vos fonds directement vers certains réseaux de seconde couche depuis une plateforme d'échange. Consultez la section « Passer à la couche 2 » de notre [page sur la couche 2](/layer-2/) pour plus d'informations.
 
 ### Puis-je revenir sur le réseau principal Ethereum après avoir transféré mes jetons vers une seconde couche 2 ?
 
diff --git a/public/content/translations/fr/guides/how-to-use-a-wallet/index.md b/public/content/translations/fr/guides/how-to-use-a-wallet/index.md
index e61df1afe2b..f78354799e4 100644
--- a/public/content/translations/fr/guides/how-to-use-a-wallet/index.md
+++ b/public/content/translations/fr/guides/how-to-use-a-wallet/index.md
@@ -1,13 +1,13 @@
 ---
 title: Comment utiliser un portefeuille
-metaTitle: Comment utiliser un portefeuille Ethereum | Étape par étape
-description: Un guide expliquant comment envoyer, recevoir des jetons et se connecter à des projets web3.
+metaTitle: "Comment utiliser un portefeuille Ethereum | Étape par étape"
+description: "Un guide expliquant comment envoyer, recevoir des jetons et se connecter à des projets web3."
 lang: fr
 ---
 
 # Comment utiliser un portefeuille
 
-Apprenez à utiliser toutes les fonctions de base d'un portefeuille. Si vous n'en possédez pas encore, consultez notre[Comment créer un compte Ethereum](/guides/how-to-create-an-ethereum-account/).
+Apprenez à utiliser toutes les fonctions de base d'un portefeuille. Si vous n'en avez pas encore, consultez notre guide [Comment créer un compte Ethereum](/guides/how-to-create-an-ethereum-account/).
 
 ## Ouvrir votre portefeuille
 
@@ -39,8 +39,7 @@ Voulez-vous envoyer ETH à un autre portefeuille ?
 3. Entrez l'adresse de réception ou scannez un code QR avec votre caméra afin que vous n'ayez pas à écrire l'adresse manuellement.
 4. Cliquez sur le bouton « Envoyer » dans votre portefeuille (ou sur une alternative de la même forme).
 
-![Champ d'envoi de l'adresse crypto](./send.png)
-<br/>
+![Champ d'envoi pour l'adresse de cryptomonnaie](./send.png) <br/>
 
 5. De nombreux actifs, comme le DAI ou l'USDC, existent sur plusieurs réseaux. Lors du transfert de crypto-jetons, assurez-vous que le destinataire utilise le même réseau que vous, car ceux-ci ne sont pas interchangeables.
 6. Assurez-vous que votre portefeuille a suffisamment d'ETH pour couvrir les frais de transaction, qui varient selon les conditions du réseau. La plupart des portefeuilles ajouteront automatiquement les frais suggérés à la transaction que vous pourrez ensuite confirmer.
@@ -54,14 +53,14 @@ Votre adresse sera la même pour tous les projets Ethereum. Vous n'avez pas beso
 2. Si la page d'accueil du projet n'est qu'une description statique du projet, vous devriez être en mesure de cliquer sur le bouton « Ouvrir l'application » dans le menu qui vous mènera vers l'application web actuelle.
 3. Une fois que vous êtes dans l'application, cliquez sur « Connecter ».
 
-![Bouton permettant à l'utilisateur de se connecter au site avec un portefeuille](./connect1.png)
+![Bouton permettant à l'utilisateur de se connecter au site Web avec un portefeuille](./connect1.png)
 
 4. Sélectionnez votre portefeuille à partir de la liste des options fournies. Si vous ne pouvez pas voir votre portefeuille, il peut être caché sous l’option « WalletConnect ».
 
-![Sélection à partir d'une liste de portefeuilles avec lesquels se connecter](./connect2.png)
+![Sélection dans une liste de portefeuilles avec lesquels se connecter](./connect2.png)
 
 5. Confirmez la demande de signature dans votre portefeuille pour établir la connexion. **La signature de ce message ne devrait pas nécessiter de dépenser des ETH**.
-6. C’est tout! Commencez à utiliser l'application. Vous pouvez trouver des projets intéressants sur notre page [dApps](/apps/#explore). <br />
+6. C’est tout! Commencez à utiliser l'application. Vous pouvez trouver des projets intéressants sur notre [page dApps](/apps/#explore). <br />
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
@@ -77,7 +76,7 @@ Votre adresse sera la même pour tous les projets Ethereum. Vous n'avez pas beso
 
 ### Si je possède une adresse ETH, est-ce que je peux l'utiliser sur d'autres blockchains ?
 
-Vous pouvez utiliser la même adresse sur toutes les blockchains compatibles EVM (si vous utilisez un portefeuille avec une phrase de récupération). Cette [liste](https://chainlist.org/) vous présente les blockchains que vous pouvez utiliser avec la même adresse. Certaines blockchains, comme Bitcoin, utilisent un ensemble de règles de réseau totalement différentes et vous aurez donc besoin d'une adresse différente fonctionnant sous un autre format. Si vous utilisez un portefeuille de contrats intelligents, vous pouvez consulter son site web pour plus d'informations sur les blockchains pris en charge.
+Vous pouvez utiliser la même adresse sur toutes les blockchains compatibles EVM (si vous utilisez un portefeuille avec une phrase de récupération). Cette [liste](https://chainlist.org/) vous montrera quelles blockchains vous pouvez utiliser avec la même adresse. Certaines blockchains, comme Bitcoin, utilisent un ensemble de règles de réseau totalement différentes et vous aurez donc besoin d'une adresse différente fonctionnant sous un autre format. Si vous utilisez un portefeuille de contrats intelligents, vous pouvez consulter son site web pour plus d'informations sur les blockchains pris en charge.
 
 ### Puis-je utiliser la même adresse sur plusieurs appareils ?
 
@@ -85,7 +84,7 @@ Bien entendu, vous pouvez utiliser la même adresse sur plusieurs appareils. Tec
 
 ### Je n'ai pas reçu la cryptomonnaie, où puis-je vérifier l'état d'une transaction ?
 
-Vous pouvez utiliser [l'explorateur de bloc](/developers/docs/data-and-analytics/block-explorers/) afin de vérifier l'état d'une transaction en temps réel. Tout ce que vous avez à faire est de chercher l'adresse de votre portefeuille ou l'ID de la transaction.
+Vous pouvez utiliser des [explorateurs de blocs](/developers/docs/data-and-analytics/block-explorers/) pour voir le statut de n'importe quelle transaction en temps réel. Tout ce que vous avez à faire est de chercher l'adresse de votre portefeuille ou l'ID de la transaction.
 
 ### Puis-je annuler ou retourner des transactions ?
 
diff --git a/public/content/translations/fr/guides/index.md b/public/content/translations/fr/guides/index.md
index a11f2e1290f..1be5c346435 100644
--- a/public/content/translations/fr/guides/index.md
+++ b/public/content/translations/fr/guides/index.md
@@ -1,6 +1,6 @@
 ---
 title: Guides sur Ethereum
-description: Une collection de guides expliquant en pratique les bases de l'utilisation d'Ethereum pour les débutants.
+description: "Une collection de guides expliquant en pratique les bases de l'utilisation d'Ethereum pour les débutants."
 lang: fr
 ---
 
@@ -10,7 +10,7 @@ Vous souhaitez entamer votre aventure sur Ethereum ? Nos guides pratiques vous c
 
 ## Premiers pas
 
-1. [Comment "créer" un compte Ethereum](/guides/how-to-create-an-ethereum-account/) -N'importe qui peut créer un portefeuille gratuitement. Ce guide vous montrera par où commencer.
+1. [Comment "créer" un compte Ethereum](/guides/how-to-create-an-ethereum-account/) - N'importe qui peut créer un portefeuille gratuitement. Ce guide vous montrera par où commencer.
 
 2. [Comment utiliser un portefeuille](/guides/how-to-use-a-wallet/) - Apprenez à envoyer et recevoir des jetons dans votre portefeuille et à connecter votre portefeuille à des projets.
 
@@ -18,10 +18,10 @@ Vous souhaitez entamer votre aventure sur Ethereum ? Nos guides pratiques vous c
 
 1. [Comment révoquer l'accès des contrats intelligents à vos cryptos](/guides/how-to-revoke-token-access/) - Si vous découvrez une transaction dans votre portefeuille que vous n'avez pas initiée, ce guide vous apprendra comment éviter que cela ne se reproduise.
 
-2. [Comment identifier les arnaques aux jetons](/guides/how-to-id-scam-tokens/) - Que sont les jetons d'arnaque, comment parviennent-ils à se faire passer pour légitimes et comment les identifier pour vous protéger et éviter les escroqueries.
+2. [Comment identifier les tokens frauduleux](/guides/how-to-id-scam-tokens/) - Que sont les tokens frauduleux ? Comment ces tokens se donnent-ils une apparence légitime, et comment les identifier pour vous protéger et éviter les arnaques ?
 
 ## Utiliser Ethereum
 
-1. [Comment transférer des jetons vers une seconde couche](/guides/how-to-use-a-bridge/) - Les transactions sur Ethereum sont-elles trop coûteuses ? Pensez à passer aux solutions de mise à l'échelle Ethereum appelées secondes couches.
+1. [Comment transférer des jetons vers la couche 2](/guides/how-to-use-a-bridge/) - Les transactions sur Ethereum sont-elles trop coûteuses ? Pensez à passer aux solutions de mise à l'échelle Ethereum appelées secondes couches.
 
 2. [Comment échanger des jetons](/guides/how-to-swap-tokens/) - Souhaitez-vous échanger vos jetons contre un autre ? Ce guide simple vous montrera comment procéder.
diff --git a/public/content/translations/fr/nft/index.md b/public/content/translations/fr/nft/index.md
index 15eb35a83d7..bf1f9e70077 100644
--- a/public/content/translations/fr/nft/index.md
+++ b/public/content/translations/fr/nft/index.md
@@ -1,44 +1,44 @@
 ---
 title: Jetons non fongibles (NFT)
 metaTitle: Que sont les NFT ? | Avantages et utilisation
-description: Un aperçu des NFT sur Ethereum
+description: "Un aperçu des NFT sur Ethereum"
 lang: fr
 template: use-cases
 emoji: ":frame_with_picture:"
 sidebarDepth: 2
 image: /images/infrastructure_transparent.png
-alt: Un logo Eth affiché par hologramme.
-summaryPoint1: Un moyen de représenter toute chose unique en tant qu'actif Ethereum.
-summaryPoint2: Les NFT offrent plus de possibilités que jamais aux créateurs de contenus.
-summaryPoint3: Propulsés par des contrats intelligents sur la blockchain Ethereum.
+alt: "Un logo Eth affiché par hologramme."
+summaryPoint1: "Un moyen de représenter toute chose unique en tant qu'actif Ethereum."
+summaryPoint2: "Les NFT offrent plus de possibilités que jamais aux créateurs de contenus."
+summaryPoint3: "Propulsés par des contrats intelligents sur la blockchain Ethereum."
 ---
 
 ## Que sont les NFT ? {#what-are-nfts}
 
-Les NFT sont des jetons qui sont **individuellement uniques**. Chaque NFT a des propriétés différentes (non fongibles) et sa rareté est prouvée. Ils diffèrent des jetons tels que [l'ETH](/glossary/#ether) ou d'autres jetons basés sur Ethereum comme l'USDC, où chaque jeton est identique et possède les mêmes propriétés (« fongibles »). Vous ne vous souciez pas de savoir quel type de billet (ou d'ETH) vous possédez dans votre portefeuille, parce qu'ils sont tous identiques et valent tous la même chose. Cependant, vous vous souciez de savoir quel NFT spécifique vous possédez, car ils ont tous des propriétés individuelles qui les distinguent des autres ("non fongibles").
+Les NFT sont des jetons qui sont **individuellement uniques**. Chaque NFT a des propriétés différentes (non fongibles) et sa rareté est prouvée. Ceci est différent des jetons tels que [l'ETH](/glossary/#ether) ou d'autres jetons basés sur Ethereum comme l'USDC, où chaque jeton est identique et possède les mêmes propriétés (« fongibles »). Vous ne vous souciez pas de savoir quel type de billet (ou d'ETH) vous possédez dans votre portefeuille, parce qu'ils sont tous identiques et valent tous la même chose. Cependant, vous vous souciez _bel et bien_ de savoir quel NFT spécifique vous possédez, car ils ont tous des propriétés individuelles qui les distinguent les uns des autres (« non fongibles »).
 
 Le caractère unique de chaque NFT permet la tokenisation de choses telles que l'art, les objets de collection ou même l'immobilier, où un NFT unique et spécifique représente un objet numérique ou réel unique et spécifique. La propriété d'un actif est publiquement vérifiable sur la [blockchain](/glossary/#blockchain) Ethereum.
 
 <YouTube id="Xdkkux6OxfM" />
 
-## L'internet des ressources {#internet-of-assets}
+## L'internet des actifs {#internet-of-assets}
 
-Les NFT et Ethereum résolvent certains des problèmes qui se posent aujourd'hui sur l'internet. Alors que tout devient de plus en plus numérique, il y a un besoin de reproduire les propriétés des objets physiques tels que la rareté, l'unicité et la preuve de propriété d'une manière qui n'est pas contrôlée par une entité centralisée. Par exemple, avec les NFT, vous pouvez posséder un fichier mp3 de musique dans toutes les applications basées sur Ethereum et ne pas être lié à l'application musicale spécifique d'une société comme Spotify ou Apple Music. Vous pouvez posséder un identifiant de média social que vous pouvez vendre ou échanger, mais **qui ne peut pas vous être retiré arbitrairement** par un fournisseur de plateforme.
+Les NFT et Ethereum résolvent certains des problèmes qui se posent aujourd'hui sur l'internet. Alors que tout devient de plus en plus numérique, il y a un besoin de reproduire les propriétés des objets physiques tels que la rareté, l'unicité et la preuve de propriété d'une manière qui n'est pas contrôlée par une entité centralisée. Par exemple, avec les NFT, vous pouvez posséder un fichier mp3 de musique dans toutes les applications basées sur Ethereum et ne pas être lié à l'application musicale spécifique d'une société comme Spotify ou Apple Music. Vous pouvez posséder un identifiant de réseau social que vous pouvez vendre ou échanger, mais qui **ne peut pas vous être retiré arbitrairement** par un fournisseur de plateforme.
 
 Voici à quoi ressemble un internet de NFT par rapport à l'internet que la plupart d'entre nous utilisons aujourd'hui...
 
 ### Une comparaison {#nft-comparison}
 
-| Un internet NFT                                                                                                                                                                                                | Internet aujourd'hui                                                                                                                                                                                          |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Vous possédez vos actifs !** Vous seul pouvez les vendre ou les échanger.                                                                                                                                    | **Vous louez un actif** à une organisation et il peut vous être retiré.                                                                                                                                       |
-| Les NFT sont **uniques sur le plan numérique** ; il n'y aura jamais deux NFT identiques.                                                                                                                       | **Une copie ne peut pas être distingué** de l'original.                                                                                                                                                       |
-| La propriété d'un NFT est stockée sur la blockchain et peut être **vérifiée** par n'importe qui.                                                                                                               | L'accès aux registres de propriété des objets numériques est **contrôlé par les institutions** - vous devez leur demander pour y accéder.                                                                     |
-| Les NFT sont des [contrats intelligents](/glossary/#smart-contract) sur Ethereum. Cela signifie qu'ils **peuvent facilement être utilisés dans d'autres contrats intelligents** et applications sur Ethereum ! | Les entreprises qui possèdent des objets numériques **requièrent généralement leurs propres infrastructure de type « jardin clos »**.                                                                         |
-| Les **créateurs de contenu peuvent vendre leur travail n'importe où** et accéder à un marché mondial.                                                                                                          | Les créateurs dépendent de l'infrastructure et de la distribution des plates-formes qu'ils utilisent. Celles-ci sont souvent soumises à des conditions d'utilisation et à des **restrictions géographiques**. |
-| Les créateurs de NFT **peuvent conserver les droits** de propriété sur leur propre travail et programmer les redevances directement dans le contrat NFT.                                                       | Les plateformes, telles que **les services de streaming musical, conservent la majorité des profits issus des ventes**.                                                                                       |
+| Un internet NFT                                                                                                                                                                                                                | Internet aujourd'hui                                                                                                                                                                                                                          |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Vous possédez vos actifs !** Vous seul pouvez les vendre ou les échanger.                                                                                                                                    | **Vous louez un actif** à une organisation et il peut vous être retiré.                                                                                                                                                       |
+| Les NFT sont **uniques sur le plan numérique**, il n'y a pas deux NFT identiques.                                                                                                                              | **Une copie ne peut souvent pas être distinguée** de l'original.                                                                                                                                                              |
+| La propriété d'un NFT est stockée sur la blockchain pour que n'importe qui puisse la **vérifier publiquement**.                                                                                                | L'accès aux registres de propriété des articles numériques est **contrôlé par des institutions** – vous devez les croire sur parole.                                                                                          |
+| Les NFT sont des [contrats intelligents](/glossary/#smart-contract) sur Ethereum. Cela signifie qu'ils **peuvent facilement être utilisés dans d'autres contrats intelligents** et applications sur Ethereum ! | Les entreprises possédant des articles numériques **requièrent généralement leur propre infrastructure de type « jardin fermé »**.                                                                                            |
+| Les **créateurs de contenu peuvent vendre leur travail n'importe où** et peuvent accéder à un marché mondial.                                                                                                  | Les créateurs dépendent de l'infrastructure et de la distribution des plates-formes qu'ils utilisent. Celles-ci sont souvent soumises à des conditions d'utilisation et à des **restrictions géographiques**. |
+| Les créateurs de NFT **peuvent conserver les droits de propriété** sur leur propre travail et programmer les redevances directement dans le contrat NFT.                                                       | Les plateformes, telles que les services de **streaming musical, conservent la majorité des bénéfices des ventes**.                                                                                                           |
 
-## Comment les NFT sont-ils utilisés ? {#nft-use-cases}
+## Comment les NFT sont-ils utilisés ? Cas d'utilisation des NFT {#nft-use-cases}
 
 Les NFT sont utilisés pour de nombreuses choses, notamment :
 
@@ -51,29 +51,29 @@ Les NFT sont utilisés pour de nombreuses choses, notamment :
 - autoriser l'accès au contenu
 - billetterie
 - noms de domaines Internet décentralisés
-- caution dans [la finance décentralisée](/glossary/#defi)
+- garantie dans la [finance décentralisée](/glossary/#defi)
 
-Vous êtes peut-être un artiste qui souhaite partager ses œuvres à l'aide de NFT, sans en perdre le contrôle et sans sacrifier ses bénéfices à des intermédiaires. Vous pouvez créer un nouveau contrat et spécifier le nombre de NFT, leurs propriétés et un lien vers une œuvre d'art spécifique. En tant qu'artiste, **vous pouvez programmer dans le contrat intelligent les redevances** qui doivent vous être versées (par exemple transférer 5 % du prix de vente au détenteur du contrat chaque fois qu'un NFT est transféré). Vous pouvez également toujours prouver que vous êtes le créateur des NFT car vous détenez le [portefeuille](/glossary/#wallet) qui a déployé le contrat. Vos acheteurs peuvent facilement prouver qu'ils possèdent un **authentique NFT** de votre collection car leur [adresse](/glossary/#address) de portefeuille est associée à un jeton dans votre contrat intelligent. Ils peuvent l'utiliser dans l'écosystème Ethereum, sûrs de son authenticité.
+Vous êtes peut-être un artiste qui souhaite partager ses œuvres à l'aide de NFT, sans en perdre le contrôle et sans sacrifier ses bénéfices à des intermédiaires. Vous pouvez créer un nouveau contrat et spécifier le nombre de NFT, leurs propriétés et un lien vers une œuvre d'art spécifique. En tant qu'artiste, **vous pouvez programmer dans le contrat intelligent les redevances** qui doivent vous être versées (p. ex., transférer 5 % du prix de vente au propriétaire du contrat chaque fois qu'un NFT est transféré). Vous pouvez également toujours prouver que vous avez créé les NFT, car vous possédez le [portefeuille](/glossary/#wallet) qui a déployé le contrat. Vos acheteurs peuvent facilement prouver qu'ils possèdent un **NFT authentique** de votre collection, car l'[adresse](/glossary/#address) de leur portefeuille est associée à un jeton dans votre contrat intelligent. Ils peuvent l'utiliser dans l'écosystème Ethereum, sûrs de son authenticité.
 
 <Alert variant="update" className="mt-8">
 <AlertEmoji text=":eyes:"/>
 <AlertContent className="justify-between flex-row items-center">
   <div>Explorez, achetez ou créez vos propres collections NFT...</div>
   <ButtonLink href="/apps/categories/collectibles">
-    Explorez les cartes NFT
+    Explorer l'art NFT
   </ButtonLink>
 </AlertContent>
 </Alert>
 
-Par exemple, pensez à un billet pour un événement sportif. Tout comme **l'organisateur d'un événement peut décider du nombre de billets à vendre**, le créateur d'un NFT peut décider du nombre de répliques existantes. Il s'agit parfois de répliques exactes telles que 5 000 billets d'entrée générale. Parfois, plusieurs très similaires sont créés, chacun légèrement différent, comme un billet avec un siège assigné. Ils peuvent être achetés et vendus de pair à pair sans avoir à payer de frais de billetterie et l'acheteur peut toujours s'assurer de l'authenticité du billet en vérifiant l'adresse du contrat.
+Par exemple, pensez à un billet pour un événement sportif. Tout comme un **organisateur d'événement peut choisir le nombre de billets à vendre**, le créateur d'un NFT peut décider du nombre de répliques qui existent. Il s'agit parfois de répliques exactes telles que 5 000 billets d'entrée générale. Parfois, plusieurs très similaires sont créés, chacun légèrement différent, comme un billet avec un siège assigné. Ils peuvent être achetés et vendus de pair à pair sans avoir à payer de frais de billetterie et l'acheteur peut toujours s'assurer de l'authenticité du billet en vérifiant l'adresse du contrat.
 
-Sur ethereum.org, les **NFT sont utilisés pour démontrer que des personnes ont contribué** de manière significative à notre dépôt Github (programmation du site web, rédaction ou modification d'un article...), ont traduit notre contenu, ou ont participé à nos appels à la communauté, et nous avons même notre propre nom de domaine NFT. Si vous contribuez à ethereum.org, vous pouvez réclamer un NFT [POAP](/glossary/#poap). Certains rassemblements crypto ont utilisé des POAP comme billets. [Plus d'infos sur la contribution](/contributing/#poap).
+Sur ethereum.org, **les NFT sont utilisés pour démontrer que des personnes ont contribué de manière significative** à notre dépôt Github (programmé le site web, rédigé ou modifié un article...), traduit notre contenu ou assisté à nos appels communautaires, et nous avons même notre propre nom de domaine NFT. Si vous contribuez à ethereum.org, vous pouvez réclamer un NFT [POAP](/glossary/#poap). Certains rassemblements crypto ont utilisé des POAP comme billets. [En savoir plus sur la contribution](/contributing/#poap).
 
-![POAP ethereum.org](./poap.png)
+![POAP d'ethereum.org](./poap.png)
 
-Ce site web dispose également d'un nom de domaine alternatif NFT, **ethereum.eth**. Notre adresse `.org` est gérée de façon centralisée par un fournisseur de noms de domaine (DNS) alors que ethereum`.eth` est enregistré sur Ethereum par le service Ethereum Name Service (ENS). Nous en sommes les propriétaires et les gestionnaires. [Consulter notre dossier ENS](https://app.ens.domains/name/ethereum.eth)
+Ce site web possède également un nom de domaine alternatif alimenté par les NFT, **ethereum.eth**. Notre adresse `.org` est gérée de manière centralisée par un fournisseur de système de noms de domaine (DNS), tandis qu'ethereum`.eth` est enregistré sur Ethereum via l'Ethereum Name Service (ENS). Nous en sommes les propriétaires et les gestionnaires. [Consultez notre enregistrement ENS](https://app.ens.domains/name/ethereum.eth)
 
-[Plus d'infos sur le service ENS](https://app.ens.domains)
+[En savoir plus sur l'ENS](https://app.ens.domains)
 
 <Divider />
 
@@ -83,17 +83,17 @@ Les NFT, comme tous les objets numériques de la blockchain Ethereum, sont cré
 
 Le contrat intelligent NFT peut accomplir quelques tâches essentielles :
 
-- **Création de NFT :** Il peut créer de nouveaux NFT.
-- **Attribution de la propriété :** Il permet de savoir qui possède quels NFT en les reliant à des adresses Ethereum spécifiques.
-- **Attribution d'un identifiant à chaque NFT :** Chaque NFT possède un numéro qui le rend unique. En outre, il est généralement accompagné d'informations (métadonnées) décrivant ce qu'il représente.
+- **Créer des NFT :** il peut créer de nouveaux NFT.
+- **Attribuer la propriété :** il assure le suivi de qui possède quels NFT en les liant à des adresses Ethereum spécifiques.
+- **Donner un ID à chaque NFT :** chaque NFT possède un numéro qui le rend unique. En outre, il est généralement accompagné d'informations (métadonnées) décrivant ce qu'il représente.
 
 Lorsque quelqu'un "crée" ou "frappe" un NFT, il demande au contrat intelligent de lui donner la propriété d'un NFT particulier. Cette information est stockée publiquement et en toute sécurité dans la blockchain.
 
-En outre, le créateur du contrat peut ajouter des règles supplémentaires. Elles peuvent limiter le nombre d'exemplaires d'un certain NFT ou décider qu'ils recevront une petite redevance chaque fois que le NFT changera de mains.
+En outre, le créateur du contrat peut ajouter des règles supplémentaires. Ils peuvent limiter le nombre d'exemplaires d'un certain NFT pouvant être créés ou décider qu'ils devraient recevoir une petite commission de redevance chaque fois que le NFT change de mains.
 
-### Sécurité NFT {#nft-security}
+### Sécurité des NFT {#nft-security}
 
-La sécurité d'Ethereum émane de la [preuve d'enjeu](/glossary/#pos). Le système est conçu pour décourager économiquement les actions malveillantes, ce qui rend Ethereum infalsifiable. C'est ce qui rend les NFT possibles. Une fois le [bloc](/glossary/#block) contenant votre transaction NFT [finalisé](/glossary/#finality), un attaquant devrait dépenser des millions d'ETH pour le modifier. Quiconque exécute un logiciel Ethereum serait immédiatement capable de détecter des manipulations malhonnêtes avec un NFT, et la personne malveillante serait économiquement pénalisée et rejetée.
+La sécurité d'Ethereum provient de la [preuve d'enjeu](/glossary/#pos). Le système est conçu pour décourager économiquement les actions malveillantes, ce qui rend Ethereum infalsifiable. C'est ce qui rend les NFT possibles. Une fois que le [bloc](/glossary/#block) contenant votre transaction NFT est [finalisé](/glossary/#finality), il en coûterait des millions d'ETH à un attaquant pour le modifier. Quiconque exécute un logiciel Ethereum serait immédiatement capable de détecter des manipulations malhonnêtes avec un NFT, et la personne malveillante serait économiquement pénalisée et rejetée.
 
 Les questions de sécurité concernant les NFT sont le plus souvent liées aux escroqueries par hameçonnage, aux vulnérabilités des contrats intelligents ou aux erreurs utilisateur (comme exposer par inadvertance des clés privées), rendant la sécurité du portefeuille critique pour les propriétaires de NFT.
 
@@ -101,10 +101,11 @@ Les questions de sécurité concernant les NFT sont le plus souvent liées aux e
   En savoir plus sur la sécurité
 </ButtonLink>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [A beginner's guide to NFTs](https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d) – _Linda Xie, Janvier 2020_
-- [Traqueur de NFTs de Etherscan](https://etherscan.io/nft-top-contracts)
+- [Un guide du débutant sur les NFT](https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d) – _Linda Xie, janvier 2020_
+- [Traqueur de NFT Etherscan](https://etherscan.io/nft-top-contracts)
+- [Traqueur de NFT Blockscout](https://eth.blockscout.com/tokens?type=ERC-721,ERC-1155,ERC-404)
 - [Norme de jeton ERC-721](/developers/docs/standards/tokens/erc-721/)
 - [Norme de jeton ERC-1155](/developers/docs/standards/tokens/erc-1155/)
 - [Applications et outils NFT populaires](https://www.ethereum-ecosystem.com/blockchains/ethereum/nfts)
diff --git a/public/content/translations/fr/payments/index.md b/public/content/translations/fr/payments/index.md
index 057e43b8465..311e348d1fa 100644
--- a/public/content/translations/fr/payments/index.md
+++ b/public/content/translations/fr/payments/index.md
@@ -1,36 +1,35 @@
 ---
 title: Paiements Ethereum
 metaTitle: Paiements sur Ethereum
-description: Un aperçu des paiements sur Ethereum
+description: "Un aperçu des paiements sur Ethereum"
 lang: fr
 template: use-cases
 emoji: ":frame_with_picture:"
 sidebarDepth: 2
 image: /images/impact_transparent.png
-alt: Logo d’Ethereum accompagné de mains tendues.
-summaryPoint1: Un monde où l’argent circule aussi librement que l’information
-summaryPoint2: Ouvert et global, permettant des transactions sans frontières pour tous
-summaryPoint3: Paiements reçus en moins d’une minute
+alt: "Logo d’Ethereum accompagné de mains tendues."
+summaryPoint1: "Un monde où l’argent circule aussi librement que l’information"
+summaryPoint2: "Ouvert et global, permettant des transactions sans frontières pour tous"
+summaryPoint3: "Paiements reçus en moins d’une minute"
 ---
 
 Chaque jour, des millions de personnes font face au même défi : transférer de l’argent à travers le monde est lent, coûteux et souvent frustrant. Un freelance à Bali attend plusieurs jours que le paiement de son client à New York soit validé. Cela touche particulièrement les personnes vivant dans des régions où l’infrastructure bancaire est limitée, rendant leur participation à l’économie mondiale difficile.
 
-Ce n’est pas un rêve lointain – cela se passe aujourd’hui sur Ethereum. Bien que les institutions financières traditionnelles aient mis des décennies à construire des systèmes de paiement solides, elles restent souvent limitées par les frontières, les horaires d’ouverture et des infrastructures héritées du passé. Ethereum propose un nouveau paradigme : une plateforme financière mondiale, accessible 24h/24 et 7j/7, qui permet des transactions quasi instantanées et programmables pour toute personne disposant d’un accès à Internet.
+Ce n'est pas un rêve lointain — cela se produit aujourd'hui sur Ethereum. Bien que les institutions financières traditionnelles aient mis des décennies à construire des systèmes de paiement solides, elles restent souvent limitées par les frontières, les horaires d’ouverture et des infrastructures héritées du passé. Ethereum propose un nouveau paradigme : une plateforme financière mondiale, accessible 24h/24 et 7j/7, qui permet des transactions quasi instantanées et programmables pour toute personne disposant d’un accès à Internet.
 
 <div style={{maxWidth: "320px", margin: "0 auto"}}>
 
 ![Logo Ethereum sur un écran d’ordinateur](./computer.png)
-
 </div>
 
 ## Transferts de fonds : des envois internationaux moins coûteux {#remittances}
 
 Pour des millions de personnes travaillant à l’étranger, envoyer de l’argent au pays est une nécessité régulière. Les services de transfert de fonds traditionnels s’accompagnent souvent de frais élevés et de délais de traitement longs. Ethereum propose une alternative intéressante.
 
-<CardGrid className="grid grid-cols-[repeat(auto-fill,_minmax(min(100%,_280px),_1fr))] gap-8">
-  <Card title="Cheaper Fees" emoji=":money_with_wings:" description="Remittance services charge up to $14 fees on average. Ethereum transactions can often be completed under $0.01."/>
-  <Card title="Faster Transfers" emoji="📶" description="International wire transfers take several days to process. Ethereum transactions are settled in minutes." />
-  <Card title="Open to anyone" emoji="🌎" description="You only need an internet connection and a wallet app to send or receive Ether." />
+<CardGrid>
+  <Card title="Frais moins chers" emoji=":money_with_wings:" description="Les services de transfert d'argent facturent en moyenne jusqu'à 14 $ de frais. Les transactions Ethereum peuvent souvent être réalisées pour moins de 0,01 $."/>
+  <Card title="Transferts plus rapides" emoji="📶" description="Les virements bancaires internationaux prennent plusieurs jours à être traités. Les transactions Ethereum sont réglées en quelques minutes." />
+  <Card title="Ouvert à tous" emoji="🌎" description="Vous n'avez besoin que d'une connexion Internet et d'une application de portefeuille pour envoyer ou recevoir de l'Ether." />
 </CardGrid>
 
 ## Accès aux monnaies mondiales {#access-to-global-currencies}
@@ -52,36 +51,82 @@ De nombreuses entreprises commencent à accepter l’ether (ETH) et d’autres c
 - **Newegg :** Le célèbre détaillant d’électronique accepte l’Ethereum pour les achats dans certains pays.
 - **Travala.com :** Cette plateforme de réservation de voyages permet aux utilisateurs de payer leurs hôtels et vols en Ethereum.
 - **Shopify :** Cette plateforme de commerce électronique populaire, qui héberge de nombreuses boutiques en ligne, accepte également les paiements en Ethereum pour les biens et services.
-- **Sotheby’s :** Cette maison de vente aux enchères spécialisée dans l’art, les bijoux et les objets de collection accepte les paiements en Ethereum et autres cryptomonnaies.
+- **Sotheby's :** cette organisation commercialise des œuvres d'art, des bijoux et des objets de collection, et autorise les paiements en Ethereum et en d'autres cryptomonnaies.
 
 Des pays comme le Salvador et la République centrafricaine ont même adopté les cryptomonnaies comme monnaie légale, ouvrant la voie à une adoption plus large des paiements en Ethereum dans les transactions quotidiennes.
 
 Dans les pays où les moyens de paiement ont été déconnectés du reste du monde, les solutions de paiement intégrant les cryptomonnaies ont constitué un grand soulagement. Le paiement d’abonnements à des plateformes comme Netflix, Spotify ou encore à des cours en ligne est désormais facilité grâce aux plateformes de paiement en cryptomonnaie telles que Gnosis Pay et PayPal.
 
-
 <Alert variant="update">
-<AlertEmoji text=":eyes:" />
+<AlertEmoji text=":eyes:"/>
 <AlertContent className="justify-between flex-row items-center">
   <div>Créez votre compte Ethereum dès aujourd’hui avec une application de portefeuille.</div>
   <ButtonLink href="/wallets/find-wallet">
     Commencer
   </ButtonLink>
 </AlertContent>
+
 </Alert>
 
-## Paiement des salaires {#salary-payments}
+## Payer avec des cartes crypto en auto-conservation {#pay-with-self-custodial-crypto-cards}
+
+Les cartes crypto en auto-conservation fonctionnent comme si vous utilisiez votre propre sac à dos au lieu d'enfermer votre argent dans le coffre-fort de quelqu'un d'autre. Avec une carte traditionnelle, une banque ou un dépositaire détient vos fonds et les libère lorsque vous dépensez. Avec les cartes en auto-conservation, vous gardez le contrôle de vos actifs en permanence — sans intermédiaire — tout en pouvant payer sans contact ou par carte pour un café, des courses ou même un vol.
+
+Ces cartes sont directement liées à des portefeuilles non dépositaires ou à des comptes de contrat intelligent, ce qui permet aux utilisateurs de dépenser des ETH et des stablecoins dans des situations quotidiennes sans renoncer à la propriété. Contrairement aux cartes dépositaires, qui exigent que les utilisateurs déposent des fonds auprès d'un tiers, les cartes en auto-conservation permettent des paiements dans le monde réel, comme avec Visa et Mastercard, tout en préservant le contrôle sur la chaîne.
+
+### Exemples {#crypto-cards-examples}
+
+- **Carte MetaMask :** liée au portefeuille MetaMask, cette carte de débit Mastercard permet aux utilisateurs de dépenser des ETH, des stablecoins et d'autres jetons pris en charge. Elle prend en charge Apple Pay et Google Pay, inclut des récompenses de cashback en crypto et offre des options de rendement.
+
+- **Carte Tuyo :** une carte Visa basée sur un contrat intelligent qui convertit automatiquement la crypto en USDC pour les dépenses partout où Visa est acceptée. Les utilisateurs conservent la garde de leurs actifs, avec un accès à des fonctionnalités de rendement, de trading et de dépenses.
+
+- **Gnosis Pay :** la première carte Visa en auto-conservation liée à un compte intelligent Gnosis Safe. Les utilisateurs dépensent leur crypto directement depuis leur portefeuille sans frais de gaz, de change ou de retrait. La personnalisation de la carte via Ethereum Name Service (ENS) est également prise en charge.
+
+- **Carte Ether.Fi Cash :** intégrée au protocole de staking d'ether.fi, cette carte permet aux utilisateurs de dépenser tout en gardant leurs ETH en staking. Les paiements sont gérés via des contrats intelligents, maintenant l'auto-conservation même lors des dépenses.
+
+### Comparaison des cartes crypto en auto-conservation {#crypto-card-custody-comparison}
+
+| **Carte crypto**              | **Auto-conservation** | **Non-autonome** | **Remarques clés**                                                                                      |
+| ----------------------------- | :-------------------: | :--------------: | ------------------------------------------------------------------------------------------------------- |
+| Carte MetaMask                |           ✅           |         ✅        | Le portefeuille reste dans MetaMask ; retrait automatique au moment du paiement.        |
+| Carte Tuyo                    |           ✅           |         ✅        | Le portefeuille intelligent convertit en USDC ; l'utilisateur conserve le contrôle.     |
+| Gnosis Pay                    |           ✅           |         ✅        | Liée au Gnosis Safe de l'utilisateur ; pas de transfert de garde lors de l'utilisation. |
+| Ether.Fi Cash |           ✅           |         ✅        | L'ETH reste en staking ; le contrat intelligent contrôle l'accès aux dépenses.          |
+
+> **Remarque :** le terme \"auto-conservation\" fait référence aux portefeuilles contrôlés par l'utilisateur, où celui-ci a un accès et un contrôle total sur ses fonds.
+> Le terme \"non dépositaire\" fait référence aux portefeuilles où les fonds sont gérés sans la garde d'un tiers, souvent par le biais de contrats intelligents.
+> Bien que toutes les cartes en auto-conservation soient non dépositaires, toutes les cartes non dépositaires ne sont pas en auto-conservation.
+
+## Micropaiements pour les sites web et les agents (x402) {#x402}
+
+[x402](https://www.x402.org/) est une norme de paiement ouverte qui apporte des paiements natifs par utilisation au web. En utilisant des [stablecoins](/stablecoins/) sur des [réseaux de couche 2 Ethereum](/layer-2/) à faible coût, la norme x402 permet aux humains et aux machines de payer de manière économique pour une action unique, comme la lecture d'un article de presse ou l'appel d'une API, plutôt que de gérer des clés d'API, des abonnements ou de \"payer\" en prêtant attention à la publicité.
+
+- **Suppression des murs de paiement et des connexions :** au lieu de créer un compte et de partager des informations personnelles pour lire un article de presse, votre portefeuille peut payer les quelques centimes nécessaires pour le déverrouiller.
+- **Paiements pour les agents d'IA :** x402 permet à des logiciels autonomes (\"agents d'IA\") de payer les données et les appels d'API dont ils ont besoin pour fonctionner, sans intervention humaine.
+
+### Fonctionnement de la norme de paiement x402 {#x402-how}
+
+Lorsqu'un client demande une ressource, le serveur envoie un code d'erreur `402 Payment Required` ainsi que des instructions de paiement (prix, compte, et quels jetons et chaînes sont pris en charge).
+
+- Votre [portefeuille](/wallets/) détecte la demande et gère le paiement (souvent en un seul clic pour l'approbation, ou automatiquement en utilisant une allocation pré-approuvée).
+- Les [agents d'IA](/ai-agents/) ayant accès à des soldes de portefeuille pré-approuvés peuvent détecter automatiquement le prix et payer instantanément pour accéder à des données ou des services.
+- Le client doit disposer de l'un des stablecoins pris en charge dans son portefeuille, mais n'a pas besoin d'avoir des ETH pour les [frais de gaz](/gas/).
+
+Cela débloque une nouvelle économie \"de machine à machine\" où les agents d'IA peuvent acheter des ressources par eux-mêmes, et où les services d'API peuvent être accessibles plus efficacement.
+
+Le message signé est ensuite transmis au serveur. Les serveurs utilisent généralement un [facilitateur x402](https://x402.gitbook.io/x402/core-concepts/facilitator) pour gérer la complexité de la blockchain (envoi de la transaction, obtention du paiement, facilitation des frais de gaz, etc.), ce qui signifie que les développeurs peuvent facilement accepter les micropaiements en crypto sans gérer l'infrastructure de paiement.
+
+## Paiements de salaires {#salary-payments}
 
 De nombreuses entreprises avant-gardistes offrent désormais à leurs employés la possibilité de recevoir leur salaire, ou une partie de celui-ci, en cryptomonnaies comme l’ether (ETH) :
 
-- **Gipsybee :** est une organisation spécialisée dans l’électronique, la robotique, la création de jeux et d’autres services. Ils offrent à leurs employés la possibilité d’être payés en Ethereum.
+- **Gipsybee :** est une organisation spécialisée dans l'électronique, la robotique, la création de jeux et d'autres services. Ils offrent à leurs employés la possibilité d’être payés en Ethereum.
 - **SC5 :** Cette entreprise finlandaise a été l’une des premières à proposer des salaires en Bitcoin, ouvrant la voie à des dispositifs similaires avec l’Ethereum.
 - **Startups blockchain :** De nombreuses entreprises du secteur blockchain proposent naturellement à leurs employés des possibilités de rémunération en cryptomonnaie.
 - **DAO :** En raison de la particularité et de la diversité des contributeurs au sein des DAO, la majorité des contributions et des rémunérations sont récompensées en cryptomonnaie.
 
 Cette tendance séduit particulièrement les travailleurs à distance et les nomades numériques, qui peuvent profiter de paiements sans frontières et, potentiellement, de taux de change avantageux.
 
-<Divider />
-
 ## Actions humanitaires mondiales {#global-relief-efforts}
 
 En février 2023, lorsque de violents séismes ont frappé la Turquie et la Syrie, la communauté crypto mondiale s’est immédiatement mobilisée. Diverses campagnes ont été lancées pour collecter des fonds en soutien aux opérations de secours, mettant en lumière la puissance d’Ethereum en temps de crise. Bien que les cryptomonnaies [ne soient pas reconnues comme moyen de paiement](https://www.reuters.com/technology/no-more-kebabs-bitcoins-turkeys-crypto-payment-ban-looms-2021-04-28/) en Turquie, les autorités ont accordé [des exceptions](https://x.com/haluklevent/status/1622913175409623041) à certaines organisations pour leur permettre de collecter des dons. Voici quelques exemples :
@@ -90,14 +135,14 @@ En février 2023, lorsque de violents séismes ont frappé la Turquie et la Syri
 - DAO Power : [Anka Relief DAO](https://ankarelief.org/) et [Bankless DAO](https://x.com/banklessDAO) ont uni leurs forces avec [Giveth](https://x.com/Giveth/status/1623493672149843969) pour collecter des fonds.
 - [Pak](https://cause.quest/), un artiste NFT de renom, a également contribué à cette cause.
 - Même le cofondateur d’Ethereum, [Vitalik Buterin](https://cointelegraph.com/news/vitalik-buterin-donates-227k-to-help-earthquake-victims-in-turkey-syria), a effectué des dons personnels en faveur de plusieurs campagnes.
-  Le résultat de tout cela ? Plus de 6 millions de dollars ont été récoltés en quelques jours, comme le montre un tableau de bord d'analyses [Dune](https://dune.com/davy42/turkiye-earthquake-donations).
+
+Le résultat de tout cela ? Plus de 6 millions de dollars ont été récoltés en quelques jours, comme le montre un tableau de bord d'analyses [Dune](https://dune.com/davy42/turkiye-earthquake-donations).
 
 Des temps de réponse similaires ont également été observés lors des tragédies survenues en Inde et en Ukraine. Cette réponse rapide met en évidence un avantage crucial des paiements via Ethereum : la capacité à mobiliser rapidement un soutien mondial, sans les obstacles liés à la conversion de devises, à la lenteur des virements bancaires ou aux frais exorbitants.
 
 <div style={{maxWidth: "320px", margin: "0 auto"}}>
 
 ![Image d’un robot Ethereum](./eth_robot.png)
-
 </div>
 
 ## Ethereum vs fiat {#ethereum-vs-fiat}
@@ -139,12 +184,11 @@ Chaque transaction sur la blockchain Ethereum est enregistrée dans un registre
 - Les entreprises, pour justifier les paiements effectués aux fournisseurs ou aux employés
 - Les particuliers, pour suivre leurs activités financières
 
-Avec Ethereum, tout le monde peut voir comment l’argent circule et de quelle manière les coûts sont appliqués, contrairement aux organisations traditionnelles où la plupart de ces informations restent inconnues.
+Avec Ethereum, tout le monde peut voir comment l'argent circule et comment les coûts sont mis en œuvre, contrairement aux organisations traditionnelles où la plupart de ces éléments restent inconnus.
 
 <div style={{maxWidth: "320px", margin: "0 auto"}}>
 
 ![image de marche](./walking.png)
-
 </div>
 
 Bien que les monnaies fiduciaires aient l'avantage d'une large acceptation et stabilité, Ethereum offre des avantages uniques qui en font une option attrayante pour certains types de transactions.
@@ -152,11 +196,12 @@ Bien que les monnaies fiduciaires aient l'avantage d'une large acceptation et st
 Qu'il s'agisse de faciliter les secours rapides en cas de catastrophe ou d'autonomiser les travailleurs du monde entier, les paiements en Ethereum écrivent un nouveau chapitre dans la longue histoire de l'argent. Bien que des défis subsistent, les avantages uniques offerts par cette technologie en font une option intéressante pour une large gamme de cas d’utilisation.
 
 <Alert variant="update">
-<AlertEmoji text=":eyes:" />
+<AlertEmoji text=":eyes:"/>
 <AlertContent className="justify-between flex-row items-center">
   <div>Le moment est venu de créer votre propre compte Ethereum.</div>
   <ButtonLink href="/wallets/find-wallet">
     Commencer
   </ButtonLink>
 </AlertContent>
-</Alert>
\ No newline at end of file
+
+</Alert>
diff --git a/public/content/translations/fr/prediction-markets/index.md b/public/content/translations/fr/prediction-markets/index.md
new file mode 100644
index 00000000000..b1bc1c225c8
--- /dev/null
+++ b/public/content/translations/fr/prediction-markets/index.md
@@ -0,0 +1,86 @@
+---
+title: "Marchés prédictifs"
+lang: fr
+template: use-cases
+image: /images/use-cases/prediction-markets.png
+sidebarDepth: 2
+summaryPoint1: "Recevez des incitations financières pour produire des prévisions précises"
+summaryPoint2: "Prédictions de haute qualité sur des événements futurs"
+buttons:
+  - content: En savoir plus
+    toId: how-prediction-markets-work
+  - content: Découvrir les Apps
+    toId: find-a-prediction-market
+    isSecondary: false
+---
+
+Les marchés prédictifs utilisent la sagesse collective et des incitations financières pour prévoir des événements. Ils offrent des données variées et de haute qualité et ont gagné en popularité lors des élections américaines de 2024.
+
+## Comment fonctionnent les marchés prédictifs {#how-prediction-markets-work}
+
+Contrairement aux méthodes de prévision traditionnelles qui reposent sur les avis d’experts, des échantillons d’enquête limités ou des données historiques, les marchés prédictifs s’appuient sur des **incitations financières en temps réel** et la **sagesse collective** pour produire des informations sur un événement donné — élections, prix des cryptomonnaies, résultats sportifs — n’importe quoi.
+
+Cela permet à chacun de manifester son soutien à un résultat spécifique par un engagement financier.
+En permettant de parier sur des événements réels et d’ajuster les prix à mesure que de nouvelles informations apparaissent, les opinions éclairées sont mieux valorisées et la précision peut être récompensée.
+
+En théorie, puisque les parieurs ont un intérêt à avoir raison, les marchés prédictifs peuvent prévoir les résultats avec une grande précision. Les marchés prédictifs basés sur la blockchain sont encore plus excitants, car pratiquement tout le monde peut y participer et gagner des récompenses en stablecoins ou en cryptomonnaies.
+
+## Pourquoi cela est-il important ? {#why-does-this-matter}
+
+Contrairement à la prévision traditionnelle, les marchés prédictifs basés sur la blockchain sont :
+
+<CardGrid>
+  <Card title="Incitatif" emoji=":money_with_wings:" description="Les participants misent des fonds réels, ce qui favorise des prédictions de haute qualité."/>
+  <Card title="Décentralisation" emoji="🌎" description="L'utilisation de la blockchain et des contrats intelligents assure des paiements transparents et automatisés." />
+  <Card title="Cotes déterminées par le marché" emoji="🤝" description="Les prix sont fixés par les traders qui achètent et vendent des parts de résultat, et non par un bookmaker centralisé." />
+</CardGrid>
+
+Même en tant qu’observateur du marché, vous pouvez accéder à des données précieuses qui seraient autrement indisponibles. Voyez cela comme ceci :
+
+1. Les prédictions sont liées à un événement spécifique (par exemple : Beam Chain sera-t-elle déployée d’ici 2030 ?).
+2. Les participants au marché achètent et vendent des parts en fonction de leur confiance dans un résultat donné.
+3. Les prix s’ajustent à mesure que davantage de participants misent sur leurs convictions, reflétant des informations en temps réel.
+4. Toute personne ayant parié correctement gagne proportionnellement au montant misé.
+5. Les observateurs du marché peuvent exploiter les données ouvertes pour alimenter leurs recherches ou leurs discussions.
+
+## Trouver un marché prédictif {#find-a-prediction-market}
+
+Il existe plusieurs marchés prédictifs disponibles basés sur Ethereum. Voici quelques-uns des marchés prédictifs les plus connus aujourd’hui :
+
+<PredictionMarketLists />
+
+<Alert variant="warning">
+<AlertEmoji text="💡"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Restez conscient des risques</strong></p>
+  <p className="mt-2">Ne pariez que ce que vous pouvez vous permettre, et soyez conscient des comportements potentiellement addictifs.</p>
+</AlertDescription>
+
+</AlertContent>
+
+</Alert>
+
+## Défis et risques {#challenges-and-risks}
+
+Les marchés prédictifs sur la blockchain rencontrent quelques défis pouvant affecter l’équité, la légalité et la précision.
+
+⚠️ **Manipulation du marché** – Des acteurs fortunés peuvent fausser les résultats via des opérations d'achat-revente fictives.  
+💧 **Problèmes de liquidité** – Une faible participation ([liquidité faible](https://www.investopedia.com/terms/t/thinmarket.asp)) peut réduire la fiabilité du marché.  
+🏛 **Incertitude réglementaire** – Certains gouvernements ont imposé des restrictions à certaines plateformes.
+
+Pour atténuer ces problèmes, les développeurs d’Ethereum expérimentent des solutions comme la futarchie (gouvernance par les marchés prédictifs) et la vérification d’identité décentralisée.
+
+## Expérimenter avec les marchés prédictifs {#experimenting-with-prediction-markets}
+
+Les marchés prédictifs redéfinissent la prise de décision à l’ère numérique. En s’appuyant sur Ethereum, ils offrent des moyens **équitables, ouverts et rémunérateurs de prédire l’avenir.**
+
+Il existe de nombreuses façons d’utiliser les outils de prévision en dehors du gain financier. Par exemple, dans une [proposition d’amélioration de DevCon](https://forum.devcon.org/t/futarchy-decision-markets-for-deciding-next-devcon/5305) (DIP), il a été suggéré que les organisateurs de DevCon utilisent des marchés prédictifs pour anticiper la participation à de futurs événements.
+
+Cela aiderait les organisateurs à déterminer quel lieu mènerait à l’événement le plus fréquenté, en comparaison avec celui qui serait le plus accessible au niveau international. Les avantages de cette approche permettent aux organisateurs de DevCon de réduire le temps nécessaire pour examiner plusieurs politiques de visa, l’accès aux aéroports et le coût de la vie dans la région, tout en recueillant des données sur les destinations qui enthousiasmeraient les participants potentiels.
+
+## En savoir plus {#further-reading}
+
+[Des marchés prédictifs à la finance de l'information](https://vitalik.eth.limo/general/2024/11/09/infofinance.html) – Vitalik Buterin
+[Développement d’un marché prédictif décentralisé sur Ethereum](https://blockchain.oodles.io/dev-blog/decentralized-prediction-market-development-ethereum/)
+[Le livre blanc du projet Augur](https://github.com/AugurProject/whitepaper)
\ No newline at end of file
diff --git a/public/content/translations/fr/privacy/index.md b/public/content/translations/fr/privacy/index.md
new file mode 100644
index 00000000000..6e5a44b982f
--- /dev/null
+++ b/public/content/translations/fr/privacy/index.md
@@ -0,0 +1,97 @@
+---
+title: "Confidentialité sur Ethereum"
+description: "Outils et techniques pour protéger votre confidentialité sur Ethereum"
+lang: fr
+---
+
+# Confidentialité sur Ethereum {#introduction}
+
+La confidentialité n'est pas seulement essentielle à la sécurité personnelle, elle est aussi la pierre angulaire de la liberté et un [garant clé de la décentralisation](https://vitalik.eth.limo/general/2025/04/14/privacy.html). La confidentialité donne aux gens la possibilité de s'exprimer, d'effectuer des transactions avec d'autres personnes et d'organiser des communautés librement. Mais comme pour toutes les blockchains, le registre public d'Ethereum rend la confidentialité difficile.
+
+Ethereum est transparent par conception. Toute action en chaîne est visible par quiconque la consulte. Bien qu'Ethereum offre un pseudonymat en liant votre activité à une [clé publique](/decentralized-identity/#public-key-cryptography) plutôt qu'à une identité réelle, les schémas d'activité peuvent être analysés pour révéler des informations sensibles et identifier des utilisateurs.
+
+L'intégration d'outils de protection de la confidentialité dans Ethereum peut aider les personnes, les organisations et les institutions à interagir en toute sécurité tout en limitant une exposition inutile. Cela rend l'écosystème plus sûr et plus pratique pour un plus large éventail de cas d'utilisation.
+
+## Confidentialité des écritures {#privacy-of-writes}
+
+Par défaut, chaque transaction écrite sur Ethereum est publique et permanente. Cela inclut non seulement l'envoi d'ETH, mais aussi l'enregistrement de noms ENS, la collecte de POAP ou l'échange de NFT. Les actions quotidiennes telles que les paiements, le vote ou la vérification d'identité peuvent révéler vos informations à des parties non intentionnelles. Il existe plusieurs outils et techniques qui peuvent aider à rendre ces actions plus confidentielles :
+
+### Protocoles de mixage (ou "mixeurs") {#mixing-protocols}
+
+Les mixeurs brisent le lien entre les expéditeurs et les destinataires en regroupant les transactions de nombreux utilisateurs dans un "pool" partagé, puis en permettant aux personnes de retirer ultérieurement des fonds vers une nouvelle adresse. Étant donné que les dépôts et les retraits sont mélangés, il est beaucoup plus difficile pour les observateurs de les relier.
+
+_Exemples : [PrivacyPools](https://docs.privacypools.com/), [Tornado Cash](https://tornado.cash/)_
+
+### Pools protégés {#shielded-pools}
+
+Les pools protégés sont similaires aux mixeurs, mais ils permettent aux utilisateurs de détenir et de transférer des fonds de manière privée à l'intérieur même du pool. Au lieu de simplement masquer le lien entre le dépôt et le retrait, les pools protégés maintiennent un état privé continu, souvent sécurisé par des preuves à divulgation nulle de connaissance. Cela permet de créer des transferts privés, des soldes privés, et plus encore.
+
+_Exemples : [Railgun](https://www.railgun.org/), [Aztec](https://aztec.network/), Nightfall_
+
+### Adresses furtives {#stealth-addresses}
+
+Une [adresse furtive](https://vitalik.eth.limo/general/2023/01/20/stealth.html) revient à donner à chaque expéditeur une boîte postale unique et à usage unique. que vous seul pouvez ouvrir. Chaque fois que quelqu'un vous envoie des cryptomonnaies, elles sont dirigées vers une nouvelle adresse, de sorte que personne d'autre ne peut voir que tous ces paiements vous appartiennent. Cela maintient la confidentialité de votre historique de paiement et le rend plus difficile à suivre.
+
+_Exemples : [UmbraCash](https://app.umbra.cash/faq), [FluidKey](https://www.fluidkey.com/)_
+
+### Autres cas d'utilisation {#other-use-cases}
+
+D'autres projets explorant les écritures privées incluent [PlasmaFold](https://pse.dev/projects/plasma-fold) (paiements privés) et des systèmes comme [MACI](https://pse.dev/projects/maci) et [Semaphore](https://pse.dev/projects/semaphore) (vote privé).
+
+Ces outils étendent les options d'écriture privée sur Ethereum, mais chacun comporte des compromis. Certaines approches sont encore expérimentales, d'autres augmentent les coûts ou la complexité, et certains outils comme les mixeurs peuvent faire l'objet d'un examen juridique ou réglementaire en fonction de leur utilisation.
+
+## Confidentialité des lectures {#privacy-of-reads}
+
+La lecture ou la vérification de toute information sur Ethereum (par exemple, le solde de votre portefeuille) passe généralement par un service tel que votre fournisseur de portefeuille, un fournisseur de nœud ou un explorateur de blocs. Parce que vous comptez sur eux pour lire la blockchain pour vous, ils peuvent également voir vos requêtes ainsi que des métadonnées comme votre adresse IP ou votre emplacement. Si vous continuez à vérifier le même compte, ces informations peuvent être rassemblées pour lier votre identité à votre activité.
+
+L'exécution de votre propre nœud Ethereum empêcherait cela, mais le stockage et la synchronisation de l'intégralité de la blockchain restent coûteux et peu pratiques pour la plupart des utilisateurs, en particulier sur les appareils mobiles.
+
+Certains projets explorant les lectures privées incluent [Private Information Retrieval](https://hackmd.io/@brech1/ethereum-privacy-pir?utm_source=preview-mode&utm_medium=rec) (PIR, récupérer des données sans révéler ce que vous recherchez), [zkID](https://hackmd.io/@brech1/ethereum-privacy-pir?utm_source=preview-mode&utm_medium=rec) (vérifications d'identité privées avec des preuves à divulgation nulle de connaissance), [vOPRF](https://pse.dev/projects/voprf) (utiliser des comptes Web2 de manière pseudonyme dans le Web3), [vFHE](https://pse.dev/blog/zero-to-start-applied-fully-homomorphic-encryption-fhe-part-1) (calculer sur des données chiffrées), et [MachinaIO](https://pse.dev/projects/machina-io) (masquer les détails du programme tout en conservant les fonctionnalités).
+
+## Confidentialité des preuves {#privacy-of-proving}
+
+Les preuves préservant la confidentialité sont des outils que vous pouvez utiliser sur Ethereum pour démontrer que quelque chose est vrai sans révéler de détails inutiles. Par exemple, vous pourriez :
+
+- Prouver que vous avez plus de 18 ans sans partager votre date de naissance complète
+- Prouver la propriété d'un NFT ou d'un jeton sans révéler l'intégralité de votre portefeuille
+- Prouver votre éligibilité à une adhésion, une récompense ou un vote sans exposer d'autres données personnelles
+
+La plupart de ces outils reposent sur des techniques cryptographiques telles que les preuves à divulgation nulle de connaissance, mais le défi consiste à les rendre suffisamment efficaces pour fonctionner sur des appareils de tous les jours, portables sur n'importe quelle plateforme et sécurisés.
+
+Certains projets explorant la confidentialité pour la preuve incluent [Client Side Proving](https://pse.dev/projects/client-side-proving) (systèmes de preuve ZK), [TLSNotary](https://tlsnotary.org/), (preuves d'authenticité pour toutes les données sur le web), [Mopro](https://pse.dev/projects/mopro) (preuve côté client mobile), [Private Proof Delegation](https://pse.dev/projects/private-proof-delegation) (cadres de délégation qui évitent les hypothèses de confiance), et [Noir](https://noir-lang.org/) (langage pour le calcul privé et vérifiable).
+
+## Glossaire de la confidentialité {#privacy-glossary}
+
+**Anonyme** : Interagir en supprimant définitivement tous les identifiants de vos données, ce qui rend impossible de remonter à un individu
+
+**Chiffrement** : Un processus qui brouille les données de sorte que seule une personne disposant de la bonne clé puisse les lire
+
+**[Chiffrement entièrement homomorphe](https://pse.dev/blog/zero-to-start-applied-fully-homomorphic-encryption-fhe-part-1) (FHE)** : Un moyen d'effectuer des calculs directement sur des données chiffrées, sans jamais les déchiffrer
+
+**[Obfuscation indiscernable](https://pse.dev/projects/machina-io) (iO)** : Techniques de confidentialité qui rendent les programmes ou les données inintelligibles tout en restant utilisables
+
+**[Calcul multipartite](https://pse.dev/blog/secure-multi-party-computation) (MPC)** : Méthodes qui permettent à plusieurs parties de calculer un résultat ensemble sans exposer leurs entrées privées
+
+**Cryptographie programmable** : Cryptographie flexible, régie par des règles, qui peut être personnalisée dans un logiciel pour contrôler comment et quand les données sont partagées, vérifiées ou révélées
+
+**Pseudonyme** : Utiliser des codes ou des numéros uniques (comme une adresse Ethereum) à la place d'identifiants personnels
+
+**Divulgation sélective** : La capacité de ne partager que ce qui est nécessaire (par exemple, prouver que vous possédez un NFT sans révéler l'historique complet de votre portefeuille)
+
+**Non-liabilité** : S'assurer que des actions distinctes sur la blockchain ne peuvent pas être rattachées à la même adresse
+
+**Vérifiabilité** : S'assurer que d'autres peuvent confirmer qu'une affirmation est vraie, comme la validation d'une transaction ou d'une preuve sur Ethereum
+
+**Délégation vérifiable** : Assigner une tâche — comme la génération d'une preuve — à une autre partie (par exemple, un portefeuille mobile utilisant un serveur pour une cryptographie lourde) tout en pouvant vérifier qu'elle a été effectuée correctement
+
+**[Preuves à divulgation nulle de connaissance](/zero-knowledge-proofs/#why-zero-knowledge-proofs-are-important) (ZKP)** : Protocoles cryptographiques qui permettent à quelqu'un de prouver qu'une information est vraie sans révéler les données sous-jacentes
+
+**Rollup ZK** : Un système de scalabilité qui regroupe les transactions hors chaîne et soumet une preuve de validité en chaîne — non privé par défaut, mais qui permet des systèmes de confidentialité efficaces (comme les pools protégés) en réduisant les coûts
+
+## Ressources {#resources}
+
+- [Privacy Stewards of Ethereum](https://pse.dev/) (PSE), un laboratoire de recherche et développement de la Fondation Ethereum axé sur la confidentialité de l'écosystème
+- [Web3PrivacyNow](https://web3privacy.info/), un réseau de personnes, de projets et d'organisations alignées qui protègent et font progresser les droits de l'homme en ligne
+- [WalletBeat](https://beta.walletbeat.eth.limo/wallet/summary/), un site de notation de portefeuilles Ethereum visant à fournir une liste complète des portefeuilles, de leurs fonctionnalités, de leurs pratiques et de leur prise en charge de certaines normes.
+- [Zk-kit](https://zkkit.pse.dev/) : Un ensemble de bibliothèques (algorithmes, fonctions utilitaires et structures de données) qui peuvent être réutilisées dans différents projets et protocoles à divulgation nulle de connaissance.
+- [Applications de confidentialité](/apps/categories/privacy/) - Découvrez une liste d'applications de confidentialité sélectionnées qui fonctionnent sur Ethereum.
diff --git a/public/content/translations/fr/real-world-assets/index.md b/public/content/translations/fr/real-world-assets/index.md
new file mode 100644
index 00000000000..6c00b674852
--- /dev/null
+++ b/public/content/translations/fr/real-world-assets/index.md
@@ -0,0 +1,93 @@
+---
+title: "Actifs du monde réel (RWA)"
+metaTitle: "Que sont les RWA ? | Avantages et utilisation des actifs du monde réel"
+description: "Un aperçu des actifs du monde réel sur Ethereum"
+lang: fr
+template: use-cases
+emoji: ":house_buildings:"
+image: /images/man-and-dog-playing.png
+alt: Un homme et un chien en train de jouer.
+sidebarDepth: 2
+summaryPoint1: "Une méthode permettant de convertir des actifs de valeur en jetons numériques."
+summaryPoint2: "Vous pouvez désormais posséder des fractions d’objets ou d’actifs réels, sans avoir à acheter une propriété ou un bien dans son intégralité."
+summaryPoint3: "Relie la finance traditionnelle à l’écosystème blockchain."
+---
+
+Les actifs du monde réel (RWA) sont des jetons représentant des formes de richesse existantes, telles que l’immobilier, l’or, les actions, l’art, les machines ou les objets de collection. Passer en jeton ces objets revient à les traduire en forme numérique, ce qui permet de les diviser entre plusieurs propriétaires et facilite leur échange.
+
+## Que sont les RWA ? {#what-are-rwas}
+
+Certains RWA sont tangibles — des objets que vous pouvez voir et toucher, comme des lingots d’or ou des immeubles commerciaux. D’autres sont intangibles, comme la dette publique, la propriété intellectuelle ou les actions d’une entreprise.
+
+Une fois en jeton, ces actifs sont transformés en unités de valeur. L’or en jeton est un bon exemple de la manière dont cela fonctionne. L’entreprise [Paxos](https://www.paxos.com/) convertit des barres d’or de 400 onces en 400 jetons sur la blockchain Ethereum, chacun étant adossé à une once d’or. Les détenteurs de jetons peuvent échanger leurs jetons contre de l’or à tout moment. C’est également le cas pour les jetons achetés auprès d’une autre entreprise de RWA, [Tether Gold](https://gold.tether.to/).
+
+Chaque jeton peut être divisé en fractions encore plus petites. Les jetons Tether Gold, par exemple, peuvent être divisés en parts aussi petites que 0,000001.
+
+Les jetons RWA n’ont pas de valeur intrinsèque. Ils reflètent plutôt la valeur de l’objet qu’ils représentent, et la valeur du token évolue donc en fonction de celle de l’objet.
+
+## Quels sont les avantages des RWA? {#rwas-benefits}
+
+<CardGrid className="grid grid-cols-[repeat(auto-fill,_minmax(min(100%,_280px),_1fr))] gap-8">
+  <Card title="Propriété fractionnée" emoji=":house_buildings:" description="Les RWA démocratisent l'investissement. Si vous ne pouvez pas investir dans certains types d'actifs faute de moyens, vous pouvez désormais le faire en tant que propriétaire partiel."/>
+  <Card title="Diversification des investissements" emoji="🛒" description="Vous pouvez investir dans plusieurs types d'actifs, ce qui vous permet de diversifier votre portefeuille sans dépenser des fortunes." />
+  <Card title="Opportunités mondiales" emoji="🌏" description="Les RWA suppriment les barrières géographiques à l'investissement. Vous pouvez acheter des jetons pour des actifs situés partout dans le monde." />
+  <Card title="Rendre les actifs liquides" emoji="🖼️" description="De nombreux actifs sont illiquides. Ils ont de la valeur, mais ce n'est pas comme avoir des liquidités à dépenser. En tokenisant un actif, les propriétaires peuvent en transformer tout ou partie en valeur utilisable."/>
+  <Card title="Marché mondial" emoji="💰" description="Les propriétaires cherchant à capitaliser sur leurs actifs peuvent atteindre un plus grand nombre d'investisseurs, et pas seulement ceux qui ont les moyens d'acheter des terrains, des actions, des œuvres d'art ou des instruments financiers traditionnels." />
+  <Card title="Se passer des intermédiaires" emoji="👩‍💻" description="Les jetons fonctionnent sur des contrats intelligents, ce qui signifie qu'ils peuvent être échangés directement entre personnes, sans intermédiaires ni frais associés." />
+</CardGrid>
+
+## Comment fonctionnent les RWA ? {#how-rwas-work}
+
+Voyons quelques exemples issus de l’écosystème RWA : l’immobilier, les produits financiers traditionnels et l’art.
+
+### Investir dans l’immobilier {#investing-in-real-estate}
+
+Disons que vous souhaitez investir dans l’immobilier, mais que l’achat d’un bien entier est hors de portée. À la place, vous pourriez acheter des RWA via un projet tel que [RealT](https://realt.co/). Ses tokens représentent des parts dans une société à responsabilité limitée (LLC) créée pour détenir l’acte de propriété d’un bien immobilier. Les détenteurs de jetons reçoivent des revenus locatifs sous forme de stablecoins, proportionnellement à la fraction qu’ils détiennent ; RealT indique avoir déjà reversé 15 millions de dollars américains de revenus locatifs nets à ses investisseurs.
+
+Un autre projet similaire, [LABS Group](https://x.com/labsgroupio), permet aux particuliers d’investir dans de l’immobilier sous forme de jeton avec des montants aussi petits que 100 dollars américains.
+
+### Investir dans des produits financiers {#investing-in-financial-products}
+
+Plusieurs projets font le lien entre la finance traditionnelle et la finance décentralisée (DeFi) en amenant des titres, des actions, des obligations et d’autres instruments financiers sur la blockchain.
+
+Par exemple, l’entreprise [Securitize](https://securitize.io/), basée sur Ethereum, est spécialisée dans la création de produits financiers traditionnels sous forme de jetons. En 2024, elle s’est associée à BlackRock pour lancer un fonds RWA. BlackRock affirme prévoir de transformer en jetons à terme 10 000 milliards de dollars américains de ses actifs ; son PDG, Larry Fink, a qualifié les jetons de « prochaine génération des marchés ».
+
+### Investir dans l’art de prestige {#investing-in-fine-art}
+
+Il existe plusieurs mécanismes différents pour investir dans l’art de prestige. [Masterworks](https://www.masterworks.com/) achète des œuvres d’art, les transforme en titres financiers, puis vend des parts sous forme de jetons. Elle prévoit de revendre ensuite l’œuvre d’art et de distribuer les bénéfices aux détenteurs de jetons.
+
+Les détenteurs de jetons ne contrôlent ni le stockage ni la vente future de l'œuvre d'art. En revanche, ils décident de la durée pendant laquelle ils conservent leurs jetons, dont la valeur évolue en fonction de celle de l’œuvre.
+
+Pendant ce temps, le registre d’art numérique basé sur la blockchain [Artory](https://www.artory.com/) vérifie l’authenticité des œuvres et enregistre les historiques de propriété.
+
+### Investir dans les objets de collection {#investing-in-collectibles}
+
+Jusqu’à présent, la plupart de ces exemples montrent comment la transformation d’actifs en jetons permet une propriété partielle de différents types de richesse. Un autre avantage de la conversion en jetons est qu’elle permet l’échange d’objets de valeur, comme des objets de collection, sur le marché mondial.
+
+Un exemple de ce principe est [Courtyard](https://courtyard.io/), qui transforme des cartes à collectionner – comme des cartes de baseball, de football ou des cartes Pokémon – en jetons. Les propriétaires envoient leurs cartes dans un centre de stockage sécurisé aux États-Unis. Les cartes sont converties en jetons numériques et ajoutées aux portefeuilles des propriétaires pour être échangées sur la place de marché de Courtyard. Courtyard n’accepte que les cartes gradées : cela signifie qu’un tiers a certifié l’authenticité de la carte et lui a attribué une note en fonction de son état, qu’il soit détérioré ou impeccable.
+
+Courtyard propose également un type de système de redevances. Chaque fois qu’une carte est vendue, la personne qui l’a transformée en jeton reçoit un pour cent des revenus. Seuls les créateurs initiaux des cartes sont récompensés de cette manière. À tout moment, un propriétaire peut échanger ses cartes numériques contre les cartes physiques, peu importe où il se trouve dans le monde.
+
+## Quelles sont les limites des RWA ? {#rwas-limitations}
+
+L’un des défis des RWA, à ce stade précoce, consiste à garantir le lien entre les objets réels et leurs représentations numériques.
+
+Un bon signe est lorsque les projets RWA fournissent aux investisseurs une preuve de réserve – la garantie qu’ils sont bien les propriétaires légaux des objets physiques qui soutiennent les jetons numériques. Pensez à Paxos, Tether Gold ou Courtyard, mentionnés précédemment : tous conservent leurs actifs dans un lieu sécurisé et offrent aux propriétaires la possibilité d’échanger un jeton contre son équivalent physique à tout moment.
+
+Une autre limite concerne la reconnaissance de la propriété des jetons par les systèmes juridiques à travers le monde. Autrement dit, les contrats intelligents peuvent-ils être appliqués devant un tribunal, ou le détenteur d’un jeton RWA peut-il faire valoir la propriété de l’objet réel ?
+
+Parmi les pionniers dans la mise en place de cadres juridiques reconnaissant spécifiquement la mise en jetons figurent Singapour, les Émirats arabes unis, Hong Kong et la Suisse, qui a introduit en 2021 une législation surnommée la « Loi Blockchain » pour encadrer des technologies telles que la mise en jetons. L’Union européenne a entamé le processus de régulation des RWA, tandis qu’aux États-Unis, la Securities and Exchange Commission devrait publier des consignes sur les RWA sous peu.
+
+## En apprendre plus {#learn-more}
+
+Plongez dans les [contrats intelligents](/smart-contracts/) ou découvrez une autre catégorie de jetons, les [jetons non fongibles (NFT)](/nft/).
+
+## En savoir plus {#further-reading}
+
+- [Qu’est-ce que la mise en jetons d’actifs ?](https://www.britannica.com/money/real-world-asset-tokenization) sur Britannica
+- [Comment la mise en jetons transforme la finance et l’investissement mondiaux](https://www.weforum.org/stories/2024/12/tokenization-blockchain-assets-finance/) sur le Forum Économique Mondial
+- [Ce que les investisseurs crypto doivent savoir sur la mise en jetons des actifs du monde réel](https://www.forbes.com/sites/irinaheaver/2024/03/14/what-crypto-investors-need-to-know-about-tokenizing-real-world-assets/) sur Forbes
+- [Comment les contrats intelligents fonctionnent avec la blockchain](https://www.britannica.com/money/how-smart-contracts-work) sur Britannica
+- [Comment les actifs du monde réel sous forme de jetons transforment la DeFi](https://medium.com/coinmonks/how-tokenized-real-world-assets-are-transforming-defi-4e040f28732a) sur Medium
+- [Qu’est-ce qu’un RWA dans la crypto ? Son rôle dans la blockchain expliqué](https://www.bitdegree.org/crypto/tutorials/what-is-rwa-in-crypto) sur BitDegree
+- [Principaux jetons d’actifs du monde réel (RWA) aujourd’hui par capitalisation boursière](https://www.forbes.com/digital-assets/categories/real-world-assets-rwa/) sur Forbes
diff --git a/public/content/translations/fr/refi/index.md b/public/content/translations/fr/refi/index.md
index 5ecaf0ec258..1f28adf6661 100644
--- a/public/content/translations/fr/refi/index.md
+++ b/public/content/translations/fr/refi/index.md
@@ -1,5 +1,5 @@
 ---
-title: Finance Régénérative (ReFi)
+title: "Finance Régénérative (ReFi)"
 description: Une vue d'ensemble de la ReFi et de ses cas d'utilisation actuels.
 lang: fr
 template: use-cases
@@ -7,14 +7,14 @@ emoji: ":recycle:"
 sidebarDepth: 2
 image: /images/future_transparent.png
 alt: ""
-summaryPoint1: Un système économique alternatif fondé sur des principes de régénération
-summaryPoint2: Une tentative d'utilisation d'Ethereum pour résoudre les crises de coordination au niveau mondial, telles que le changement climatique
-summaryPoint3: Un outil permettant une augmentation drastique des bénéfices écologiques tels que les crédits de carbone vérifiés
+summaryPoint1: "Un système économique alternatif fondé sur des principes de régénération"
+summaryPoint2: "Une tentative d'utilisation d'Ethereum pour résoudre les crises de coordination au niveau mondial, telles que le changement climatique"
+summaryPoint3: "Un outil permettant une augmentation drastique des bénéfices écologiques tels que les crédits de carbone vérifiés"
 ---
 
 ## Qu'est-ce que la ReFi ? {#what-is-refi}
 
-**La finance régénérative (ReFi)** est un ensemble d'outils et d'idées construits sur les [blockchains](/glossary/#blockchain), qui visent à créer des économies régénératives, plutôt qu'extractives ou exploitantes. Les systèmes extractifs finissent par épuiser les ressources disponibles et s'effondrent ; en l'absence de mécanismes de régénération, ils manquent de résilience. La ReFi part du principe que la création de valeur monétaire doit être dissociée de l'extraction non durable des ressources de notre planète et de nos communautés.
+**La finance régénérative (ReFi)** est un ensemble d'outils et d'idées construits sur des [blockchains](/glossary/#blockchain), qui visent à créer des économies régénératives, plutôt qu'extractives ou exploitatrices. Les systèmes extractifs finissent par épuiser les ressources disponibles et s'effondrent ; en l'absence de mécanismes de régénération, ils manquent de résilience. La ReFi part du principe que la création de valeur monétaire doit être dissociée de l'extraction non durable des ressources de notre planète et de nos communautés.
 
 La ReFi vise plutôt à résoudre des problèmes environnementaux, communautaires ou sociaux en créant des cycles de régénération. Ces systèmes créent de la valeur pour les participants tout en bénéficiant aux écosystèmes et aux communautés.
 
@@ -22,9 +22,9 @@ L'un des fondements de la ReFi est le concept d'économie régénératrice dont
 
 ![Huit principes interconnectés](refi-regenerative-economy-diagram.png)
 
-Les projets ReFi concrétisent ces principes en utilisant des [contrats intelligents](/glossary/#smart-contract) et des [applications de finance décentralisée (DeFi)](/glossary/#defi) pour encourager les comportements régénérateurs, par exemple la restauration des écosystèmes dégradés, et faciliter la collaboration à grande échelle sur des questions mondiales telles que le changement climatique et la perte de biodiversité.
+Les projets ReFi concrétisent ces principes en utilisant des [contrats intelligents](/glossary/#smart-contract) et des applications de [finance décentralisée (DeFi)](/glossary/#defi) pour encourager les comportements régénératifs, par exemple, la restauration des écosystèmes dégradés, et faciliter la collaboration à grande échelle sur des questions mondiales telles que le changement climatique et la perte de biodiversité.
 
-La ReFi rejoint également le mouvement [science décentralisée (DeSci)](/desci/), qui utilise Ethereum comme plateforme pour financer, créer, réviser, créditer, stocker et diffuser des connaissances scientifiques. Les outils DeSci pourraient être utiles pour élaborer des normes et des pratiques vérifiables pour la mise en œuvre et le suivi d'activités régénératrices telles que la plantation d'arbres, l'élimination du plastique dans les océans ou la restauration d'un écosystème dégradé.
+La ReFi rejoint également le mouvement de la [science décentralisée (DeSci)](/desci/), qui utilise Ethereum comme plateforme pour financer, créer, réviser, créditer, stocker et diffuser les connaissances scientifiques. Les outils DeSci pourraient être utiles pour élaborer des normes et des pratiques vérifiables pour la mise en œuvre et le suivi d'activités régénératrices telles que la plantation d'arbres, l'élimination du plastique dans les océans ou la restauration d'un écosystème dégradé.
 
 <YouTube id="La52dDzBt2k" />
 
@@ -42,40 +42,40 @@ Malgré son développement au cours des dernières décennies, le VCM continue d
 4. Vitesse de trading très lente
 5. Manque de passage à l'échelle
 
-La transition du VCM vers le nouveau **marché numérique du carbone (DCM)** basé sur la blockchain pourrait être l'occasion de mettre à niveau la technologie existante pour la validation, la vente et la consommation des crédits carbone. Les blockchains permettent d'obtenir des données publiquement vérifiables, un accès pour un large éventail d'utilisateurs et une plus grande liquidité.
+La transition du VCM vers le nouveau **marché numérique du carbone (DCM)** basé sur la blockchain pourrait être une occasion de mettre à niveau la technologie existante pour valider, échanger et consommer des crédits carbone. Les blockchains permettent d'obtenir des données publiquement vérifiables, un accès pour un large éventail d'utilisateurs et une plus grande liquidité.
 
 Les projets ReFi utilisent la technologie de la blockchain pour atténuer de nombreux problèmes du marché traditionnel :
 
-- **La liquidité est concentrée sur un petit nombre de pools** où chacun peut commercer. Les grandes organisations comme les individus peuvent utiliser ces pools sans devoir rechercher manuellement des acheteurs/vendeurs, sans frais de participation ou sans enregistrement préalable.
+- **La liquidité est concentrée dans un petit nombre de pools de liquidité** où tout le monde peut échanger librement. Les grandes organisations comme les individus peuvent utiliser ces pools sans devoir rechercher manuellement des acheteurs/vendeurs, sans frais de participation ou sans enregistrement préalable.
 - **Toutes les transactions sont enregistrées sur des blockchains publiques**. Le chemin que chaque crédit carbone prend en raison de l'activité de trading est retraçable à jamais dès qu'il est rendu disponible dans le DCM.
 - **La rapidité des transactions est quasiment instantanée**. Sécuriser de vastes quantités de crédits carbone via les marchés traditionnels peut prendre des jours ou des semaines, alors que ceci peut être réalisé en quelques secondes dans le DCM.
-- **Les activités de trading ont lieu sans intermédiaires**, qui facturent des fortes commissions. Les crédits carbones numériques représentent une réduction de coût conséquente comparé aux crédits traditionnels.
-- **Le DCM peut passer à l'échelle** et répondre aussi bien aux attentes des individus que des entreprises multinationales.
+- **L'activité d'échange se déroule sans intermédiaires**, qui facturent des frais élevés. Les crédits carbones numériques représentent une réduction de coût conséquente comparé aux crédits traditionnels.
+- **Le DCM est évolutif** et peut répondre aux demandes des particuliers comme des sociétés multinationales.
 
 ### Composants clés du DCM {#key-components-dcm}
 
 Quatre éléments majeurs composent le paysage actuel du DCM :
 
-1. Des registres tels que [Verra](https://verra.org/project/vcs-program/registry-system/) et [Gold Standard](https://www.goldstandard.org/) veillent à ce que les projets créant des crédits carbone soient fiables. Ils gèrent également les bases de données dans lesquelles les crédits carbone numériques sont créés, transférés ou utilisés.
+1. Des registres tels que [Verra](https://verra.org/project/vcs-program/registry-system/) et [Gold Standard](https://www.goldstandard.org/) s'assurent que les projets créant des crédits carbone sont fiables. Ils gèrent également les bases de données dans lesquelles les crédits carbone numériques sont créés, transférés ou utilisés.
 
 Une nouvelle vague de projets innovants est en train d'être développée sur des blockchains dans le but de bouleverser les acteurs établis de ce secteur.
 
-2. Ponts carbone, aussi appelés tokeniseurs, fournissent la technologie pour représenter ou transférer les crédits carbones depuis les registres traditionnels vers les DCM. [Toucan Protocol](https://toucan.earth/), [C3](https://c3.app/), and [Moss.Earth](https://moss.earth/) font partie des exemples remarquables.
+2. Ponts carbone, aussi appelés tokeniseurs, fournissent la technologie pour représenter ou transférer les crédits carbones depuis les registres traditionnels vers les DCM. Les exemples notables incluent [Toucan Protocol](https://toucan.earth/), [C3](https://c3.app/) et [Moss.Earth](https://moss.earth/).
 3. Les services intégrés offrent des crédits d'évitement ou de suppression de carbone aux utilisateurs finaux afin qu'ils obtiennent le bénéfice environnemental de leur crédit et partagent leur soutien à l'action climatique avec le monde.
 
-Certains, comme [Klima Infinity](https://www.klimadao.finance/infinity) et [Senken](https://senken.io/), proposent une grande variété de projets développés par des tiers et émis conformément à des normes établies telles que Verra ; d'autres, comme [Nori](https://nori.com/), ne proposent que des projets spécifiques développés selon leur propre norme de crédit carbone, qu'ils émettent et pour laquelle ils ont leur propre marché dédié.
+Certains, comme [Klima Infinity](https://www.klimadao.finance/infinity) et [Senken](https://senken.io/), proposent une grande variété de projets développés par des tiers et émis conformément à des normes établies comme Verra ; d'autres, comme [Nori](https://nori.com/), ne proposent que des projets spécifiques développés selon leur propre norme de crédit carbone, qu'ils émettent et pour lesquels ils ont leur propre place de marché dédiée.
 
-4. Les rails et l'infrastructure sous-jacente qui facilitent la montée en charge de l'impact et de l'efficacité de l'ensemble de la chaîne d'approvisionnement du marché du carbone. [KlimaDAO](http://klimadao.finance/) fournit de la liquidité comme un bien public (permettant à quiconque d'acheter ou de vendre des crédits carbone à un prix transparent), stimule les flux sur les marchés carbone et les retraits via des récompenses, et fournit un outillage interopérable et convivial pour accéder aux données, acquérir et retirer, une grande variété de crédits carbone tokenisés.
+4. Les rails et l'infrastructure sous-jacente qui facilitent la montée en charge de l'impact et de l'efficacité de l'ensemble de la chaîne d'approvisionnement du marché du carbone. [KlimaDAO](http://klimadao.finance/) fournit de la liquidité en tant que bien public (permettant à quiconque d'acheter ou de vendre des crédits carbone à un prix transparent), incite à augmenter le débit des marchés du carbone et des retraits avec des récompenses, et fournit des outils conviviaux et interopérables pour accéder aux données relatives à une grande variété de crédits carbone tokenisés, mais aussi pour en acquérir et en retirer.
 
 ## La ReFi au-delà des marchés du carbone {#refi-beyond}
 
-Bien qu'il y ait actuellement une grande attention portée aux marchés du carbone en général et à la transition du VCM au DCM en particulier, le terme « ReFi » n'est pas strictement limité au carbone. D'autres actifs environnementaux en dehors des crédits carbone peuvent être développés et tokenisés, ce qui signifiera que d'autres externalités négatives pourront également être valorisées au sein des couches de base des futurs systèmes économiques. De plus, l'aspect régénératif de ce modèle économique peut être appliqué à d'autres domaines, tels que le financement des biens publics via des plateformes de financement quadratique comme [Gitcoin](https://gitcoin.co/). Les organisations qui reposent sur l'idée de participation ouverte et de distribution équitable des ressources permettent à chacun de contribuer financièrement aux projets de logiciels open-source, ainsi qu'aux projets éducatifs, environnementaux et communautaires.
+Bien qu'il y ait actuellement une grande attention portée aux marchés du carbone en général et à la transition du VCM au DCM en particulier, le terme « ReFi » n'est pas strictement limité au carbone. D'autres actifs environnementaux en dehors des crédits carbone peuvent être développés et tokenisés, ce qui signifiera que d'autres externalités négatives pourront également être valorisées au sein des couches de base des futurs systèmes économiques. De plus, l'aspect régénératif de ce modèle économique peut être appliqué à d'autres domaines, tels que le financement de biens publics via des plateformes de financement quadratique comme [Gitcoin](https://gitcoin.co/). Les organisations qui reposent sur l'idée de participation ouverte et de distribution équitable des ressources permettent à chacun de contribuer financièrement aux projets de logiciels open-source, ainsi qu'aux projets éducatifs, environnementaux et communautaires.
 
 En orientant le capital loin des pratiques extractives et vers un flux régénératif, les projets et les entreprises qui fournissent des avantages sociaux, environnementaux ou communautaires - et qui pourraient échouer à obtenir un financement dans la finance traditionnelle - peuvent démarrer et générer des externalités positives pour la société beaucoup plus rapidement et facilement. La transition vers ce modèle de financement ouvre également la voie à des systèmes économiques beaucoup plus inclusifs, où les personnes de toutes les catégories démographiques peuvent devenir des participants actifs plutôt que de simples observateurs passifs. ReFi propose une vision d'Ethereum en tant que mécanisme de coordination de l'action face aux défis existentiels auxquels notre espèce et toute vie sur notre planète sont confrontées - en tant que couche de base d'un nouveau paradigme économique, permettant un avenir plus inclusif et durable pour les siècles à venir.
 
 ## Lectures complémentaires sur la ReFi
 
-- [Une vue d'ensemble des monnaies carbone et de leur place dans l'économie](https://www.klimadao.finance/blog/the-vision-of-a-carbon-currency)
+- [Une vue d'ensemble des monnaies carbone et de leur place dans l'économie](https://www.klimadao.finance/resources/the-vision-of-a-carbon-currency)
 - [The Ministry for the Future, un roman décrivant le rôle d'une monnaie adossée au carbone dans la lutte contre le changement climatique](https://en.wikipedia.org/wiki/The_Ministry_for_the_Future)
-- [Un rapport détaillé du Groupe de travail pour l'expansion des marchés volontaires du carbone](https://www.iif.com/Portals/1/Files/TSVCM_Report.pdf)
-- [La ReFi sur le glossaire CoinMarketCap par Kevin Owocki et Evan Miyazono](https://coinmarketcap.com/alexandria/glossary/regenerative-finance-refi)
+- [Un rapport détaillé de la Taskforce for Scaling Voluntary Carbon Markets](https://www.iif.com/Portals/1/Files/TSVCM_Report.pdf)
+- [L'entrée du glossaire de CoinMarketCap sur la ReFi par Kevin Owocki et Evan Miyazono](https://coinmarketcap.com/academy/glossary/regenerative-finance-refi)
diff --git a/public/content/translations/fr/restaking/index.md b/public/content/translations/fr/restaking/index.md
new file mode 100644
index 00000000000..a81fd77a51c
--- /dev/null
+++ b/public/content/translations/fr/restaking/index.md
@@ -0,0 +1,188 @@
+---
+title: Re-mise en jeu
+metaTitle: Qu'est-ce que la re-mise en jeu ? | Avantages et utilisation de la re-mise en jeu
+description: "Utilisez l'ETH mis en jeu pour sécuriser d'autres services décentralisés et gagner des récompenses supplémentaires."
+lang: fr
+template: use-cases
+emoji: ":recycle:"
+image: /images/use-cases/restaking.png
+alt: "Une représentation visuelle de la re-mise en jeu sur Ethereum."
+sidebarDepth: 2
+summaryPoint1: "Utilisez l'ETH mis en jeu pour sécuriser d'autres services décentralisés et gagner des récompenses supplémentaires."
+buttons:
+  - content: Qu'est-ce que la re-mise en jeu ?
+    toId: what-is-restaking
+  - content: Comment ça marche ?
+    toId: how-does-restaking-work
+    isSecondary: false
+---
+
+Le réseau Ethereum sécurise des milliards de dollars 24h/24, 7j/7 et 365 jours par an. Comment ?
+
+Partout dans le monde, des gens bloquent (ou « mettent en jeu ») de l'[ether (ETH)](/eth/) dans des contrats intelligents pour exécuter le logiciel qui traite les transactions Ethereum et sécurise le réseau Ethereum. En retour, ils sont récompensés par davantage d'ETH.
+
+La re-mise en jeu est une technologie conçue pour les [validateurs](/staking/) afin d'étendre cette sécurité à d'autres services, applications ou réseaux. En retour, ils gagnent des récompenses de re-mise en jeu supplémentaires. Cependant, ils exposent également leur ETH mis en jeu à plus de risques.
+
+**La re-mise en jeu expliquée en 18 minutes**
+
+<YouTube id="rOJo7VwPh7I" />
+
+## Qu'est-ce que la re-mise en jeu ? {#what-is-restaking}
+
+La re-mise en jeu consiste à ce que les validateurs utilisent leurs ETH déjà mis en jeu pour sécuriser d'autres services décentralisés. En retour, les participants à la re-mise en jeu peuvent obtenir des récompenses supplémentaires de ces autres services, en plus de leurs récompenses de mise en jeu d'ETH habituelles.
+
+Les services décentralisés sécurisés par la re-mise en jeu sont connus sous le nom de « Services validés activement » (AVS).
+De la même manière que de nombreux validateurs d'ETH exécutent un logiciel de validation Ethereum, de nombreux participants à la re-mise en jeu exécutent un logiciel AVS spécialisé.
+
+<br/>
+<Alert className="justify-between">
+<AlertEmoji text=":bulb:"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Bon à savoir</strong></p>
+  <p className="mt-2">Bien que « Services validés activement » (AVS) soit le terme le plus courant, différentes plateformes de re-mise en jeu peuvent utiliser d'autres noms pour les services décentralisés qu'elles aident à sécuriser, comme « Services validés de manière autonome », « Services sécurisés distribués » ou « Réseaux ».</p>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Mise en jeu contre re-mise en jeu {#staking-vs-restaking}
+
+| Mise en jeu                                     | Re-mise en jeu                                                            |
+| ----------------------------------------------- | ------------------------------------------------------------------------- |
+| Gagnez des récompenses en ETH                   | Gagnez des récompenses en ETH + des récompenses AVS                       |
+| Sécurise le réseau Ethereum                     | Sécurise le réseau Ethereum + les AVS                                     |
+| Pas de minimum d'ETH                            | Pas de minimum d'ETH                                                      |
+| Faible niveau de risque                         | Niveau de risque de faible à élevé                                        |
+| Le délai de retrait dépend de la file d'attente | Le délai de retrait dépend de la file d'attente + la période de déblocage |
+
+## Pourquoi avons-nous besoin de la re-mise en jeu ? {#why-do-we-need-restaking}
+
+Imaginez deux mondes : l'un avec la re-mise en jeu et l'autre sans.
+
+ <TabbedSection />
+
+Dans ce monde avec la re-mise en jeu, l'AVS et le validateur bénéficient tous deux de la possibilité de se trouver et d'échanger de la sécurité contre des récompenses supplémentaires.
+
+<br/>
+
+<Alert className="justify-between">
+<AlertEmoji text=":bulb:"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Avantage supplémentaire de la re-mise en jeu</strong></p>
+  <p className="mt-2">Les AVS peuvent consacrer toutes leurs ressources à la création et à la commercialisation de leurs services, au lieu de se laisser distraire par la décentralisation et la sécurité.</p>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Comment fonctionne la re-mise en jeu ? {#how-does-restaking-work}
+
+Plusieurs entités sont impliquées dans la re-mise en jeu — chacune d'entre elles joue un rôle important.
+
+| **Terme**                                    | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Plateformes de re-mise en jeu**            | Une plateforme de re-mise en jeu est un service qui met en relation les AVS, les validateurs d'ETH et les opérateurs. Elles créent des applications décentralisées pour que les validateurs puissent remettre en jeu leur ETH et des places de marché où les validateurs, les AVS et les opérateurs peuvent se trouver.                                                                                                                                                                                                                 |
+| **Participants natifs à la re-mise en jeu**  | Les personnes qui mettent en jeu leur ETH en exécutant leurs propres validateurs Ethereum peuvent connecter leur ETH mis en jeu à une plateforme de re-mise en jeu, y compris EigenLayer et d'autres, pour gagner des récompenses de re-mise en jeu en plus des récompenses de validateur ETH.                                                                                                                                                                                                                                                          |
+|                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| **Participants à la re-mise en jeu liquide** | Les personnes qui mettent leur ETH en jeu via un fournisseur tiers de mise en jeu liquide, comme Lido ou Rocket Pool, obtiennent des jetons de mise en jeu liquide (LST) qui représentent leur ETH mis en jeu. Ils peuvent remettre ces LST en jeu pour gagner des récompenses de re-mise en jeu tout en gardant leur ETH d'origine mis en jeu.                                                                                                                                                                      |
+|                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| **Opérateurs**                               | Les opérateurs exécutent le logiciel de re-mise en jeu des AVS, effectuant les tâches de validation requises par chaque AVS. Les opérateurs sont généralement des fournisseurs de services professionnels qui garantissent des éléments tels que la disponibilité et les performances. Comme les participants à la re-mise en jeu non-opérateurs, les opérateurs utilisent l'ETH mis en jeu pour sécuriser les AVS, mais les opérateurs reçoivent également des récompenses supplémentaires en échange de leur travail. |
+|                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| **AVS**                                      | Ce sont les services décentralisés — comme les oracles de prix, les ponts de jetons et les systèmes de données — qui reçoivent la sécurité des participants à la re-mise en jeu et offrent des récompenses en jetons en retour.                                                                                                                                                                                                                                                                                                                         |
+
+<br/>
+
+<Alert className="justify-between">
+<AlertEmoji text=":bulb:"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Bon à savoir</strong></p>
+  <p className="mt-2">Les participants natifs et liquides à la re-mise en jeu délèguent souvent leur ETH mis en jeu à un opérateur, au lieu d'exécuter eux-mêmes le logiciel pour sécuriser les AVS.</p>
+  <p className="mt-2">De cette façon, ils n'ont pas à se soucier des exigences techniques compliquées des AVS, bien qu'ils reçoivent un taux de récompense inférieur à celui des opérateurs.</p>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Quels sont les exemples de re-mise en jeu ? {#what-are-some-examples-of-restaking}
+
+Bien qu'il s'agisse d'une idée nouvelle, quelques projets ont vu le jour pour explorer les possibilités de la re-mise en jeu.
+
+<RestakingList/>
+
+<br/>
+
+<Alert variant="warning" className="justify-between">
+<AlertEmoji text=":bulb:"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Alerte à l'appellation impropre</strong></p>
+  <p className="mt-2">Certaines personnes confondent la « re-mise en jeu » avec le prêt et l'emprunt de LST dans la DeFi. Les deux mettent au travail l'ETH mis en jeu, mais la re-mise en jeu signifie sécuriser des AVS, et non pas seulement gagner un rendement sur les LST.</p>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Combien puis-je gagner avec la re-mise en jeu ? {#how-much-can-i-make-from-restaking}
+
+Alors que les AVS offrent des taux différents, les jetons de re-mise en jeu liquide (LRT) comme eETH vous donnent une idée de combien vous pouvez gagner. De la même manière que vous obtenez des LST comme stETH pour la mise en jeu de votre ETH, vous pouvez obtenir des LRT comme eETH pour la re-mise en jeu de stETH. Ces jetons rapportent des récompenses de mise en jeu d'ETH et de re-mise en jeu.
+
+**Il est important de reconnaître les risques liés à la re-mise en jeu. Les récompenses potentielles peuvent être attrayantes, mais elles ne sont pas sans risque.**
+
+## Quels sont les risques de la re-mise en jeu ? {#what-are-the-risks-of-restaking}
+
+| **Risques**                                         | **Description**                                                                                                                                                                                                                                                       |
+| --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Pénalités (ou « délestage »)** | Comme pour la mise en jeu d'ETH, si les participants à la re-mise en jeu/opérateurs se déconnectent, censurent des messages ou tentent de corrompre le réseau, leur mise peut être délestée (brûlée) partiellement ou entièrement. |
+| **Centralisation**                                  | Si quelques opérateurs dominent la majeure partie de la re-mise en jeu, ils pourraient avoir une grande influence sur les participants à la re-mise en jeu, les AVS et même les plateformes de re-mise en jeu.                                        |
+| **Réactions en chaîne**                             | Si un participant à la re-mise en jeu est délesté tout en sécurisant plusieurs AVS, cela pourrait réduire la sécurité des autres AVS, les rendant vulnérables.                                                                                        |
+| **Accès immédiat aux fonds**                        | Il y a un temps d'attente (ou « période de déblocage ») pour retirer l'ETH remis en jeu, donc vous n'aurez peut-être pas toujours un accès immédiat.                                                                               |
+
+<br/>
+
+<Alert className="justify-between">
+<AlertEmoji text=":bulb:"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Le cofondateur d'Ethereum est en train d'écrire…</strong></p>
+  <p className="mt-2">
+ Vitalik, le cofondateur d'Ethereum, a mis en garde contre les risques potentiels de la re-mise en jeu dans un article de blog de 2021 intitulé <a href="https://vitalik.eth.limo/general/2023/05/21/dont_overload.html">Don't Overload Consensus.</a>
+</p>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Comment démarrer avec la re-mise en jeu ? {#how-to-get-started-with-restaking}
+
+| 🫡 Débutants                                                                                                                        | 🤓 Utilisateurs avancés                                                                                                                     |
+| ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1. Mettez en jeu des ETH sur des plateformes comme Lido ou Rocket Pool pour obtenir des LST. | 1. Mettez votre ETH en jeu en tant que validateur sur Ethereum.                                      |
+| 2. Utilisez ces LST pour commencer la re-mise en jeu sur un service de re-mise en jeu.       | 2. Comparez les services de re-mise en jeu comme EigenLayer, Symbiotic et d'autres.                  |
+|                                                                                                                                     | 3. Suivez les instructions pour connecter votre validateur au contrat intelligent de re-mise en jeu. |
+
+<br/>
+
+<Alert className="justify-between">
+<AlertEmoji text=":eyes:"/>
+<AlertContent>
+<AlertDescription>
+  <p className="mt-0"><strong>Mise en jeu sur Ethereum :</strong> comment ça marche ?</p>
+  <ButtonLink href="/staking/">
+    En savoir plus
+  </ButtonLink>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Avancé {#advanced}
+
+<YouTube id="-V-fG4J1N_M" />
+
+## En savoir plus {#further-reading}
+
+1. [ethereum.org - Guide de la mise en jeu d'ETH](https://ethereum.org/en/staking/)
+2. [Ledger Academy - Qu'est-ce que la re-mise en jeu sur Ethereum ?](https://www.ledger.com/academy/what-is-ethereum-restaking)
+3. [Consensys - EigenLayer : explication du protocole de re-mise en jeu décentralisé d'Ethereum](https://consensys.io/blog/eigenlayer-decentralized-ethereum-restaking-protocol-explained)
+4. [Vitalik Buterin - Ne surchargez pas le consensus d'Ethereum](https://vitalik.eth.limo/general/2023/05/21/dont_overload.html)
+5. [Cointelegraph - Qu'est-ce qu'EigenLayer ? Explication du protocole de re-mise en jeu d'Ethereum](https://cointelegraph.com/explained/what-is-eigenlayer-ethereums-restaking-protocol-explained)
+6. [a16z crypto research - EigenLayer : Ajout de fonctionnalités sans permission à Ethereum avec Sreeram Kannan](https://www.youtube.com/watch?v=-V-fG4J1N_M)
+7. [Junion - Explication d'EigenLayer : qu'est-ce que la re-mise en jeu ?](https://www.youtube.com/watch?v=5r0SooSQFJg)
+8. [The Block - Tableau de bord des données de re-mise en jeu](https://www.theblock.co/data/decentralized-finance/restaking)
diff --git a/public/content/translations/fr/roadmap/account-abstraction/index.md b/public/content/translations/fr/roadmap/account-abstraction/index.md
index 0908b5c7ef0..5deaad597c6 100644
--- a/public/content/translations/fr/roadmap/account-abstraction/index.md
+++ b/public/content/translations/fr/roadmap/account-abstraction/index.md
@@ -1,6 +1,6 @@
 ---
 title: Abstraction de comptes
-description: Un aperçu des plans d'Ethereum pour simplifier et sécuriser les comptes utilisateurs
+description: "Un aperçu des plans d'Ethereum pour simplifier et sécuriser les comptes utilisateurs"
 lang: fr
 summaryPoints:
   - L'abstraction du compte facilite de manière significative la création de portefeuilles de contrats intelligents
@@ -8,11 +8,11 @@ summaryPoints:
   - Les clés perdues ou exposées peuvent être récupérées en faisant plusieurs sauvegardes
 ---
 
-# Abstraction de comptes {#account-abstraction}
+# Abstraction de compte {#account-abstraction}
 
-Les utilisateurs interagissent sur Ethereum en utilisant des **[ comptes détenus en externe (EOA)](/glossary/#eoa)**. C'est la seule façon de démarrer une transaction ou d'exécuter un contrat intelligent. Ce qui restreint la façon dont les utilisateurs peuvent interagir sur Ethereum. Par exemple, il est difficile d'exécuter des lots de transactions si les utilisateurs ne disposent pas d'un solde d'ETH suffisant pour couvrir les frais de gaz.
+La plupart des utilisateurs interagissent avec Ethereum en utilisant des **[comptes externes (EOA)](/glossary/#eoa)**. Cela limite la façon dont les utilisateurs peuvent interagir avec Ethereum. Par exemple, cela rend difficile l’exécution de lots de transactions et oblige les utilisateurs à toujours conserver un solde ETH pour payer les frais de transaction.
 
-L'abstraction de compte est un moyen de résoudre ces problèmes car elle offre aux utilisateurs plus de flexibilité et donc plus de sécurité pour une meilleure expérience avec leur compte. Cela peut se produire en [mettant à niveau les EOA](https://eips.ethereum.org/EIPS/eip-3074) afin qu'ils puissent être contrôlés par des contrats intelligents, ou en [ mettant à niveau les contrats intelligents](https://eips.ethereum.org/EIPS/eip-2938) pour qu'ils puissent initier des transactions. Ces deux options nécessitent des modifications du protocole Ethereum. Il existe également une troisième voie qui consiste à ajouter un [second système de transaction distinct](https://eips.ethereum.org/EIPS/eip-4337) fonctionnant parallèlement au protocole existant. Indépendamment du procédé, le résultat est l'accès à Ethereum via des portefeuilles de contrats intelligents, soit nativement pris en charge par le protocole existant, soit par l'intermédiaire d'un réseau de transactions complémentaires.
+L'abstraction de compte est un moyen de résoudre ces problèmes car elle offre aux utilisateurs plus de flexibilité et donc plus de sécurité pour une meilleure expérience avec leur compte. Cela peut se faire en [mettant à niveau les EOA](https://eips.ethereum.org/EIPS/eip-7702) (EIP-7702) afin qu'ils puissent être contrôlés par des contrats intelligents. Il existe également une autre voie qui consiste à ajouter un [second système de transaction distinct](https://eips.ethereum.org/EIPS/eip-4337) (EIP-4337) fonctionnant parallèlement au protocole existant. Quel que soit le chemin emprunté, le résultat est un accès à Ethereum via des portefeuilles de contrats intelligents, soit pris en charge nativement dans le cadre du protocole existant, soit via un réseau de transactions complémentaire.
 
 Les portefeuilles de contrats intelligents offrent de nombreux avantages à l'utilisateur, notamment :
 
@@ -25,102 +25,47 @@ Les portefeuilles de contrats intelligents offrent de nombreux avantages à l'ut
 
 Ces avantages ne sont pas pris en charge de manière native aujourd'hui, car seuls les comptes externes ([EOA](/glossary/#eoa)) peuvent initier des transactions. Les EOA sont simplement des paires de clés publiques-privées. Ils fonctionnent comme ceci :
 
-- si vous avez la clé privée, vous pouvez faire _tout ce que vous voulez_ dans le respect des règles de la Machine virtuelle Ethereum (EVM)
+- si vous avez la clé privée, vous pouvez faire _n'importe quoi_ dans le respect des règles de la machine virtulle Ethereum (EVM)
 - si vous n'avez pas la clé privée, vous ne pouvez _rien_ faire.
 
 Si vous perdez vos clés, il sera impossible de les récupérer. Par ailleurs, les clés volées permettent aux voleurs d'accéder instantanément à tous les fonds disponibles sur un compte.
 
-Les portefeuilles de contrats intelligents sont la solution à ces problèmes, mais ils sont aujourd'hui difficiles à programmer car, en fin de compte, toute logique qu'ils implémentent doit être traduite en un ensemble de transactions EOA avant de pouvoir être traitée par Ethereum. L'abstraction de compte permet aux contrats intelligents d'initier eux-mêmes des transactions, de sorte que toute logique que l'utilisateur souhaite mettre en œuvre peut être codée dans le portefeuille du contrat intelligent lui-même et exécutée sur Ethereum.
+Les portefeuilles de contrats intelligents sont la solution à ces problèmes, mais aujourd'hui, ils sont difficiles à programmer car, en fin de compte, toute logique qu'ils implémentent doit être traduite en un ensemble de transactions EOA avant de pouvoir être traitée par Ethereum. L'abstraction de compte permet aux contrats intelligents d'initier eux-mêmes des transactions, de sorte que toute logique que l'utilisateur souhaite mettre en œuvre peut être codée dans le portefeuille du contrat intelligent lui-même et exécutée sur Ethereum.
 
-Finalement, l'abstraction de compte améliore le support des portefeuilles de contrats intelligents, les rendant plus faciles à développer et plus sûrs à utiliser. En fin de compte, avec l'abstraction de compte, les utilisateurs peuvent profiter de tous les avantages d'Ethereum sans avoir besoin de connaître ou de se soucier de la technologie sous-jacente.
+Finalement, l'abstraction de compte améliore le support des portefeuilles de contrats intelligents, les rendant plus faciles à développer et plus sûrs à utiliser. Avec l'abstraction de compte, les utilisateurs peuvent profiter de tous les avantages d'Ethereum sans avoir besoin de comprendre la technologie sous-jacente.
 
-## En finir avec les phrases de récupération {#beyond-seed-phrases}
+## Au-delà des phrases de récupération {#beyond-seed-phrases}
 
-Les comptes d'aujourd'hui sont sécurisés en utilisant des clés privées calculées à partir de phrases de récupération. Toute personne ayant accès à une phrase de récupération peut facilement découvrir la clé privée protégeant un compte et gagner l'accès à tous les actifs qu'il contient. Si une clé privée et une phrase de récupération sont perdues, elles ne pourront jamais être récupérées et les actifs qu'elles contrôlent seront figés à jamais. La sécurisation de ces phrases de récupération est compliquée, même pour les utilisateurs expérimentés, et l'hameçonnage de phrases de récupération est l'une des méthodes les plus courantes utilisées pour arnaquer les utilisateurs.
+Les comptes d'aujourd'hui sont sécurisés en utilisant des clés privées calculées à partir de phrases de récupération. Toute personne ayant accès à une phrase de récupération peut facilement découvrir la clé privée protégeant un compte et obtenir l'accès à tous les actifs qu'il contient. Si une clé privée et une phrase de récupération sont perdues, les actifs deviennent définitivement inaccessibles. La sécurisation de ces phrases de récupération est compliquée, même pour les utilisateurs expérimentés, et l'hameçonnage de phrases de récupération est l'une des méthodes les plus courantes d'arnaque.
 
-L'abstraction de compte résoudra ce problème en utilisant un contrat intelligent pour détenir les actifs et autoriser les transactions. Ces contrats intelligents peuvent ensuite être agrémentés de logiques personnalisées pour les rendre aussi sécurisés et adaptés à l'utilisateur que possible. Au bout du compte, vous utiliserez toujours des clés privées pour contrôler l'accès à votre compte, mais avec des filets de sécurité qui les rendront plus faciles et plus sûres à gérer.
+L'abstraction de compte résout cela en utilisant un contrat intelligent pour détenir les actifs et autoriser les transactions. Les contrats intelligents peuvent inclure une logique personnalisée conçue pour une sécurité et une convivialité optimales. Les utilisateurs utilisent toujours des clés privées pour contrôler l’accès, mais avec des mesures de sécurité renforcées.
 
-Par exemple, des clés de secours peuvent être ajoutées à un portefeuille afin que si vous perdiez ou exposiez accidentellement votre clé principale, elle puisse être remplacée par une nouvelle clé sécurisée de secours. Vous pourriez sécuriser chacune de ces clés différemment ou les répartir entre des gardiens de confiance. Cela rend beaucoup plus difficile pour un voleur de prendre le contrôle total de vos fonds. De même, vous pouvez ajouter des règles au portefeuille pour réduire l'impact en cas de compromission de votre clé principale, par exemple vous pourriez autoriser les transactions de faible valeur à être vérifiées par une seule signature, tandis que les transactions de plus grande valeur nécessitent l'approbation de plusieurs signataires authentifiés. Il existe d'autres moyens par lesquels les portefeuilles de contrats intelligents peuvent vous aider à déjouer les voleurs, par exemple, une liste de confiance peut être utilisée pour bloquer toutes les transactions à moins qu'elles ne soient destinées à une adresse de confiance ou vérifiées par plusieurs de vos clés pré-approuvées.
-
-### Exemples de logiques de sécurité pouvant être intégrées dans un portefeuille de contrat intelligent :
-
-- **Autorisation multi-signatures**: vous pouvez partager les identifiants d'autorisation entre plusieurs personnes ou appareils de confiance. Alors, le contrat peut être configuré de telle sorte que les transactions d'une valeur supérieure à une certaine valeur prédéfinie nécessitent l'autorisation d'une certaine proportion (par exemple 3/5) des parties de confiance. Par exemple, les transactions de valeur élevée pourraient nécessiter l'approbation à la fois d'un appareil mobile et d'un portefeuille matériel, ou les signatures de comptes distribués à des membres de la famille de confiance.
-- **Gel de compte** : si un appareil est perdu ou compromis, le compte peut être verrouillé depuis un autre appareil autorisé, protégeant ainsi les actifs de l'utilisateur.
-- **Récupération de compte** : vous avez perdu un appareil ou oublié un mot de passe ? Dans le paradigme actuel, cela signifie que vos actifs pourraient être gelés à jamais. Avec un portefeuille de contrats intelligents, vous pouvez mettre en place une liste de confiance des comptes pouvant autoriser de nouveaux appareils ou réinitialiser les accès.
-- **Définir des limites de transaction**: Spécifiez des seuils quotidiens pour la valeur maximale pouvant être transférée depuis le compte par jour/semaine/mois. Cela signifie que si un attaquant prend le contrôle de votre compte, il ne pourra pas tout vider d'un coup, et vous aurez l'occasion de geler et de réinitialiser l'accès.
-- **Créer une liste de confiance** : N'autoriser les transactions qu'à une liste restreinte d'adresses que vous savez sûres. Cela signifie que _même si_ votre clé privée était volée, l'attaquant ne pourrait envoyer des fonds qu'à des comptes de destination faisant partie de votre liste. Ces listes des adresses autorisées nécessiteraient plusieurs signatures pour être modifiées, de sorte qu'un attaquant ne pourrait pas ajouter sa propre adresse à la liste à moins d'avoir accès à plusieurs de vos clés de sauvegarde.
+Par exemple, des clés de secours peuvent être ajoutées à un portefeuille, permettant de remplacer la clé principale en cas de compromission. Chaque clé peut être sécurisée différemment ou répartie entre des personnes de confiance, augmentant ainsi considérablement la sécurité. Des règles supplémentaires du portefeuille peuvent limiter les dégâts en cas d’exposition d’une clé, comme l’exigence de plusieurs signatures pour les transactions de grande valeur ou la restriction des transactions à des adresses de confiance.
 
 ## Meilleure expérience utilisateur {#better-user-experience}
 
-L'abstraction de compte permet une **meilleure expérience utilisateur globale** ainsi qu'une **sécurité améliorée** car elle ajoute la prise en charge des portefeuilles de contrats intelligents. au niveau du protocole. La raison la plus importante est que cela offrira aux développeurs de contrats intelligents, de portefeuilles et d’applications beaucoup plus de liberté pour innover en matière d’expérience utilisateur d’une manière que nous ne pouvons peut-être pas encore anticiper. Quelques améliorations évidentes qui accompagneront l'abstraction de compte incluent le regroupement des transactions pour plus de rapidité et d'efficacité. Par exemple, un simple échange devrait être une opération en un clic, mais aujourd'hui, il faut signer plusieurs transactions pour approuver les dépenses de chaque jeton individuellement avant que l'échange ne soit exécuté. L'abstraction de compte élimine cette friction en autorisant le regroupement des transactions. De plus, la transaction groupée pourrait approuver précisément la bonne valeur de jetons requise pour chaque transaction, puis révoquer les approbations après la finalisation de la transaction, offrant ainsi une sécurité supplémentaire.
-
-La gestion du gaz est également nettement améliorée grâce à l'abstraction de comptes. Non seulement les applications peuvent proposer de payer les frais de gaz de leurs utilisateurs, mais les frais de gaz peuvent être payés en jetons autres que l'ETH, ce qui évite aux utilisateurs d'avoir à maintenir un solde d'ETH pour financer les transactions. Cela fonctionnerait en échangeant les jetons de l'utilisateur contre de l'ETH à l'intérieur du contrat, puis en utilisant l'ETH pour payer le gaz.
-
-<ExpandableCard title="Comment l'abstraction de comptes peut-elle être utile pour le gaz ?" eventCategory="/roadmap/account-abstraction" eventName="clicked how can account abstraction help with gas?">
-
-La gestion du gaz est l'une des principales frictions pour les utilisateurs d'Ethereum, principalement parce que l'ETH est le seul actif qui peut être utilisé pour payer les transactions. Imaginez que vous ayez un portefeuille avec un solde d'USDC, mais pas d'ETH. Vous ne pouvez pas déplacer ou échanger ces jetons USDC parce que vous ne pouvez pas payer le gaz. Vous ne pouvez pas non plus échanger l'USDC contre de l'ETH, car cela coûte du gaz. Pour résoudre le problème, vous devez envoyer plus d'ETH sur votre compte à partir d'un échange ou d'une autre adresse. Avec les portefeuilles de contrats intelligents, vous pouvez simplement payer le gaz en USDC à la place, libérant ainsi votre compte. Vous n'avez plus besoin de conserver un solde d'ETH sur tous vos comptes.
-
-L'abstraction de comptes permet également aux développeurs de DApp de faire preuve de créativité en matière de gestion du gaz. Par exemple, vous pourriez commencer à payer à votre DEX préféré un montant fixe chaque mois pour un nombre illimité de transactions. Les DApps peuvent vous proposer de payer tous vos frais de gaz en votre nom en guise de récompense pour l'utilisation de leur plateforme, ou en tant qu'offre de démarrage. Il sera beaucoup plus facile pour les développeurs d'innover dans le domaine du gaz lorsque les portefeuilles de contrats intelligents seront pris en charge au niveau du protocole.
+L’abstraction de compte améliore considérablement l’expérience utilisateur et la sécurité en prenant en charge les portefeuilles de contrats intelligents au niveau du protocole. Les développeurs peuvent innover librement, en améliorant le regroupement des transactions pour plus de rapidité et d’efficacité. Les échanges simples peuvent devenir des opérations en un clic, ce qui améliore considérablement la facilité d’utilisation.
 
-</ExpandableCard>
-
-Les sessions de confiance sont aussi susceptibles de transformer l'expérience utilisateur, en particulier pour des applications comme les jeux, où un grand nombre de petites transactions doivent être approuvées dans un court laps de temps. L'approbation individuelle de chaque transaction perturberait l'expérience du jeu, mais l'approbation permanente n'est pas sécurisée. Un portefeuille de contrats intelligents, pourrait approuver certaines transactions lors d'un temps fixe jusqu'à une certaine valeur spécifique, ou seulement vers certaines adresses.
-
-Il est également intéressant de réfléchir à la manière, dont les achats pourraient évoluer avec l’abstraction du compte. Aujourd'hui, chaque transaction doit être approuvée et exécutée depuis un portefeuille préfinancé avec une quantité suffisante du bon jeton. Grâce à l'abstraction des comptes, l'expérience pourrait ressembler davantage aux achats en ligne habituels, où l'utilisateur remplit un « panier » d'articles et clique une seule fois pour les acheter en même temps, avec toute la logique requise étant assurée par le contrat, non par l'utilisateur.
-
-Ce ne sont là que quelques exemples, de la manière dont l’expérience utilisateur pourrait être améliorée grâce à l’abstraction des comptes, mais il y en a bien d’autres que nous n’avons pas encore imaginés. L'abstraction de compte libère les développeurs des contraintes des EOA actuels, leur permet d'intégrer les bons aspects du web2 dans le web3 sans sacrifier leur propre sécurité, et pirater de manière créative de nouvelles expériences utilisateur inventives.
+La gestion du gas s’améliore considérablement. Les applications peuvent payer les frais de gaz des utilisateurs ou autoriser le paiement en tokens autres que l’ETH, éliminant ainsi le besoin de maintenir un solde en ETH.
 
 ## Comment l'abstraction des comptes sera-t-elle mise en œuvre ? {#how-will-aa-be-implemented}
 
-Aujourd'hui, les portefeuilles de contrats intelligents existent mais sont difficiles à mettre en œuvre car l'EVM ne les prend pas en charge. À la place, ils s’appuient sur un code relativement complexe autour des transactions standard d'Ethereum. Ethereum peut changer cela en permettant aux contrats intelligents d'initier des transactions, adoptant une logique nécessaire dans les contrats intelligents d'Ethereum plutôt que hors chaîne. L'addition de logique dans les contrats intelligents augmente également la décentralisation d'Ethereum, car elle élimine le besoin de « relais » gérés par les développeurs de portefeuilles, pour traduire les messages signés par l'utilisateur lors des transactions régulières Ethereum.
-
-<ExpandableCard title="EIP-2771 : abstraction de comptes à l'aide de méta-transactions" eventCategory="/roadmap/account-abstract" eventName="clicked EIP-2771: account abstraction using meta-transactions">
-
-L'EIP-2771 introduit le concept de méta-transactions qui permettent à des tiers de payer les frais de gaz d'un utilisateur sans modifier le protocole Ethereum. L'idée est que les transactions signées par un utilisateur sont envoyées à un contrat "Forwarder". Le forwarder est une entité de confiance qui vérifie que les transactions sont valides avant de les transmettre à un relais de gaz. C'est fait hors chaîne, ce qui évite d'avoir à payer du gaz. Le relais de gaz transmet la transaction à un contrat « Destinataire », qui paie le gaz nécessaire pour que la transaction puisse être exécutée sur Ethereum. La transaction est exécutée si le « Forwarder » est connu du « Destinataire » et lui fait confiance. Ce modèle facilite la mise en œuvre par les développeurs de transactions sans gaz pour les utilisateurs.
-
-</ExpandableCard>
-
-<ExpandableCard title="EIP-4337 : abstraction de compte sans changer le protocole Ethereum" eventCategory="/roadmap/account-abstract" eventName="clicked EIP-4337: account abstraction without changing the Ethereum protocol">
-
-L'EIP-4337 est la première étape vers la prise en charge native des portefeuilles de contrats intelligents de manière décentralisée <em>sans nécessiter de modifications du protocole Ethereum</em>. Au lieu de modifier la couche de consensus pour prendre en charge les portefeuilles de contrats intelligents, un nouveau système est ajouté séparément à la transaction normale du « gossip protocol ». Ce système de haut niveau s'articule autour d'un nouvel objet appelé <code>UserOperation</code> qui regroupe les actions d'un utilisateur et les signatures correspondantes. Ces <code>UserOperation</code> soulèvent une objection puis sont diffusés dans un pool de mémoire dédié, où les validateurs peuvent les collecter dans une « transaction groupée ». La transaction groupée représente une séquence de nombreuses <code>UserOperations</code> individuelles, et peut être incluse dans les blocs d'Ethereum tout comme une transaction normale, et serait récupérée par les validateurs en utilisant un modèle de sélection similaire maximisant les frais.
-
-Le fonctionnement des portefeuilles changerait également avec l'EIP-4337. Au lieu que chaque portefeuille réimplémente une logique de sécurité commune mais complexe, ces fonctions seraient externalisées vers un contrat de portefeuille global, plus connu sous le nom de &quot;point d'entrée&quot;. Cela permettrait de gérer des opérations telles que le paiement des frais et l'exécution du code EVM, afin que les développeurs de portefeuilles puissent se concentrer sur la fourniture d'excellentes expériences utilisateurs.
-
-<strong>Il est à noter</strong> que le contrat de point d'entrée EIP 4337, a été déployé sur le réseau principal Ethereum le 1er mars 2023. Vous pouvez voir le contrat sur<a href="https://etherscan.io/address/0x0576a174D229E3cFA37253523E645A78A0C91B57">Etherscan</a>.
-
-</ExpandableCard>
-
-<ExpandableCard title="EIP-2938 : modification du protocole Ethereum pour soutenir l'abstraction de comptes" eventCategory="/roadmap/account-abstract" eventName="clicked EIP-2938: changing the Ethereum protocol to support account abstraction">
-
-<a href="https://eips.ethereum.org/EIPS/eip-2938">EIP-2938</a> vise à mettre à jour le protocole Ethereum en introduisant un nouveau type de transaction : <code>AA_TX_TYPE</code> qui comprend trois champs : <code>nonce</code>, <code>cible</code> et <code>data</code>, où <code>nonce</code> est un compteur de transactions, <code>cible</code> est l'adresse du contrat du point d'entrée et <code>données</code> est le bytecode EVM. Pour exécuter ces transactions, deux nouvelles instructions (appelées opcodes) doivent être ajoutées à l'EVM : <code>NONCE</code> et <code>PAYGAS</code>. L'opcode <code>NONCE</code> suit la séquence de transaction et <code>PAYGAS</code> calcule puis retire le gaz nécessaire à l'exécution de la transaction du &#39;s solde du contrat. Ces nouvelles fonctionnalités permettent à Ethereum de prendre en charge les portefeuilles de contrats intelligents de manière native, car l’infrastructure nécessaire est intégrée au protocole Ethereum.&#39;.
-
-Notez qu'EIP-2938 n'est actuellement pas actif. La communauté favorise actuellement EIP-4337 car il ne nécessite pas de modification du protocole.
-
-</ExpandableCard>
-
-<ExpandableCard title="EIP-3074 : mise à niveau des comptes EOA pour l'abstraction de comptes" eventCategory="/roadmap/account-abstract" eventName="clicked EIP-3074: upgrading externally-owned accounts for account abstraction">
-
-L'<a href="https://eips.ethereum.org/EIPS/eip-3074">EIP-3074</a> vise à mettre à jour les comptes externes d'Ethereum&#39;s en leur permettant de déléguer le contrôle à un contrat intelligent. Cela signifie que la logique des contrats intelligents pourrait approuver les transactions provenant d’un EOA. Cela permettrait des fonctionnalités telles que le parrainage du gaz et les transactions groupées. Pour que cela fonctionne, deux nouveaux opcodes doivent être ajoutés à l'EVM : <code>AUTH</code> et <code>AUTHCALL</code>. Avec EIP-3074, les avantages d'un portefeuille de contrats intelligents sont rendus disponibles <em>sans avoir besoin de contrat</em> - à la place, un type spécifique de contrat sans état, dénué de confiance et non-évolutif, aussi connu sous le nom « d'appelant », gère les transactions.
+Actuellement, les portefeuilles de contrats intelligents sont difficiles à mettre en œuvre car ils reposent sur du code complexe qui enveloppe les transactions standard. Ethereum peut changer cela en permettant aux contrats intelligents d’initier directement des transactions, en intégrant la logique dans les contrats intelligents Ethereum plutôt qu’en s’appuyant sur des relais externes.
 
-Notez qu'EIP-3074 n'est pas actif actuellement. La communauté favorise actuellement EIP-4337 car il ne nécessite pas de modification du protocole.
+### EIP-4337 : Abstraction de compte sans modification du protocole
 
-</ExpandableCard>
+L’EIP-4337 permet la prise en charge native des portefeuilles de contrats intelligents sans modifier le protocole central d’Ethereum. Il introduit des objets `UserOperation` regroupés en lots de transactions par les validateurs, ce qui simplifie le développement de portefeuilles. Le contrat EntryPoint de l’EIP-4337 a été déployé sur le réseau principal d’Ethereum le 1er mars 2023 et a permis la création de plus de 26 millions de portefeuilles intelligents et 170 millions de UserOperations.
 
 ## Progrès actuels {#current-progress}
 
-Des portefeuilles de contrats intelligents sont déjà disponibles, mais d'autres améliorations sont nécessaires pour les rendre aussi décentralisés et sans autorisation que possible. L'EIP-4337 est une proposition mûre qui ne nécessite aucune modification du protocole Ethereum, il est donc possible qu'elle soit mise en œuvre rapidement. Toutefois, les mises à jour qui modifient le protocole d'Ethereum ne sont actuellement pas en cours de développement actif, de sorte que ces changements peuvent prendre beaucoup plus de temps à être déployés. Il est également possible que l'abstraction des comptes soit suffisamment bien réalisée par l'EIP-4337 pour qu'aucun changement de protocole ne soit jamais nécessaire.
+Dans le cadre de la mise à niveau Pectra d’Ethereum, l’EIP-7702 est prévu pour le 7 mai 2025. L'EIP-4337 a été largement adopté, [avec plus de 26 millions de comptes intelligents déployés et plus de 170 millions de UserOperations traitées](https://www.bundlebear.com/erc4337-overview/all).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [erc4337.io](https://www.erc4337.io/)
-- [Débat sur l'abstraction des comptes à Devcon Bogota](https://www.youtube.com/watch?app=desktop&v=WsZBymiyT-8)
-- ["Pourquoi l'abstraction de compte est une innovation majeure pour les dapps" - Devcon Bogota](https://www.youtube.com/watch?v=OwppworJGzs)
-- [« L'abstraction de compte, ELI5 » - Devcon Bogota](https://www.youtube.com/watch?v=QuYZWJj65AY)
-- [Les notes de Vitalik sur la « Route vers l'abstraction de comptes »](https://notes.ethereum.org/@vbuterin/account_abstraction_roadmap#Transaction-inclusion-lists)
-- [Article de blog de Vitalik sur les portefeuilles à récupération sociale](https://vitalik.eth.limo/general/2021/01/11/recovery.html)
-- [Notes EIP-2938](https://hackmd.io/@SamWilsn/ryhxoGp4D#What-is-EIP-2938)
-- [Documentation EIP-2938](https://eips.ethereum.org/EIPS/eip-2938)
-- [Notes EIP-4337](https://medium.com/infinitism/erc-4337-account-abstraction-without-ethereum-protocol-changes-d75c9d94dc4a)
+- [erc4337.io](https://docs.erc4337.io/)
 - [Documentation EIP-4337](https://eips.ethereum.org/EIPS/eip-4337)
-- [Documentation EIP-2771](https://eips.ethereum.org/EIPS/eip-2771)
-- [« Les bases de l'abstraction de comptes » -- Qu'est-ce que l'abstraction de comptes ? Partie 1](https://www.alchemy.com/blog/account-abstraction)
+- [Documentation EIP-7702](https://eips.ethereum.org/EIPS/eip-7702)
+- [Tableau de bord de l'adoption de l'ERC-4337](https://www.bundlebear.com/erc4337-overview/all)
+- [« La voie vers l'abstraction de compte » de Vitalik](https://notes.ethereum.org/@vbuterin/account_abstraction_roadmap#Transaction-inclusion-lists)
+- [Le blog de Vitalik sur les portefeuilles à récupération sociale](https://vitalik.eth.limo/general/2021/01/11/recovery.html)
+- [Awesome Account Abstraction](https://github.com/4337Mafia/awesome-account-abstraction)
diff --git a/public/content/translations/fr/roadmap/beacon-chain/index.md b/public/content/translations/fr/roadmap/beacon-chain/index.md
index 0f3e4f8af66..527f0b39606 100644
--- a/public/content/translations/fr/roadmap/beacon-chain/index.md
+++ b/public/content/translations/fr/roadmap/beacon-chain/index.md
@@ -1,49 +1,49 @@
 ---
-title: La chaîne phare
-description: En savoir plus sur la chaîne phare - la mise à niveau qui a introduit la preuve d'enjeu d'Ethereum.
+title: "La Chaîne phare"
+description: "En savoir plus sur la chaîne phare - la mise à niveau qui a introduit la preuve d'enjeu d'Ethereum."
 lang: fr
 template: upgrade
-image: /images/use-cases/defi.png
+image: /images/upgrades/core.png
 alt:
-summaryPoint1: La Chaîne phare a introduit la preuve d'enjeu dans l'écosystème Ethereum.
-summaryPoint2: Elle a été fusionnée avec la chaîne originale de preuve de travail Ethereum en septembre 2022.
-summaryPoint3: La Chaîne phare a introduit la logique de consensus et le protocole de commutation de bloc qui sécurise désormais Ethereum.
+summaryPoint1: "La Chaîne phare a introduit la preuve d'enjeu dans l'écosystème Ethereum."
+summaryPoint2: "Elle a été fusionnée avec la chaîne originale de preuve de travail Ethereum en septembre 2022."
+summaryPoint3: "La Chaîne phare a introduit la logique de consensus et le protocole de commutation de bloc qui sécurise désormais Ethereum."
 ---
 
 <UpgradeStatus isShipped dateKey="page-upgrades:page-upgrades-beacon-date">
-  La Chaîne phare a été présentée le 1er décembre 2020 et a formalisé la preuve d'enjeu comme mécanisme de consensus d'Ethereum avec La Fusion du 15 septembre 2022.
+  La Chaîne phare a été lancée le 1er décembre 2020 et a formalisé la preuve d'enjeu comme mécanisme de consensus d'Ethereum avec la mise à niveau The Merge le 15 septembre 2022.
 </UpgradeStatus>
 
 ## Qu'est-ce que la chaîne phare Beacon ? {#what-is-the-beacon-chain}
 
-La chaîne phare Beacon est le nom donné à la chaîne originelle à preuve d'enjeu, lancée en 2020. Elle a été crée pour s'assurer que la logique de consensus par preuve d'enjeu était saine et durable avant de l'activer sur le réseau principal Ethereum. Par conséquent, elle a fonctionné aux côtés de l'Ethereum original de preuve de travail. La chaîne Beacon était une chaîne de blocs « vides », mais désactiver la preuve de travail et activer la preuve d'enjeu sur Ethereum nécessitait de demander à la Beacon Chain d'accepter les données de transaction des clients d'exécution, de les regrouper en blocs, puis de les organiser dans une blockchain en utilisant un mécanisme de consensus basé sur la preuve d'enjeu. Au même moment, les clients originaux d'Ethereum ont arrêté leur minage, la propagation du bloc et la logique de consensus, regroupant tout ceci sur la Chaîne phare. Cet événement était connu sous le nom de [La Fusion](/roadmap/merge/). Une fois que La Fusion a eu lieu, il n’y avait plus deux blockchains. Au lieu de cela, il n’y avait qu’une seule preuve d'enjeu Ethereum, qui nécessite désormais deux clients différents par nœud. La chaîne Beacon est désormais la couche de consensus, un réseau de pair à pair de clients de consensus qui gère le gossip des blocs et la logique de consensus, tandis que les clients d'origine forment la couche d'exécution, qui est responsable de l'échange d'informations et de l'exécution des transactions, ainsi que de la gestion de l'état d'Ethereum. Les deux couches peuvent communiquer entre elles en utilisant l'API Engine.
+La chaîne phare Beacon est le nom donné à la chaîne originelle à preuve d'enjeu, lancée en 2020. Elle a été crée pour s'assurer que la logique de consensus par preuve d'enjeu était saine et durable avant de l'activer sur le réseau principal Ethereum. Par conséquent, elle a fonctionné aux côtés de l'Ethereum original de preuve de travail. La chaîne Beacon était une chaîne de blocs « vides », mais désactiver la preuve de travail et activer la preuve d'enjeu sur Ethereum nécessitait de demander à la Beacon Chain d'accepter les données de transaction des clients d'exécution, de les regrouper en blocs, puis de les organiser dans une blockchain en utilisant un mécanisme de consensus basé sur la preuve d'enjeu. Au même moment, les clients originaux d'Ethereum ont arrêté leur minage, la propagation du bloc et la logique de consensus, regroupant tout ceci sur la Chaîne phare. Cet événement était connu sous le nom de [La Fusion](/roadmap/merge/). Une fois La Fusion effectuée, il n'y avait plus deux blockchains. Au lieu de cela, il n’y avait qu’une seule preuve d'enjeu Ethereum, qui nécessite désormais deux clients différents par nœud. La chaîne Beacon est désormais la couche de consensus, un réseau de pair à pair de clients de consensus qui gère le gossip des blocs et la logique de consensus, tandis que les clients d'origine forment la couche d'exécution, qui est responsable de l'échange d'informations et de l'exécution des transactions, ainsi que de la gestion de l'état d'Ethereum. Les deux couches peuvent communiquer entre elles en utilisant l'API Engine.
 
 ## Que fait la chaîne Beacon ? {#what-does-the-beacon-chain-do}
 
-La chaîne Beacon est le nom donné au registre de comptes utilisé pour la conduite et la coordination du réseau d'Ethereum de [validateurs](/staking/) avant que ces mêmes validateurs commencent réellement la validation des blocs Ethereum. Elle n'exécute pas les transactions ou gère les interactions des contrats intelligents puisque cela est assuré au niveau de la couche d'exécution. La chaîne Beacon est responsable des éléments comme la gestion des blocs et de leur attestation, en accord avec l'algorithme de choix de fourche, tout en gérant les récompenses et les pénalités. Pour en savoir plus, veuillez vous reporter à notre [page d'architecture des noeuds](/developers/docs/nodes-and-clients/node-architecture/#node-comparison).
+La Chaîne phare est le nom donné à un registre de comptes qui a géré et coordonné le réseau des [validateurs](/staking/) d'Ethereum avant que ces derniers ne commencent à valider les blocs réels d'Ethereum. Elle n'exécute pas les transactions ou gère les interactions des contrats intelligents puisque cela est assuré au niveau de la couche d'exécution.
+La chaîne Beacon est responsable des éléments comme la gestion des blocs et de leur attestation, en accord avec l'algorithme de choix de fourche, tout en gérant les récompenses et les pénalités.
+En savoir plus sur notre [page sur l'architecture des nœuds](/developers/docs/nodes-and-clients/node-architecture/#node-comparison).
 
 ## Impact de la Chaîne phare {#beacon-chain-features}
 
-### Présentation de la preuve d'enjeu {#introducing-staking}
+### Introduction à la mise en jeu {#introducing-staking}
 
-La Chaîne phare introduit la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/) dans Ethereum. Cela permet de sécuriser Ethereum et pour les validateurs de gagner plus d'ETH au cours du processus. En pratique, le staking implique de miser des ETH pour activer le logiciel de validation. En tant que validateur, vous exécutez le logiciel qui créé et valide de nouveaux blocs dans la chaîne.
+La Chaîne phare a introduit la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/) dans Ethereum. Cela permet de sécuriser Ethereum et pour les validateurs de gagner plus d'ETH au cours du processus. En pratique, le staking implique de miser des ETH pour activer le logiciel de validation. En tant que validateur, vous exécutez le logiciel qui créé et valide de nouveaux blocs dans la chaîne.
 
-La mise en jeu a un objectif similaire au [minage](/developers/docs/consensus-mechanisms/pow/mining/), mais diffère à plusieurs titres. Le minage nécessitait d’importantes dépenses initiales sous la forme d’une puissante consommation en matériel et énergie, entraînant des économies d’échelle et promouvant la centralisation. Le minage n'impliquait pas non plus l'obligation de bloquer les actifs en tant que garantie, ce qui limite la capacité du protocole à punir les mauvais acteurs après une attaque.
+La mise en jeu a un objectif similaire à celui du [minage](/developers/docs/consensus-mechanisms/pow/mining/), mais en diffère à bien des égards. Le minage nécessitait d’importantes dépenses initiales sous la forme d’une puissante consommation en matériel et énergie, entraînant des économies d’échelle et promouvant la centralisation. Le minage n'impliquait pas non plus l'obligation de bloquer les actifs en tant que garantie, ce qui limite la capacité du protocole à punir les mauvais acteurs après une attaque.
 
 La transition vers la preuve d'enjeu a rendu Ethereum nettement plus sûr et décentralisé par comparaison avec la preuve de travail. Plus le nombre de participants sera élevé sur le réseau, plus celui-ci sera décentralisé et à l'abri des attaques.
 
-De plus, l'utilisation de la preuve d'enjeu comme mécanisme de consensus est un composant fondamental pour un [Ethereum sécurisé, respectueux de l'environnement et évolutif tel que nous le connaissons maintenant](/roadmap/).
-
 <Alert variant="update">
 <AlertEmoji text=":money_bag:"/>
 <AlertContent>
 <AlertDescription>
-  Si vous souhaitez devenir validateur et aider à sécuriser Ethereum, [familiarisez-vous avec le concept de mise en jeu](/staking/).
+  Si vous souhaitez devenir validateur et contribuer à sécuriser Ethereum, [apprenez-en plus sur la mise en jeu](/staking/).
 </AlertDescription>
 </AlertContent>
 </Alert>
 
-### Mise en place de la fragmentation {#setting-up-for-sharding}
+### Préparation à la fragmentation {#setting-up-for-sharding}
 
 Depuis que la Chaîne phare a fusionné avec le réseau principal Ethereum d'origine, la communauté Ethereum a commencé à chercher à mettre le réseau à niveau.
 
@@ -55,7 +55,7 @@ Cette responsabilité contraste avec la preuve de travail, où les mineurs n'ont
 
 ## Relation entre les mises à niveau {#relationship-between-upgrades}
 
-Les mises à niveau d'Ethereum sont plus ou moins interdépendantes. Récapitulons donc comment la chaîne phare affecte les autres mises à niveau.
+Les mises à niveau Ethereum sont plus ou moins interdépendantes. Récapitulons donc comment la chaîne phare affecte les autres mises à niveau.
 
 ### La Chaîne phare et La Fusion {#merge-and-beacon-chain}
 
@@ -65,9 +65,10 @@ Au début, la Chaîne phare existait séparément du réseau principal Ethereum,
   La Fusion
 </ButtonLink>
 
-### Fragments et chaîne phare {#shards-and-beacon-chain}
+### Les fragments et la Chaîne phare {#shards-and-beacon-chain}
 
-La fragmentation ne peut s'ajouter en toute sécurité dans l'écosystème Ethereum que s'il existe un mécanisme de consensus sur la preuve d'enjeu. La Chaîne phare a introduit la mise en jeu qui a « fusionné » avec le réseau principal et a ouvert la voie à la fragmentation pour favoriser une plus grande évolutivité d'Ethereum.
+La fragmentation ne peut s'ajouter en toute sécurité dans l'écosystème Ethereum que s'il existe un mécanisme de consensus sur la preuve d'enjeu.
+La Chaîne phare a introduit la mise en jeu qui a « fusionné » avec le réseau principal et a ouvert la voie à la fragmentation pour favoriser une plus grande évolutivité d'Ethereum.
 
 <ButtonLink href="/roadmap/danksharding/">
   Chaînes de fragments
@@ -75,6 +76,5 @@ La fragmentation ne peut s'ajouter en toute sécurité dans l'écosystème Ether
 
 ## Complément d'information
 
-- [En savoir plus sur les futures mises à jour d'Ethereum](/roadmap/vision)
-- [En savoir plus sur l'architecture d'un noeud](/developers/docs/nodes-and-clients/node-architecture)
+- [En savoir plus sur l'architecture des nœuds](/developers/docs/nodes-and-clients/node-architecture)
 - [En savoir plus sur la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos)
diff --git a/public/content/translations/fr/roadmap/danksharding/index.md b/public/content/translations/fr/roadmap/danksharding/index.md
index a6e72d2aef6..8f6ab31e1b5 100644
--- a/public/content/translations/fr/roadmap/danksharding/index.md
+++ b/public/content/translations/fr/roadmap/danksharding/index.md
@@ -1,6 +1,6 @@
 ---
 title: Danksharding
-description: Découvrez le Proto-Danksharding et le Danksharding, deux mises à jour consécutives pour passer à l’échelle Ethereum.
+description: "Découvrez le Proto-Danksharding et le Danksharding, deux mises à niveau consécutives pour passer à l’échelle Ethereum."
 lang: fr
 summaryPoints:
   - Le Danksharding est une mise à jour en plusieurs phases visant à améliorer le passage à l’échelle et les capacités d'Ethereum.
@@ -11,50 +11,46 @@ summaryPoints:
 
 # Danksharding {#danksharding}
 
-Le **Danksharding** est la façon dont Ethereum devient une blockchain à grande échelle, mais plusieurs mises à jour de protocole sont nécessaires pour y parvenir. Le **Proto-Danksharding** est une étape intermédiaire sur ce chemin. Les deux visent à rendre les transactions sur les secondes couches aussi économiques que possible pour les utilisateurs et devraient permettre à Ethereum de traiter plus de >100 000 transactions par seconde.
+**Le Danksharding** est ce qui permettra à Ethereum de devenir une blockchain véritablement évolutive, mais plusieurs mises à jour du protocole sont nécessaires pour y parvenir. **Le Proto-Danksharding est une étape intermédiaire sur ce chemin.** Tous deux visent à rendre les transactions sur la couche 2 aussi peu coûteuses que possible pour les utilisateurs et devraient permettre à Ethereum de traiter plus de 100 000 transactions par seconde.
 
 ## Qu'est-ce que le Proto-Danksharding ? {#what-is-protodanksharding}
 
-Le Proto-Danksharding, également connu sous le nom d'[EIP-4844](https://eips.ethereum.org/EIPS/eip-4844), est une manière pour les [rollups](/layer-2/#rollups) d'ajouter des données aux blocs, à moindre frais. Le nom provient des deux chercheurs qui ont proposé l'idée : Protolambda et Dankrad Feist. Historiquement, les rollups étaient limités dans la mesure où ils peuvent effectuer des transactions utilisateur à moindre coût du fait qu'ils publient leurs transactions dans `CALDATA`.
+Le Proto-Danksharding, également connu sous le nom d'[EIP-4844](https://eips.ethereum.org/EIPS/eip-4844), est un moyen pour les [rollups](/layer-2/#rollups) d'ajouter des données moins coûteuses aux blocs. Le nom provient des deux chercheurs qui ont proposé l'idée : Protolambda et Dankrad Feist. Historiquement, la capacité des rollups à rendre les transactions des utilisateurs peu coûteuses était limitée par le fait qu'ils publient leurs transactions dans `CALLDATA`.
 
 Cette solution est onéreuse car ces données sont traitées par l’ensemble des nœuds d’Ethereum et restent sur la blockchain pour toujours, même si les rollups n'ont besoin des données que pendant une courte période. Le Proto-Danksharding introduit des « blobs » de données qui peuvent être envoyés et ajoutés aux blocs. Les données présentes dans ces blobs ne sont pas accessibles pour l'EVM et sont automatiquement supprimées après un laps de temps fixe (fixé à 4 096 périodes à l'heure actuelle, soit à peu près 18 jours). Cela signifie que les rollups peuvent envoyer leurs données à moindre frais et répercuter ces économies sur les utilisateurs finaux sous forme de transactions moins onéreuses.
 
-<ExpandableCard title="Pourquoi les blobs rendent-ils les rollups moins coûteux ?" eventCategory="/roadmap/danksharding" eventName="clicked why do blocks make rollups cheaper?">
-
-Les rollups sont une méthode pour faire passer Ethereum à l'échelle en regroupant les transactions hors chaîne, puis en publiant les résultats sur Ethereum. Un rollup est essentiellement composé de deux parties : les données et la vérification de l'exécution. Les données représentent la séquence complète de transactions traitées par un rollup pour générer le changement d'état publié sur Ethereum. La vérification de l'exécution consiste à faire réexécuter ces transactions par un acteur honnête (un « démonstrateur ») pour garantir que le changement d'état proposé est correct. Pour que la vérification de l'exécution soit possible, les données de transaction doivent être disponibles suffisamment longtemps afin que quiconque puisse les télécharger et les vérifier. Cela signifie que tout comportement malhonnête de la part du séquenceur de rollup peut être identifié et contesté par le démonstrateur. Cependant, ces données n'ont pas besoin d'être disponibles indéfiniment.
+<ExpandableCard title="Pourquoi les blobs rendent-ils les rollups moins chers ?" eventCategory="/roadmap/danksharding" eventName="clicked why do blocks make rollups cheaper?">
 
+Les rollups sont un moyen de faire évoluer Ethereum en regroupant les transactions hors chaîne, puis en publiant les résultats sur Ethereum. Un rollup est essentiellement composé de deux parties : les données et la vérification de l'exécution. Les données représentent la séquence complète de transactions traitées par un rollup pour générer le changement d'état publié sur Ethereum. La vérification de l'exécution consiste à faire réexécuter ces transactions par un acteur honnête (un « démonstrateur ») pour garantir que le changement d'état proposé est correct. Pour que la vérification de l'exécution soit possible, les données de transaction doivent être disponibles suffisamment longtemps afin que quiconque puisse les télécharger et les vérifier. Cela signifie que tout comportement malhonnête de la part du séquenceur de rollup peut être identifié et contesté par le démonstrateur. Cependant, ces données n'ont pas besoin d'être disponibles indéfiniment.
 </ExpandableCard>
 
-<ExpandableCard title="Pourquoi est-il acceptable de supprimer les données des blobs ?" eventCategory="/roadmap/danksharding" eventName="clicked why is it OK to delete the blob data?">
+<ExpandableCard title="Pourquoi peut-on supprimer les données de blob ?" eventCategory="/roadmap/danksharding" eventName="clicked why is it OK to delete the blob data?">
 
 Les rollups publient des engagements liés à leurs données de transaction en chaîne et rendent également les données réelles accessibles sous forme de « blobs » de données. Cela signifie que les démonstrateurs peuvent vérifier la validité des engagements ou contester les données qu'ils estiment incorrectes. Au niveau des nœuds, les « blobs » de données sont stockés dans le client de consensus. Les clients de consensus attestent qu'ils ont vu les données et qu'elles se sont propagées sur le réseau. Si les données étaient conservées indéfiniment, ces clients deviendraient trop encombrés et cela augmenterait les besoins matériels pour faire fonctionner les nœuds. Au lieu de cela, les données sont automatiquement supprimées du nœud tous les 18 jours. Les attestations des clients de consensus démontrent qu'il y a eu suffisamment de possibilités pour que les démonstrateurs vérifient les données. Les données réelles peuvent être stockées en dehors de la blockchain par les opérateurs de rollup, les utilisateurs ou d'autres parties.
-
 </ExpandableCard>
 
 ### Comment les données des blobs sont-elles vérifiées ? {#how-are-blobs-verified}
 
-Les rollups publient les transactions qu'ils exécutent dans des blobs de données. Ils publient également un « engagement » envers ces données. Ils font cela en appliquant une fonction polynomiale aux données. Cette fonction peut ensuite être évaluée à différents points. Par exemple, si nous définissons une fonction extrêmement simple `f(x) = 2x-1`, alors nous pouvons évaluer cette fonction pour `x = 1`, `x = 2`, `x = 3`, ce qui donne les résultats `1, 3, 5`. Un démonstrateur applique la même fonction aux données et l'évalue aux mêmes points. Si les données d'origine sont modifiées, la fonction ne sera pas identique, et par conséquent, les valeurs évaluées à chaque point ne le seront pas non plus. En réalité, l'engagement et la preuve sont plus complexes car ils contiennent une couche de fonctions cryptographiques.
+Les rollups publient les transactions qu'ils exécutent dans des blobs de données. Ils publient également un « engagement » envers ces données. Ils font cela en appliquant une fonction polynomiale aux données. Cette fonction peut ensuite être évaluée à différents points. Par exemple, si nous définissons une fonction extrêmement simple `f(x) = 2x-1`, nous pouvons alors évaluer cette fonction pour `x = 1`, `x = 2`, `x = 3`, ce qui donne les résultats `1, 3, 5`. Un démonstrateur applique la même fonction aux données et l'évalue aux mêmes points. Si les données d'origine sont modifiées, la fonction ne sera pas identique, et par conséquent, les valeurs évaluées à chaque point ne le seront pas non plus. En réalité, l'engagement et la preuve sont plus complexes car ils contiennent une couche de fonctions cryptographiques.
 
 ### Qu'est-ce que KZG ? {#what-is-kzg}
 
-KZG signifie Kate-Zaverucha-Goldberg - les noms des trois [auteurs originaux](https://link.springer.com/chapter/10.1007/978-3-642-17373-8_11) d'un schéma qui réduit un blob de données à un petit [« engagement » cryptographique](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html). Le blob de données soumis par un rollup doit être vérifié pour s'assurer que le rollup ne se comporte pas de manière incorrecte. Cela implique qu'un démonstrateur exécute à nouveau les transactions dans le blob pour vérifier que l'engagement était valide. Conceptuellement, cela correspond à la manière dont les clients d'exécution vérifient la validité des transactions Ethereum sur la couche principale à l'aide de preuves de Merkle. KZG est une preuve alternative qui applique une équation polynomiale aux données. L'engagement évalue le polynôme à des points de données tenus secrets. Un démonstrateur applique le même polynôme aux données et l'évalue aux mêmes valeurs, vérifiant que le résultat est bien identique. C'est une manière de vérifier que les données sont compatibles avec les techniques de zero-knowledge (Zk) utilisées par certains rollups et éventuellement d'autres parties du protocole Ethereum.
+KZG est l'acronyme de Kate-Zaverucha-Goldberg – les noms des trois [auteurs originaux](https://link.springer.com/chapter/10.1007/978-3-642-17373-8_11) d'un schéma qui réduit un blob de données à un petit [« engagement » cryptographique](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html). Le blob de données soumis par un rollup doit être vérifié pour s'assurer que le rollup ne se comporte pas de manière incorrecte. Cela implique qu'un démonstrateur exécute à nouveau les transactions dans le blob pour vérifier que l'engagement était valide. Conceptuellement, cela correspond à la manière dont les clients d'exécution vérifient la validité des transactions Ethereum sur la couche principale à l'aide de preuves de Merkle. KZG est une preuve alternative qui applique une équation polynomiale aux données. L'engagement évalue le polynôme à des points de données tenus secrets. Un démonstrateur applique le même polynôme aux données et l'évalue aux mêmes valeurs, vérifiant que le résultat est bien identique. C'est une manière de vérifier que les données sont compatibles avec les techniques de zero-knowledge (Zk) utilisées par certains rollups et éventuellement d'autres parties du protocole Ethereum.
 
 ### Qu'est-ce que la cérémonie KZG ? {#what-is-a-kzg-ceremony}
 
-La cérémonie KZG était un moyen pour de nombreuses personnes à travers la communauté Ethereum de collectivement générer une suite secrète aléatoire de nombres qui peuvent être utilisés pour vérifier certaines données. Il est très important que cette suite de nombres ne soit pas connue et ne puisse pas être recréée par qui que ce soit. Pour garantir cela, chaque personne qui participait à la cérémonie recevait une chaine de caractère provenant du participant précédent. Ensuite, ils créent de nouvelles valeurs aléatoires (par exemple, en mesurant les mouvements de leur souris par leur navigateur) et les mélangent avec la valeur de la chaîne précédente. Ils envoyaient ensuite la valeur au participant suivant et la détruisaient de leur machine locale. Tant qu’une personne présente à la cérémonie a fait cela honnêtement, la valeur finale sera inconnue d’un attaquant.
+La cérémonie KZG était un moyen pour de nombreuses personnes à travers la communauté Ethereum de collectivement générer une suite secrète aléatoire de nombres qui peuvent être utilisés pour vérifier certaines données. Il est très important que cette suite de nombres ne soit pas connue et ne puisse pas être recréée par qui que ce soit. Pour garantir cela, chaque personne qui participait à la cérémonie recevait une chaine de caractère provenant du participant précédent. Ils créent ensuite de nouvelles valeurs aléatoires (p. ex., en autorisant leur navigateur à mesurer le mouvement de leur souris) et les mélangent à la valeur précédente. Ils envoyaient ensuite la valeur au participant suivant et la détruisaient de leur machine locale. Tant qu’une personne présente à la cérémonie a fait cela honnêtement, la valeur finale sera inconnue d’un attaquant.
 
 La cérémonie KZG de l'EIP-4844 était ouverte au public et des dizaines de milliers de personnes y ont participé pour ajouter leur propre entropie (aléatoire). Au total, elle compta plus de 140 000 contributions, faisant d'elle la plus large cérémonie de ce type dans le monde. Pour que la cérémonie soit compromise, il aurait fallu que 100 % de ses participants soient volontairement malhonnêtes. Du point de vue des participants, s'ils savent qu'ils ont agi honnêtement, il n'est pas nécessaire de faire confiance à quelqu'un d'autre car ils savent qu'ils ont sécurisé la cérémonie (ils ont individuellement satisfait à l'exigence d'au moins 1 participant honnête parmi N).
 
 <ExpandableCard title="À quoi sert le nombre aléatoire de la cérémonie KZG ?" eventCategory="/roadmap/danksharding" eventName="clicked why is the random number from the KZG ceremony used for?">
 
 Quand un rollup publie des données dans un blob, il fournit un « engagement » qu'il publie sur la chaine. Cet engagement est le résultat de l'évaluation d'une fonction polynomiale appliquée aux données à certains points. Ces points sont définis par les nombres aléatoires générés lors de la cérémonie KZG. Les démonstrateurs peuvent ensuite évaluer le polynôme aux mêmes points afin de vérifier les données - si les valeurs sont identiques, alors les données sont correctes.
-
 </ExpandableCard>
 
-<ExpandableCard title="Pourquoi les valeurs aléatoires KZG doivent-elles rester secrètes ?" eventCategory="/roadmap/danksharding" eventName="clicked why does the KZG random data have to stay secret?">
-
-Si quelqu'un connaissait les points aléatoires utilisés pour l'engagement, il pourrait facilement générer un nouveau polynôme qui s'adapterait à ces points spécifiques (c'est-à-dire une « collision »). Cela signifie qu'il pourrait ajouter ou supprimer des données du « blob » tout en fournissant une preuve valide. Pour empêcher cela, au lieu de donner directement aux démonstrateurs les emplacements des points secrets , ils reçoivent en réalité les emplacements masqués dans une « boîte noire » cryptée à l'aide de courbes elliptiques. Cela brouille les valeurs de telle manière que les valeurs originales ne peuvent pas être déchiffrées, mais avec un peu d'algèbre, les démonstrateurs et les vérificateurs peuvent toujours évaluer les polynômes aux points qu'ils représentent.
+<ExpandableCard title="Pourquoi les données aléatoires KZG doivent-elles rester secrètes ?" eventCategory="/roadmap/danksharding" eventName="clicked why does the KZG random data have to stay secret?">
 
+Si quelqu'un connaît les emplacements aléatoires utilisés pour l'engagement, il peut facilement générer un nouveau polynôme qui correspond à ces points spécifiques (c'est-à-dire une « collision »). Cela signifie qu'il pourrait ajouter ou supprimer des données du « blob » tout en fournissant une preuve valide. Pour empêcher cela, au lieu de donner directement aux démonstrateurs les emplacements des points secrets , ils reçoivent en réalité les emplacements masqués dans une « boîte noire » cryptée à l'aide de courbes elliptiques. Cela brouille les valeurs de telle manière que les valeurs originales ne peuvent pas être déchiffrées, mais avec un peu d'algèbre, les démonstrateurs et les vérificateurs peuvent toujours évaluer les polynômes aux points qu'ils représentent.
 </ExpandableCard>
 
 <Alert variant="warning" className="mb-8">
@@ -67,29 +63,27 @@ Le Danksharding est la réalisation complète du passage à l'échelle des rollu
 
 Cela fonctionne en étendant le nombre de blobs attachés aux blocs de six (6) dans le Proto-Danksharding, à 64 dans le Danksharding complet. Le reste des changements requis concerne des mises à jour du fonctionnement des clients de consensus pour leur permettre de gérer les nouveaux blobs de grande taille. Plusieurs de ces modifications sont déjà prévues dans la feuille de route à d'autres fins, indépendamment du Danksharding. Par exemple, le Danksharding nécessite la mise en œuvre de la séparation entre le validateur et le constructeur de blocs. Il s'agit d'une mise à jour qui sépare les tâches de construction de blocs et de proposition de blocs entre différents validateurs. De même, l'échantillonnage de la disponibilité des données est requis pour le Danksharding, mais il est également nécessaire pour le développement de clients plus légers qui ne stockent pas toutes les données historiques (clients « sans état »).
 
-<ExpandableCard title="Pourquoi le Danksharding nécessite-t-il la séparation entre les validateurs et les constructeurs de blocs ?" eventCategory="/roadmap/danksharding" eventName="clicked why does danksharding require proposer-builder separation?">
+<ExpandableCard title="Pourquoi le Danksharding nécessite-t-il la séparation proposant-constructeur ?" eventCategory="/roadmap/danksharding" eventName="clicked why does danksharding require proposer-builder separation?">
 
 La séparation entre les validateurs et les constructeurs de blocs est nécessaire pour éviter que chaque validateur ait à générer des engagements trop volumineux et des preuves pour 32 Mo de données de blobs. Cela mettrait trop de pression sur les validateurs à domicile et les obligerait à investir dans du matériel plus puissant, ce qui nuirait à la décentralisation. Au lieu de cela, des constructeurs de blocs spécialisés prennent en charge ce travail de calcul coûteux. Ensuite, ils mettent leurs blocs à disposition des proposeurs pour qu'ils les diffusent. Le proposeur de bloc choisit simplement le bloc le plus rentable. Tout le monde peut vérifier les blobs de manière simple et rapide, ce qui signifie que n'importe quel validateur normal peut vérifier si les constructeurs de blocs se comportent honnêtement. Cela permet de traiter les blobs de grande taille sans sacrifier la décentralisation. Les constructeurs de blocs qui se comportent mal pourraient simplement être expulsés du réseau et sanctionnés - d'autres prendront leur place car la construction de blocs est une activité profitable.
-
 </ExpandableCard>
 
-<ExpandableCard title="Pourquoi le Danksharding nécessite-t-il un échantillonnage de disponibilité des données ?" eventCategory="/roadmap/danksharding" eventName="clicked why does danksharding require data availability sampling?">
+<ExpandableCard title="Pourquoi le Danksharding nécessite-t-il l'échantillonnage de la disponibilité des données ?" eventCategory="/roadmap/danksharding" eventName="clicked why does danksharding require data availability sampling?">
 
 L'échantillonnage de la disponibilité des données est nécessaire pour que les validateurs puissent vérifier rapidement et efficacement les données de blobs. En utilisant l'échantillonnage de la disponibilité des données, les validateurs peuvent être tout à fait certains que les données de blobs étaient disponibles et que les engagements étaient corrects. Chaque validateur peut échantillonner au hasard quelques points de données et en créer une preuve, ce qui signifie qu'aucun validateur n'a à vérifier l'intégralité du blob. Si des données sont manquantes, elles seront rapidement identifiées et le blob sera rejeté.
-
 </ExpandableCard>
 
 ### Progrès actuels {#current-progress}
 
-L'implémentation complète du Danksharding prendra encore plusieurs années. Dans ce temps, la cérémonie KZG s'est conclu avec plus de 140 000 contributions, et l'[EIP](https://eips.ethereum.org/EIPS/eip-4844) pour le Proto-Danksharding à mûri. Cette proposition a été totalement implémentée dans tous les réseaux de tests, et a rejoint le réseau principal avec la mise à niveau du réseau Cancun-Deneb (« Dencun ») en mars 2024.
+L'implémentation complète du Danksharding prendra encore plusieurs années. Entre-temps, la cérémonie KZG s'est conclue avec plus de 140 000 contributions, et l'[EIP](https://eips.ethereum.org/EIPS/eip-4844) pour le Proto-Danksharding est arrivé à maturité. Cette proposition a été totalement implémentée dans tous les réseaux de tests, et a rejoint le réseau principal avec la mise à niveau du réseau Cancun-Deneb (« Dencun ») en mars 2024.
 
-### Complément d'information {#further-reading}
+### En savoir plus {#further-reading}
 
 - [Notes sur le Proto-Danksharding](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq) - _Vitalik Buterin_
 - [Notes de Dankrad sur le Danksharding](https://notes.ethereum.org/@dankrad/new_sharding)
-- [Discussion de Dankrad, Proto et Vitalik sur le Danksharding](https://www.youtube.com/watch?v=N5p0TB77flM)
+- [Dankrad, Proto et Vitalik discutent du Danksharding](https://www.youtube.com/watch?v=N5p0TB77flM)
 - [La cérémonie KZG](https://ceremony.ethereum.org/)
-- [Conférence de Carl Beekhuizen à la Devcon sur les configurations de confiance](https://archive.devcon.org/archive/watch/6/the-kzg-ceremony-or-how-i-learnt-to-stop-worrying-and-love-trusted-setups/?tab=YouTube)
-- [Plus d'informations sur l'échantillonnage de disponibilité des données pour les blobs](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling)
+- [Présentation de Carl Beekhuizen à la Devcon sur les configurations de confiance](https://archive.devcon.org/archive/watch/6/the-kzg-ceremony-or-how-i-learnt-to-stop-worrying-and-love-trusted-setups/?tab=YouTube)
+- [En savoir plus sur l'échantillonnage de disponibilité des données pour les blobs](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling)
 - [Dankrad Feist sur les engagements et les preuves KZG](https://youtu.be/8L2C6RDMV9Q)
 - [Engagements polynomiaux KZG](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html)
diff --git a/public/content/translations/fr/roadmap/dencun/index.md b/public/content/translations/fr/roadmap/dencun/index.md
index 9e45a69b7de..a9628c1c3c1 100644
--- a/public/content/translations/fr/roadmap/dencun/index.md
+++ b/public/content/translations/fr/roadmap/dencun/index.md
@@ -1,6 +1,6 @@
 ---
-title: FAQ Cancun-Deneb ("Dencun")
-description: Questions fréquemment posées concernant la mise à jour réseau Cancun-Deneb (Dencun)
+title: FAQ Cancun-Deneb (Dencun)
+description: "Questions fréquemment posées concernant la mise à jour réseau Cancun-Deneb (Dencun)"
 lang: fr
 ---
 
@@ -68,9 +68,9 @@ Oui, le Proto-Danksharding (EIP-4844) nécessite des mises à jour à la fois de
 
 Les clients de consensus gèrent le logiciel du _Validateur_, qui a été entièrement mis à jour pour intégrer la mise à niveau.
 
-## Comment Cancun-Deneb (Dencun) affecte-t-il Goerli ou d'autres réseaux de test d'Ethereum ? {#testnet-impact}
+## Comment Cancun-Deneb (Dencun) affecte-t-il les réseaux de test d'Ethereum ? {#testnet-impact}
 
-- Devnets, Goerli, Sepolia et Holesky ont tous reçu la mise à jour Dencun et disposent d'un Proto-Danksharding pleinement opérationnel
+- Devnets, Sepolia et Holesky ont tous reçu la mise à jour Dencun et disposent d'un Proto-Danksharding pleinement opérationnel
 - Les développeurs de rollups peuvent utiliser ces réseaux pour tester l'EIP-4844
 - La plupart des utilisateurs ne seront absolument pas affectés par le changement apporté sur chaque réseau de test
 
diff --git a/public/content/translations/fr/roadmap/fusaka/index.md b/public/content/translations/fr/roadmap/fusaka/index.md
new file mode 100644
index 00000000000..cb5d2c0cd7c
--- /dev/null
+++ b/public/content/translations/fr/roadmap/fusaka/index.md
@@ -0,0 +1,300 @@
+---
+title: Fulu-Osaka (Fusaka)
+description: "En savoir plus sur la mise à niveau du protocole Fusaka"
+lang: fr
+---
+
+# Fusaka <Emoji text="🦓" /> {#fusaka}
+
+**La mise à niveau très attendue Fusaka d'Ethereum a été mise en service le 3 décembre 2025**
+
+La mise à niveau du réseau Fusaka suit [Pectra](/roadmap/pectra/) et apporte plus de nouvelles fonctionnalités et améliore l'expérience de chaque utilisateur et développeur Ethereum. Le nom se compose de la mise à niveau de la couche d'exécution Osaka et de la version de la couche de consensus nommée d'après l'étoile Fulu. Les deux parties d'Ethereum reçoivent une mise à niveau qui repousse la mise à l'échelle, la sécurité et l'expérience utilisateur d'Ethereum vers le futur.
+
+<Alert variant="update">
+<AlertContent>
+<AlertDescription>
+La mise à niveau de Fusaka n'est qu'une seule étape dans les objectifs de développement à long terme d'Ethereum. Apprenez-en plus sur [la feuille de route du protocole](/roadmap/) et les [mises à niveau précédentes](/ethereum-forks/).
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Améliorations dans Fusaka {#improvements-in-fusaka}
+
+### Mise à l'échelle des blobs {#scale-blobs}
+
+#### PeerDAS {#peerdas}
+
+Il s'agit de la _tête d'affiche_ de la fourche Fusaka, la principale fonctionnalité ajoutée dans cette mise à niveau. Les couches 2 publient actuellement leurs données sur Ethereum sous forme de blobs, le type de données éphémères créé spécifiquement pour les couches 2. Avant Fusaka, chaque nœud complet devait stocker chaque blob pour garantir l'existence des données. À mesure que le débit des blobs augmente, le téléchargement de toutes ces données devient extrêmement gourmand en ressources.
+
+Avec [l'échantillonnage de disponibilité des données](https://notes.ethereum.org/@fradamt/das-fork-choice), au lieu de devoir stocker toutes les données blob, chaque nœud sera responsable d'un sous-ensemble des données blob. Les blobs sont répartis uniformément de manière aléatoire sur les nœuds du réseau, chaque nœud complet ne contenant que 1/8 des données, permettant ainsi une mise à l'échelle théorique jusqu'à 8x. Pour garantir la disponibilité des données, n'importe quelle partie des données peut être reconstruite à partir de 50 % existants de l'ensemble avec des méthodes qui réduisent la probabilité de données erronées ou manquantes à un niveau cryptographiquement négligeable (~ un sur 10<sup>20</sup> à un sur 10<sup>24</sup>).
+
+Cela permet de maintenir les exigences matérielles et de bande passante des nœuds à un niveau tenable tout en permettant la mise à l'échelle des blobs, ce qui se traduit par une plus grande évolutivité avec des frais moins élevés pour les couches 2.
+
+[En savoir plus sur PeerDAS](/roadmap/fusaka/peerdas/)
+
+**Ressources** :
+
+- [Spécification technique de l'EIP-7594](https://eips.ethereum.org/EIPS/eip-7594)
+- [DappLion sur PeerDAS : Mise à l'échelle d'Ethereum aujourd'hui | ETHSofia 2024](https://youtu.be/bONWd1x2TjQ?t=328)
+- [Article universitaire : une documentation sur PeerDAS d'Ethereum (PDF)](https://eprint.iacr.org/2024/1362.pdf)
+
+#### Forks à paramètre blob uniquement {#blob-parameter-only-forks}
+
+Les couches 2 font évoluer Ethereum : à mesure que leurs réseaux se développent, ils doivent publier davantage de données sur Ethereum. Cela signifie qu'Ethereum devra augmenter le nombre de blobs à sa disposition au fil du temps. Bien que PeerDAS permette la mise à l'échelle des données blob, cette opération doit être effectuée progressivement et en toute sécurité.
+
+Étant donné qu’Ethereum est un code exécuté sur des milliers de nœuds indépendants qui nécessitent un accord sur les mêmes règles, nous ne pouvons pas simplement introduire des changements comme l’augmentation du nombre de blobs de la même manière que vous déployez une mise à jour de site Web. Tout changement de règle doit être une mise à niveau coordonnée où chaque nœud, client et logiciel de validation est mis à niveau avant le même bloc prédéterminé.
+
+Ces mises à niveau coordonnées incluent généralement de nombreux changements, nécessitent de nombreux tests et prennent du temps. Afin de s'adapter plus rapidement aux besoins changeants des blobs de couche 2, les forks blob parameter only introduisent un mécanisme permettant d'augmenter les blobs sans avoir à attendre ce calendrier de mise à niveau.
+
+Les forks blob parameter only peuvent être définis par les clients, de la même manière que d'autres configurations telles que la limite de gaz. Entre les mises à niveau majeures d'Ethereum, les clients peuvent convenir d'augmenter les blobs « target » et « max » à par exemple 9 et 12, puis les opérateurs de nœuds se mettront à jour pour participer à cette petite fourche. Ces forks blob parameter only peuvent être configurés à tout moment.
+
+Lorsque les blobs ont été ajoutés pour la première fois au réseau dans la mise à niveau Dencun, l'objectif était de 3. Ce chiffre est passé à 6 dans Pectra et, après Fusaka, il peut maintenant être augmenté à un rythme durable, indépendamment de ces mises à niveau majeures du réseau.
+
+![Graphique montrant le nombre moyen de blobs par bloc et l'augmentation des cibles avec les mises à niveau](./average-blob-count-per-block.webp)
+
+Source du graphique : [Ethereum Blobs - @hildobby, Dune Analytics](https://dune.com/hildobby/blobs)
+
+**Ressources** : [Spécification technique de l'EIP-7892](https://eips.ethereum.org/EIPS/eip-7892)
+
+#### Frais de base du blob limités par les coûts d'exécution {#blob-base-fee-bounded-by-execution-costs}
+
+Les couches 2 paient deux factures lorsqu'elles publient des données : les frais de blob et le gaz d'exécution nécessaire pour vérifier ces blobs. Si le gaz d'exécution domine, les frais d'enchères de blob peuvent chuter jusqu'à 1 wei et cesser d'être un signal de prix.
+
+L'EIP-7918 fixe un prix de réserve proportionnel sous chaque blob. Lorsque la réserve est supérieure aux frais de base nominaux du blob, l'algorithme d'ajustement des frais traite le bloc comme dépassant l'objectif, arrête de faire baisser les frais et leur permet d'augmenter normalement. De ce fait :
+
+- le marché des frais de blob réagit toujours à la congestion
+- les couches 2 paient au moins une part significative du calcul qu'elles imposent aux nœuds
+- les pics de frais de base sur l'EL ne peuvent plus bloquer les frais de blob à 1 wei
+
+**Ressources** :
+
+- [Spécification technique de l'EIP-7918](https://eips.ethereum.org/EIPS/eip-7918)
+- [Explication du Storybook](https://notes.ethereum.org/@anderselowsson/AIG)
+
+### Mise à l'échelle de la L1 {#scale-l1}
+
+#### Expiration de l'historique et reçus simplifiés {#history-expiry}
+
+En juillet 2025, les clients d'exécution d'Ethereum [ont commencé à prendre en charge l'expiration partielle de l'historique](https://blog.ethereum.org/2025/07/08/partial-history-exp). Cela a permis de supprimer l'historique antérieur à [La Fusion](https://ethereum.org/roadmap/merge/) afin de réduire l'espace disque requis par les opérateurs de nœuds à mesure qu'Ethereum continue de se développer.
+
+Cet EIP se trouve dans une section distincte des \ En pratique, les clients peuvent implémenter cela à tout moment, mais l'ajouter à la mise à niveau l'a concrètement inscrit sur leur liste de tâches et leur a permis de tester les changements de Fusaka en conjonction avec cette fonctionnalité.
+
+**Ressources** : [Spécification technique de l'EIP-7642](https://eips.ethereum.org/EIPS/eip-7642)
+
+#### Définir des limites supérieures pour MODEXP {#set-upper-bounds-for-modexp}
+
+Jusqu'à présent, la précompilation MODEXP acceptait des nombres de pratiquement toutes les tailles. Cela rendait les tests difficiles, les abus faciles et risqués pour la stabilité du client. L'EIP-7823 impose une limite claire : chaque numéro d'entrée peut avoir une longueur maximale de 8192 bits (1024 octets). Tout ce qui est plus grand est rejeté, le gaz de la transaction est brûlé et aucun changement d’état ne se produit. Il couvre très confortablement les besoins du monde réel tout en supprimant les cas extrêmes qui compliquent la planification des limites de gaz et les examens de sécurité. Ce changement offre davantage de sécurité et de protection DoS sans affecter l’expérience de l’utilisateur ou du développeur.
+
+**Ressources** : [Spécification technique de l'EIP-7823](https://eips.ethereum.org/EIPS/eip-7823)
+
+#### Plafond de limite de gaz de transaction {#transaction-gas-limit-cap}
+
+EIP-[7825](https://eips.ethereum.org/EIPS/eip-7825) ajoute un plafond de 16 777 216 (2^24) gaz par transaction. Il s’agit d’un renforcement proactif du DoS en limitant le coût du pire des cas de chaque transaction unique à mesure que nous augmentons la limite de gaz du bloc. Cela facilite la validation et la propagation à modéliser pour nous permettre d'aborder la mise à l'échelle en augmentant la limite de gaz.
+
+Pourquoi exactement 2^24 gaz ? Il est confortablement plus petit que la limite de gaz actuelle, est suffisamment grand pour les déploiements de contrats réels et les précompilations lourdes, et une puissance de 2 le rend facile à mettre en œuvre sur tous les clients. Cette nouvelle taille maximale de transaction est similaire à la taille moyenne des blocs avant Pectra, ce qui en fait une limite raisonnable pour toute opération sur Ethereum.
+
+**Ressources** : [Spécification technique de l'EIP-7825](https://eips.ethereum.org/EIPS/eip-7825)
+
+#### Augmentation du coût en gaz de `MODEXP` {#modexp-gas-cost-increase}
+
+MODEXP est une fonction intégrée de précompilation qui calcule l'exponentiation modulaire, un type de calcul mathématique à grands nombres utilisé dans les systèmes de vérification et de preuve de signature RSA. Il permet aux contrats d’exécuter ces calculs directement sans avoir à les mettre en œuvre eux-mêmes.
+
+Les développeurs et les équipes clientes ont identifié MODEXP comme un obstacle majeur à l’augmentation de la limite de gaz du bloc, car le prix actuel du gaz sous-estime souvent la puissance de calcul requise par certaines entrées. Cela signifie qu'une transaction utilisant MODEXP pourrait prendre la majeure partie du temps nécessaire au traitement d'un bloc entier, ce qui ralentit le réseau.
+
+Cet EIP modifie la tarification pour correspondre aux coûts de calcul réels en :
+
+- augmentant le tarif minimum de 200 à 500 gaz et en supprimant la réduction d'un tiers de l'EIP-2565 sur le calcul des coûts généraux
+- augmentant le coût plus fortement lorsque l'exposant d'entrée est très long. si l'exposant (le nombre « puissance » que vous passez comme deuxième argument) est plus long que 32 octets / 256 bits, la charge de gaz augmente beaucoup plus rapidement pour chaque octet supplémentaire
+- charge de base large ou de module supplémentaire également. Les deux autres nombres (la base et le module) sont supposés avoir au moins 32 octets - si l'un d'eux est plus grand, le coût augmente proportionnellement à sa taille
+
+En faisant mieux correspondre les coûts au temps de traitement réel, MODEXP ne peut plus faire en sorte qu'un bloc prenne trop de temps à valider. Ce changement est l’un des nombreux changements visant à garantir l’augmentation en toute sécurité de la limite de gaz des blocs d’Ethereum à l’avenir.
+
+**Ressources** : [Spécification technique de l'EIP-7883](https://eips.ethereum.org/EIPS/eip-7883)
+
+#### Limite de taille des blocs d'exécution RLP {#rlp-execution-block-size-limit}
+
+Cela crée un plafond sur la taille maximale autorisée d'un bloc. Il s'agit d'une limite sur ce qui est _envoyé_ sur le réseau et est distincte de la limite de gaz, qui limite le _travail_ à l'intérieur d'un bloc. La taille maximale d'un bloc est de 10 Mio, avec une petite marge (2 Mio) réservée aux données de consensus pour que tout s'intègre et se propage correctement. Si un bloc est plus gros que cela, les clients le rejettent.
+Ceci est nécessaire car les blocs très volumineux prennent plus de temps à se propager et à être vérifiés sur le réseau, et peuvent créer des problèmes de consensus ou être utilisés comme un vecteur d'attaque DoS. De plus, le gossip de la couche de consensus ne transmet déjà pas les blocs de plus de ~10 Mio, donc l'alignement de la couche d'exécution sur cette limite évite les situations étranges où ils sont \
+
+Les détails techniques : il s'agit d'un plafond sur la taille de bloc d'exécution encodée en [RLP](/developers/docs/data-structures-and-encoding/rlp/). 10 Mio au total, avec une marge de sécurité de 2 Mio réservée pour l'encadrement du bloc de balise. En pratique, les clients définissent
+
+`MAX_BLOCK_SIZE = 10,485,760` octets et
+
+`SAFETY_MARGIN = 2,097,152` octets,
+
+et rejettent tout bloc d'exécution dont la charge utile RLP dépasse
+
+`MAX_RLP_BLOCK_SIZE = MAX_BLOCK_SIZE − SAFETY_MARGIN`
+
+L'objectif est de limiter le temps de propagation/validation dans le pire des cas et de s'aligner sur le comportement du gossip de la couche de consensus, réduisant ainsi le risque de réorganisation/DoS sans modifier la comptabilité du gaz.
+
+**Ressources** : [Spécification technique de l'EIP-7934](https://eips.ethereum.org/EIPS/eip-7934)
+
+#### Définir la limite de gaz par défaut à 60 millions {#set-default-gas-limit-to-60-million}
+
+Avant d’augmenter la limite de gaz de 30 M à 36 M en février 2025 (puis à 45 M), cette valeur n’avait pas changé depuis la Fusion (septembre 2022). Ce EIP vise à faire de la mise à l’échelle cohérente une priorité.
+
+L'EIP-7935 coordonne les équipes clientes d'EL pour augmenter la limite de gaz par défaut au-dessus des 45 M actuels pour Fusaka. Il s’agit d’un EIP informatif, mais il demande explicitement aux clients de tester des limites plus élevées sur les devnets, de converger vers une valeur sûre et d’envoyer ce nombre dans leurs versions Fusaka.
+
+La planification Devnet cible environ 60 M de stress (blocs complets avec charge synthétique) et des structures itératives ; la recherche indique que les pathologies de taille de bloc du pire des cas ne devraient pas se lier en dessous d'environ 150 M. Le déploiement doit être associé au plafond de limite de gaz de transaction (EIP-7825) afin qu'aucune transaction unique ne puisse dominer lorsque les limites augmentent.
+
+**Ressources** : [Spécification technique de l'EIP-7935](https://eips.ethereum.org/EIPS/eip-7935)
+
+### Améliorer l'UX {#improve-ux}
+
+#### Anticipation de proposant déterministe {#deterministic-proposer-lookahead}
+
+Avec EIP-7917, la chaine Beacon sera informée des prochains proposants de blocs pour la prochaine période. Avoir une vision déterministe sur les validateurs qui proposeront les futurs blocs peut permettre des [préconfirmations](https://ethresear.ch/t/based-preconfirmations/17353) - un engagement avec le futur proposant qui garantit que la transaction de l'utilisateur sera incluse dans son bloc sans attendre le bloc réel.
+
+Cette fonctionnalité profite aux implémentations client et à la sécurité du réseau car elle empêche les cas extrêmes dans lesquels les validateurs pourraient manipuler le calendrier du proposant. L'anticipation permet également une mise en œuvre moins complexe.
+
+**Ressources** : [Spécification technique de l'EIP-7917](https://eips.ethereum.org/EIPS/eip-7917)
+
+#### Code d'opération de comptage des zéros non significatifs (CLZ) {#count-leading-zeros-opcode}
+
+Cette fonctionnalité ajoute une petite instruction EVM, **compter les zéros non significatifs (CLZ)**. Presque tout dans l'EVM est représenté par une valeur de 256 bits — ce nouvel opcode renvoie le nombre de bits nuls au début. Il s’agit d’une fonctionnalité commune à de nombreuses architectures de jeux d’instructions car elle permet des opérations arithmétiques plus efficaces. En pratique, cela réduit les analyses de bits manuelles actuelles en une seule étape, de sorte que la recherche du premier bit défini, l'analyse des octets ou l'analyse des champs de bits deviennent plus simples et moins coûteuses. L'opcode est faible, à coût fixe et a été évalué comme étant comparable à un ajout de base, qui réduit le bytecode et économise du gaz pour le même travail.
+
+**Ressources** : [Spécification technique de l'EIP-7939](https://eips.ethereum.org/EIPS/eip-7939)
+
+#### Précompilation pour la prise en charge de la courbe secp256r1 {#secp256r1-precompile}
+
+Introduit un vérificateur de signature secp256r1 (P-256) de type passkey intégré à l'adresse fixe `0x100` en utilisant le même format d'appel déjà adopté par de nombreuses L2 et en corrigeant les cas limites, de sorte que les contrats écrits pour ces environnements fonctionnent sur L1 sans modifications.
+
+Mise à niveau de l'UX ! Pour les utilisateurs, cela débloque la signature native de l'appareil et les passkeys. Les portefeuilles peuvent exploiter directement Apple Secure Enclave, Android Keystore, les modules de sécurité matériels (HSM) et FIDO2/WebAuthn - pas de phrase de récupération, une intégration plus fluide et des flux multi-facteurs qui ressemblent aux applications modernes. Cela se traduit par une meilleure UX, une récupération plus facile et des modèles d'abstraction de compte qui correspondent à ce que des milliards d'appareils font déjà.
+
+Pour les développeurs, il prend une entrée de 160 octets et renvoie une sortie de 32 octets, ce qui facilite le portage des bibliothèques existantes et des contrats L2. Sous le capot, il inclut des vérifications de point à l'infini et de comparaison modulaire pour éliminer les cas limites délicats sans casser les appelants valides.
+
+**Ressources** :
+
+- [Spécification technique de l'EIP-7951](https://eips.ethereum.org/EIPS/eip-7951)
+- [En savoir plus sur le RIP-7212](https://www.alchemy.com/blog/what-is-rip-7212) _(Notez que l'EIP-7951 a remplacé le RIP-7212)_
+
+### Méta {#meta}
+
+#### Méthode JSON-RPC `eth_config` {#eth-config}
+
+Il s'agit d'un appel JSON-RPC qui vous permet de demander à votre nœud quels paramètres de fourche vous utilisez. Il renvoie trois instantanés : `current`, `next` et `last` afin que les validateurs et les outils de surveillance puissent vérifier que les clients sont alignés pour une fourche à venir.
+
+En pratique, il s'agit de remédier à une lacune découverte lorsque la fourche Pectra a été mise en service sur le testnet Holesky au début de 2025 avec des erreurs de configuration mineures qui ont entraîné un état de non-finalisation. Cela aide les équipes de test et les développeurs à s'assurer que les fourches majeures se comporteront comme prévu lors du passage des devnets aux testnets, et des testnets au Mainnet.
+
+Les instantanés incluent : `chainId`, `forkId`, l'heure d'activation de la fourche prévue, les précompilations actives, les adresses de précompilation, les dépendances des contrats système et le calendrier des blobs de la fourche.
+
+Cet EIP se trouve dans une section distincte des \
+
+**Ressources** : [Spécification technique de l'EIP-7910](https://eips.ethereum.org/EIPS/eip-7910)
+
+## FAQ {#faq}
+
+### Cette mise à niveau affecte-t-elle tous les nœuds et validateurs Ethereum ? {#does-this-upgrade-affect-all-ethereum-nodes-and-validators}
+
+Oui, la mise à niveau de Fusaka nécessite des mises à jour des [clients d'exécution et des clients de consensus](/developers/docs/nodes-and-clients/). Tous les principaux clients Ethereum publieront des versions prenant en charge la hard fork, marquées comme hautement prioritaires. Vous pouvez vous tenir au courant de la date de disponibilité de ces versions dans les dépôts Github des clients, leurs [canaux Discord](https://ethstaker.org/support), le [Discord EthStaker](https://dsc.gg/ethstaker), ou en vous abonnant au blog Ethereum pour les mises à jour du protocole. Pour maintenir la synchronisation avec le réseau Ethereum après la mise à jour, les opérateurs de nœuds doivent s'assurer qu'ils utilisent une version de client prise en charge. Notez que les informations concernant les versions des clients sont tributaires du temps, et les utilisateurs doivent se référer aux dernières mises à jour pour obtenir les derniers détails.
+
+### Comment ETH peut-il être converti après la fourche majeure ? {#how-can-eth-be-converted-after-the-hardfork}
+
+- **Aucune action requise pour votre ETH** : Suite à la mise à niveau d'Ethereum Fusaka, il n'est pas nécessaire de convertir ou de mettre à niveau votre ETH. Vos soldes de compte resteront inchangés, et les ETH que vous détenez actuellement resteront accessibles sous leur forme actuelle après la fourche majeure.
+- **Attention aux arnaques !** <Emoji text="⚠️" />**quiconque vous demandant de "mettre àniveau" vos ETH essaie de vous arnaquer.** Vous n'avez rien à faire en relation avec cette mise à niveau. Vos actifs resteront totalement inchangés. N'oubliez pas, rester informé est la meilleure défense contre les arnaques.
+
+[En savoir plus sur comment reconnaitre et éviter les arnaques](/security/)
+
+### Pourquoi des zèbres ? <Emoji text="🦓" /> {#whats-with-the-zebras}
+
+Le zèbre est la \
+
+La Fusion en 2022 [a utilisé un panda](https://x.com/hwwonx/status/1431970802040127498) comme mascotte pour signaler l'union des couches d'exécution et de consensus. Depuis lors, des mascottes ont été choisies de manière informelle pour chaque fourche et apparaissent sous forme d'art ASCII dans les journaux du client au moment de la mise à niveau. C'est juste une façon amusante de célébrer.
+
+### Quelles sont les améliorations incluses pour la mise à l'échelle L2 ? {#what-improvements-are-included-for-l2-scaling}
+
+[PeerDAS](/roadmap/fusaka/peerdas) est la fonctionnalité principale de la fourche. Il met en œuvre l'échantillonnage de la disponibilité des données (DAS) qui débloque plus d'évolutivité pour les rollups, augmentant théoriquement l'espace des blobs jusqu'à 8 fois la taille actuelle. Le marché des frais de blob sera également amélioré pour réagir efficacement à la congestion et garantir que les L2 paient des frais significatifs pour le calcul et l'espace que les blobs imposent aux nœuds.
+
+### En quoi les fourches BPO sont-elles différentes ? {#how-are-bpo-forks-different}
+
+Les fourches à paramètre blob uniquement fournissent un mécanisme pour augmenter continuellement le nombre de blobs (cible et max) après l'activation de PeerDAS, sans avoir à attendre une mise à niveau complète coordonnée. Chaque augmentation est pré-configurée en dur dans les versions client supportant Fusaka.
+
+En tant qu'utilisateur ou validateur, vous n'avez pas besoin de mettre à jour vos clients pour chaque BPO et devez seulement vous assurer de suivre les hardforks majeurs comme Fusaka. C'est la même pratique qu'auparavant, aucune action spéciale n'est nécessaire. Il est toujours recommandé de surveiller vos clients lors des mises à niveau et des BPO et de les maintenir à jour même entre les versions majeures, car des correctifs ou des optimisations peuvent suivre le hardfork.
+
+### Quel est le calendrier des BPO ? {#what-is-the-bpo-schedule}
+
+Le calendrier exact des mises à jour BPO sera déterminé avec les versions de Fusaka. Suivez les [annonces de protocole](https://blog.ethereum.org/category/protocol) et les notes de version de vos clients.
+
+Exemple de ce à quoi cela pourrait ressembler :
+
+- Avant Fusaka : cible 6, max 9
+- À l'activation de Fusaka : cible 6, max 9
+- BPO1, quelques semaines après l'activation de Fusaka : cible 10, max 15, augmentant de deux tiers
+- BPO2, quelques semaines après BPO1 : cible 14, max 21
+
+### Cela réduira-t-il les frais sur Ethereum (couche 1) {#will-this-lower-gas}
+
+Cette mise à niveau ne réduit pas les frais de gaz sur la L1, du moins pas directement. L'accent principal est mis sur plus d'espace de blob pour les données de rollup, réduisant ainsi les frais sur la couche 2. Cela pourrait avoir des effets secondaires sur le marché des frais L1, mais aucun changement significatif n'est attendu.
+
+### En tant que validateur, que dois-je faire pour la mise à niveau ? {#as-a-staker-what-do-i-need-to-do-for-the-upgrade}
+
+Comme pour chaque mise à niveau du réseau, assurez-vous de mettre à jour vos clients vers les dernières versions marquées comme compatibles avec Fusaka. Suivez les mises à jour dans la liste de diffusion et les [annonces de protocole sur le blog de l'EF](https://blog.ethereum.org/category/protocol) pour être informé des nouvelles versions.
+Pour valider votre configuration avant l'activation de Fusaka sur le Mainnet, vous pouvez exécuter un validateur sur les testnets. Fusaka est [activé plus tôt sur les testnets](https://blog.ethereum.org/2025/09/26/fusaka-testnet-announcement), ce qui vous donne plus de temps pour vous assurer que tout fonctionne et signaler les bogues. Les fourches de testnet sont également annoncées dans la liste de diffusion et sur le blog.
+
+### La "Prospection Déterministe du Proposeur" (EIP-7917) affecte-t-elle les validateurs ? {#does-7917-affect-validators}
+
+Ce changement ne modifie pas le fonctionnement de votre client validateur, cependant, il fournira plus d'informations sur l'avenir de vos tâches de validateur. Assurez-vous de mettre à jour vos outils de surveillance pour suivre les nouvelles fonctionnalités.
+
+### Comment Fusaka affecte-t-il les exigences de bande passante pour les nœuds et les validateurs ? {#how-does-fusaka-affect-bandwidth-requirements-for-nodes-and-validators}
+
+PeerDAS apporte un changement significatif à la manière dont les nœuds transmettent les données de blob. Toutes les données sont divisées en morceaux appelés colonnes sur 128 sous-réseaux, les nœuds ne s'abonnant qu'à certains d'entre eux. Le nombre de colonnes de sous-réseau que les nœuds doivent conserver dépend de leur configuration et du nombre de validateurs connectés. Les exigences réelles en matière de bande passante dépendront de la quantité de blobs autorisée sur le réseau et du type de nœud. Au moment de l'activation de Fusaka, l'objectif de blob reste le même qu'auparavant, mais avec PeerDAS, les opérateurs de nœuds peuvent constater une diminution de leur utilisation de disque pour les blobs et du trafic réseau. À mesure que les BPO configureront un plus grand nombre de blobs dans le réseau, la bande passante nécessaire augmentera avec chaque BPO.
+
+Les exigences des nœuds restent dans les [marges recommandées](https://eips.ethereum.org/EIPS/eip-7870) même après les BPO de Fusaka.
+
+#### Nœuds complets {#full-nodes}
+
+Les nœuds réguliers sans validateurs ne s'abonneront qu'à 4 sous-réseaux, assurant la conservation de 1/8 des données d'origine. Cela signifie qu'avec la même quantité de données de blob, la bande passante du nœud pour les télécharger serait plus faible d'un facteur huit (8). L'utilisation du disque et la bande passante de téléchargement des blobs pour un nœud complet normal pourraient diminuer d'environ 80 %, à seulement quelques Mo.
+
+#### Validateurs en solo {#solo-stakers}
+
+Si le nœud est utilisé pour un client validateur, il doit conserver plus de colonnes et donc traiter plus de données. Avec un validateur ajouté, le nœud s'abonne à au moins 8 sous-réseaux de colonnes et traite donc deux fois plus de données qu'un nœud ordinaire, mais toujours moins qu'avant Fusaka. Si le solde du validateur est supérieur à 287 ETH, de plus en plus de sous-réseaux seront souscrits.
+
+Pour un validateur solo, cela signifie que son utilisation de disque et sa bande passante de téléchargement diminueront d'environ 50 %. Cependant, pour construire des blocs localement et téléverser tous les blobs sur le réseau, il faut plus de bande passante de téléversement. Les constructeurs locaux auront besoin d'une bande passante de téléversement 2 à 3 fois plus élevée qu'auparavant au moment de Fusaka, et avec l'objectif BPO2 de 15/21 blobs, la bande passante de téléversement finale nécessaire devra être environ 5 fois plus élevée, à 100 Mpbs.
+
+#### Grands validateurs {#large-validators}
+
+Le nombre de sous-réseaux auxquels on est abonné augmente avec l'augmentation du solde et des validateurs ajoutés au nœud. Par exemple, avec un solde d'environ 800 ETH, le nœud conserve 25 colonnes et aura besoin d'environ 30 % de bande passante de téléchargement en plus qu'auparavant. La téléversement nécessaire augmente de manière similaire aux nœuds réguliers et au moins 100 Mbps sont nécessaires.
+
+À 4096 ETH, soit 2 validateurs à solde maximal, le nœud devient un « super-nœud » qui conserve toutes les colonnes, télécharge et stocke donc tout. Ces nœuds réparent activement le réseau en y réinjectant les données manquantes, mais nécessitent également beaucoup plus de bande passante et de stockage. L'objectif final de blob étant 6 fois plus élevé qu'auparavant, les super-nœuds devront stocker environ 600 Go de données de blob supplémentaires et disposer d'une bande passante de téléchargement soutenue plus rapide, d'environ 20 Mbps.
+
+[Lire plus de détails sur les exigences attendues.](https://ethpandaops.io/posts/fusaka-bandwidth-estimation/#theoretical-requirements)
+
+### Quels changements sont apportés à l'EVM ? {#what-evm-changes-are-implemented}
+
+Fusaka solidifie l'EVM avec de nouveaux changements et fonctionnalités mineurs.
+
+- Pour la sécurité lors de la mise à l'échelle, la taille maximale d'une seule transaction sera [limitée à 16,7 millions](https://eips.ethereum.org/EIPS/eip-7825) d'unités de gaz.
+- [Le nouvel opcode de comptage des zéros non significatifs (CLZ)](https://eips.ethereum.org/EIPS/eip-7939) est ajouté à l'EVM et permettra aux langages de contrats intelligents d'effectuer certaines opérations plus efficacement.
+- [Le coût de la précompilation `ModExp` sera augmenté](https://eips.ethereum.org/EIPS/eip-7883) — les contrats qui l'utilisent factureront plus de gaz pour l'exécution.
+
+### Comment la nouvelle limite de gaz de 16M affecte-t-elle les développeurs de contrats ? {#how-does-new-16m-gas-limit-affects-contract-developers}
+
+Fusaka introduit une limite à la [taille maximale d'une seule transaction à 16,7 millions](https://eips.ethereum.org/EIPS/eip-7825) (2^24) d'unités de gaz. Cela correspond à peu près à la taille précédente d'un bloc moyen, ce qui le rend suffisamment grand pour accueillir des transactions complexes qui consommeraient un bloc entier. Cette limite crée une protection pour les clients, empêchant les attaques DoS potentielles à l'avenir avec une limite de gaz de bloc plus élevée. L'objectif de la mise à l'échelle est de permettre à plus de transactions d'entrer dans la blockchain sans qu'une seule ne consomme tout le bloc.
+
+Les transactions d'utilisateurs réguliers sont loin d'atteindre cette limite. Certains cas limites comme les opérations DeFi importantes et complexes, les déploiements de grands contrats intelligents ou les transactions par lots ciblant plusieurs contrats pourraient être affectés par ce changement. Ces transactions devront être divisées en plus petites ou optimisées d'une autre manière. Utilisez la simulation avant de soumettre des transactions qui pourraient atteindre la limite.
+
+La méthode RPC `eth_call` n'est pas limitée et permettra de simuler des transactions plus volumineuses que la limite réelle de la blockchain. La limite réelle pour les méthodes RPC peut être configurée par l'opérateur du client pour empêcher les abus.
+
+### Que signifie CLZ pour les développeurs ? {#what-clz-means-for-developers}
+
+Les compilateurs EVM comme Solidity implémenteront et utiliseront la nouvelle fonction de comptage des zéros en arrière-plan. Les nouveaux contrats pourraient bénéficier d'économies de gaz s'ils dépendent de ce type d'opération. Suivez les versions et les annonces de fonctionnalités du langage de contrat intelligent pour obtenir de la documentation sur les économies potentielles.
+
+### Y a-t-il des changements pour mes contrats intelligents existants ? {#what-clz-means-for-developers}
+
+Fusaka n'a aucun effet direct qui pourrait casser des contrats existants ou changer leur comportement. Les changements introduits dans la couche d'exécution sont faits avec une compatibilité ascendante, cependant, gardez toujours un œil sur les cas limites et l'impact potentiel.
+
+[Avec l'augmentation du coût de la précompilation `ModExp`](https://eips.ethereum.org/EIPS/eip-7883), les contrats qui en dépendent consommeront plus de gaz pour l'exécution. Si votre contrat dépend fortement de cela et devient plus cher pour les utilisateurs, reconsidérez la manière dont il est utilisé.
+
+Considérez la [nouvelle limite de 16,7 millions](https://eips.ethereum.org/EIPS/eip-7825) si les transactions exécutant vos contrats pourraient atteindre une taille similaire.
+
+## En savoir plus {#further-reading}
+
+- [Feuille de route d'Ethereum](/roadmap/)
+- [Forkcast : Fusaka](https://forkcast.org/upgrade/fusaka)
+- [Fusaka Meta EIP](https://eips.ethereum.org/EIPS/eip-7607)
+- [Annonce du testnet Fusaka sur le blog](https://blog.ethereum.org/2025/09/26/fusaka-testnet-announcement)
+- [Sans banque : ce que Fusaka et Pectra apporteront à Ethereum](https://www.bankless.com/read/what-fusaka-pectra-will-bring-ethereum)
+- [Bankless : les prochaines mises à niveau d'Ethereum : Fusaka, Glamsterdam et au-delà avec Preston Van Loon](https://x.com/BanklessHQ/status/1956017743289020633?t=502)
+- [Les Dossiers Fusaka](https://www.youtube.com/playlist?list=PL4cwHXAawZxpz-erUbKKUnnGoQNdF8s7Z)
+- [PEEPanEIPs Expliqués](https://www.youtube.com/playlist?list=PL4cwHXAawZxoIenfk7OJry4rxcqX-eqBt)
diff --git a/public/content/translations/fr/roadmap/fusaka/peerdas/index.md b/public/content/translations/fr/roadmap/fusaka/peerdas/index.md
new file mode 100644
index 00000000000..7a016108abf
--- /dev/null
+++ b/public/content/translations/fr/roadmap/fusaka/peerdas/index.md
@@ -0,0 +1,88 @@
+---
+title: PeerDAS
+description: "Apprenez-en plus sur PeerDAS dans le cadre de la mise à niveau du protocole Ethereum Fusaka"
+lang: fr
+---
+
+# PeerDAS {#peer-das}
+
+Le protocole Ethereum subit sa mise à niveau d'évolutivité la plus importante depuis [l'introduction des transactions de blobs avec l'EIP-4844](/roadmap/danksharding/). Dans le cadre de la [mise à niveau Fusaka](/roadmap/fusaka/), PeerDAS introduit une nouvelle manière de gérer les données de blob, augmentant d'environ un ordre de grandeur la capacité de **[disponibilité des données (DA)](/developers/docs/data-availability/)** pour les L2.
+
+[En savoir plus sur la feuille de route de la mise à l'échelle des blobs](https://blog.ethereum.org/2025/08/22/protocol-update-002)
+
+## Scalabilité {#scalability}
+
+La vision d'Ethereum est d'être une plateforme neutre, sécurisée et décentralisée, disponible pour tous dans le monde. À mesure que l'utilisation du réseau augmente, il est nécessaire de trouver un équilibre dans le trilemme de l'évolutivité, de la sécurité et de la décentralisation du réseau. Si Ethereum augmentait simplement la quantité de données traitées par le réseau dans sa conception actuelle, il risquerait de surcharger les [nœuds sur lesquels Ethereum s'appuie pour sa décentralisation](/developers/docs/nodes-and-clients/). L'évolutivité nécessite une conception de mécanisme rigoureuse qui minimise les compromis.
+
+L'une des stratégies pour atteindre cet objectif est de permettre un écosystème diversifié de solutions de mise à l'échelle de couche 2, plutôt que de traiter toutes les transactions sur le réseau principal de [couche 1 (L1)](/glossary/#layer-1). Les [couches 2 (L2)](/glossary/#layer-2) ou les [rollups](/glossary#rollups) traitent les transactions sur leurs propres chaînes distinctes et utilisent Ethereum pour la vérification et la sécurité. La publication d'engagements critiques pour la sécurité et la compression des charges utiles permettent aux L2 d'utiliser plus efficacement la capacité de disponibilité des données d'Ethereum. En retour, la L1 transporte moins de données sans compromettre les garanties de sécurité, tandis que les L2 intègrent plus d'utilisateurs à des coûts de gaz plus faibles. Initialement, les L2 publiaient des données en tant que `calldata` dans des transactions ordinaires, ce qui entrait en concurrence avec les transactions L1 pour le gaz et n'était pas pratique pour la disponibilité des données en vrac.
+
+## Proto-Danksharding {#proto-danksharding}
+
+La première étape majeure vers la mise à l'échelle des L2 a été la mise à niveau Dencun, qui a introduit le [Proto-Danksharding](/roadmap/danksharding/) (EIP-4844). Cette mise à niveau a créé un nouveau type de données spécialisé pour les rollups, appelé blobs. Les [blobs](/developers/docs/data-availability/blockchain-data-storage-strategies/#eip-4844-blobs), ou objets binaires volumineux, sont des éléments de données arbitraires éphémères qui ne nécessitent pas d'exécution par l'EVM et que les nœuds ne stockent que pour une durée limitée. Ce traitement plus efficace a permis aux L2 de publier plus de données sur Ethereum et de se mettre à l'échelle encore davantage.
+
+Bien que l'utilisation de blobs présente déjà des avantages considérables pour la mise à l'échelle, ce n'est qu'une partie de l'objectif final. Dans le protocole actuel, chaque nœud du réseau doit encore télécharger chaque blob. Le goulot d'étranglement devient la bande passante requise par les nœuds individuels, la quantité de données à télécharger augmentant directement avec le nombre de blobs.
+
+Ethereum ne fait aucun compromis sur la décentralisation, et la bande passante est l'un des paramètres les plus sensibles. Même avec une informatique puissante largement accessible à quiconque peut se le permettre, les [limitations de la bande passante de téléversement](https://www.speedtest.net/global-index), même dans les villes très urbanisées des pays développés (comme l'[Allemagne](https://www.speedtest.net/global-index/germany), la [Belgique](https://www.speedtest.net/global-index/belgium), l'[Australie](https://www.speedtest.net/global-index/australia) ou les [États-Unis](https://www.speedtest.net/global-index/united-states)), pourraient limiter le fonctionnement des nœuds aux seuls centres de données si les exigences en matière de bande passante ne sont pas soigneusement ajustées.
+
+Les opérateurs de nœuds ont des exigences de plus en plus élevées en matière de bande passante et d'espace disque à mesure que le nombre de blobs augmente. La taille et la quantité de blobs sont limitées par ces contraintes. Chaque blob peut transporter jusqu'à 128 ko de données, avec une moyenne de 6 blobs par bloc. Ce n'était que la première étape vers une conception future qui utilise les blobs d'une manière encore plus efficace.
+
+## Échantillonnage de la disponibilité des données {#das}
+
+La [disponibilité des données](/developers/docs/data-availability/) est la garantie que toutes les données nécessaires pour valider indépendamment la chaîne sont accessibles à tous les participants du réseau. Elle garantit que les données ont été entièrement publiées et peuvent être utilisées pour vérifier sans confiance le nouvel état de la chaîne ou les transactions entrantes.
+
+Les blobs Ethereum fournissent une garantie de disponibilité des données forte qui assure la sécurité des L2. Pour ce faire, les nœuds Ethereum doivent télécharger et stocker les blobs dans leur intégralité. Mais que se passerait-il si nous pouvions distribuer les blobs sur le réseau de manière plus efficace et éviter cette limitation ?
+
+Une approche différente pour stocker les données et garantir leur disponibilité est l'**échantillonnage de la disponibilité des données (DAS)**. Au lieu que chaque ordinateur exécutant Ethereum stocke entièrement chaque blob, le DAS introduit une division du travail décentralisée. Il allège la charge de traitement des données en distribuant des tâches plus petites et gérables sur l'ensemble du réseau de nœuds. Les blobs sont divisés en morceaux et chaque nœud ne télécharge que quelques morceaux en utilisant un mécanisme de distribution aléatoire uniforme sur tous les nœuds.
+
+Cela introduit un nouveau problème : prouver la disponibilité et l'intégrité des données. Comment le réseau peut-il garantir que les données sont disponibles et qu'elles sont toutes correctes alors que les nœuds individuels ne détiennent que de petits morceaux ? Un nœud malveillant pourrait fournir de fausses données et briser facilement les garanties de disponibilité des données fortes ! C'est là que la cryptographie entre en jeu.
+
+Pour garantir l'intégrité des données, l'EIP-4844 a déjà été mis en œuvre avec les engagements KZG. Ce sont des preuves cryptographiques créées lorsqu'un nouveau blob est ajouté au réseau. Une petite preuve est incluse dans chaque bloc, et les nœuds peuvent vérifier que les blobs reçus correspondent à l'engagement KZG du bloc.
+
+Le DAS est un mécanisme qui s'appuie sur cela et garantit que les données sont à la fois correctes et disponibles. L'échantillonnage est un processus où un nœud n'interroge qu'une petite partie des données et la vérifie par rapport à l'engagement. KZG est un schéma d'engagement polynomial, ce qui signifie que n'importe quel point unique sur la courbe polynomiale peut être vérifié. En ne vérifiant que quelques points sur le polynôme, le client effectuant l'échantillonnage peut avoir une forte garantie probabiliste que les données sont disponibles.
+
+## PeerDAS {#peer-das}
+
+[PeerDAS (EIP-7594)](https://eips.ethereum.org/EIPS/eip-7594) est une proposition spécifique qui met en œuvre le mécanisme DAS dans Ethereum, marquant probablement la plus grande mise à niveau depuis La Fusion. PeerDAS est conçu pour étendre les données de blob, en les divisant en colonnes et en distribuant un sous-ensemble aux nœuds.
+
+Ethereum emprunte quelques astuces mathématiques pour y parvenir : il applique un codage d'effacement de type Reed-Solomon aux données de blob. Les données de blob sont représentées comme un polynôme dont les coefficients encodent les données, puis ce polynôme est évalué à des points supplémentaires pour créer un blob étendu, doublant ainsi le nombre d'évaluations. Cette redondance ajoutée permet la récupération par effacement : même si certaines évaluations manquent, le blob original peut être reconstruit tant qu'au moins la moitié des données totales, y compris les morceaux étendus, sont disponibles.
+
+![Polynôme étendu](./polynomial.png)
+
+En réalité, ce polynôme a des milliers de coefficients. Les engagements KZG sont des valeurs de quelques octets, quelque chose comme un hash, connus de tous les nœuds. Chaque nœud détenant suffisamment de points de données peut [reconstruire efficacement un ensemble complet de données de blob](https://arxiv.org/abs/2207.11079).
+
+> Fait amusant : la même technique de codage était utilisée par les DVD. Si vous rayiez un DVD, le lecteur était toujours capable de le lire grâce au codage Reed-Solomon qui ajoute les morceaux manquants du polynôme.
+
+Historiquement, les données dans les blockchains, qu'il s'agisse de blocs ou de blobs, étaient diffusées à tous les nœuds. Avec l'approche de division et d'échantillonnage de PeerDAS, il n'est plus nécessaire de tout diffuser à tout le monde. Après Fusaka, le réseau de la couche de consensus est organisé en sujets/sous-réseaux de gossip : les colonnes de blobs sont assignées à des sous-réseaux spécifiques, et chaque nœud s'abonne à des sous-ensembles prédéterminés et ne conserve que ces morceaux.
+
+Avec PeerDAS, les données de blob étendues sont divisées en 128 morceaux appelés colonnes. Les données sont distribuées à ces nœuds via un protocole de gossip dédié sur des sous-réseaux spécifiques auxquels ils s'abonnent. Chaque nœud ordinaire du réseau participe à au moins 8 sous-réseaux de colonnes choisis au hasard. Recevoir des données de seulement 8 des 128 sous-réseaux signifie que ce nœud par défaut ne reçoit que 1/16 de toutes les données, mais comme les données ont été étendues, cela représente 1/8 des données originales.
+
+Cela permet une nouvelle limite théorique de mise à l'échelle de 8 fois le schéma actuel « tout le monde télécharge tout ». Avec des nœuds s'abonnant à différents sous-réseaux aléatoires servant des colonnes de blob, la probabilité est très élevée qu'ils soient distribués de manière uniforme et que, par conséquent, chaque morceau de données existe quelque part sur le réseau. Les nœuds qui exécutent des validateurs sont tenus de s'abonner à plus de sous-réseaux pour chaque validateur qu'ils exécutent.
+
+> Chaque nœud a un ID unique généré de manière aléatoire, qui lui sert normalement d'identité publique pour les connexions. Dans PeerDAS, ce nombre est utilisé pour déterminer l'ensemble aléatoire de sous-réseaux auxquels il doit s'abonner, ce qui résulte en une distribution aléatoire uniforme de toutes les données de blob.
+
+Une fois qu'un nœud a réussi à reconstruire les données originales, il redistribue les colonnes récupérées sur le réseau, comblant activement les lacunes de données et améliorant la résilience globale du système. Les nœuds connectés à des validateurs avec un solde combiné ≥4096 ETH doivent être des super-nœuds et doivent donc s'abonner à tous les sous-réseaux de colonnes de données et conserver toutes les colonnes. Ces super-nœuds combleront continuellement les lacunes de données. La nature probabilistiquement auto-réparatrice du protocole permet de fortes garanties de disponibilité sans pour autant limiter les opérateurs à domicile qui ne détiennent que des portions des données.
+
+![Nœuds s'abonnant aux colonnes distribuées via les sous-réseaux](./subnets.png)
+
+La disponibilité des données peut être confirmée par n'importe quel nœud ne détenant qu'un petit sous-ensemble des données de blob grâce au mécanisme d'échantillonnage décrit ci-dessus. Cette disponibilité est appliquée : les validateurs doivent suivre de nouvelles règles de choix de fourche, ce qui signifie qu'ils n'accepteront et ne voteront pour des blocs qu'après avoir vérifié la disponibilité des données.
+
+L'impact direct sur les utilisateurs (en particulier les utilisateurs de L2) est une réduction des frais. Avec 8 fois plus d'espace pour les données de rollup, les opérations des utilisateurs sur leur chaîne deviennent encore moins chères avec le temps. Mais la baisse des frais après Fusaka prendra du temps et dépendra des BPO.
+
+## Fourches à paramètre de blob uniquement (BPO) {#bpo}
+
+Le réseau sera théoriquement capable de traiter 8 fois plus de blobs, mais les augmentations du nombre de blobs sont un changement qui doit être correctement testé et exécuté en toute sécurité, par étapes. Les réseaux de test donnent suffisamment de confiance pour déployer les fonctionnalités sur le réseau principal, mais nous devons assurer la stabilité du réseau p2p avant d'activer un nombre de blobs significativement plus élevé.
+
+Pour augmenter progressivement le nombre cible de blobs par bloc sans surcharger le réseau, Fusaka introduit des fourches **[à paramètre de blob uniquement (BPO)](https://ethereum-magicians.org/t/blob-parameter-only-bpo-forks/22623)**. Contrairement aux fourches ordinaires qui nécessitent une large coordination de l'écosystème, un accord et des mises à jour logicielles, les [BPO (EIP-7892)](https://eips.ethereum.org/EIPS/eip-7892) sont des mises à niveau préprogrammées qui augmentent le nombre maximal de blobs au fil du temps sans intervention.
+
+Cela signifie qu'immédiatement après l'activation de Fusaka et la mise en service de PeerDAS, le nombre de blobs restera inchangé. Le nombre de blobs commencera à doubler toutes les quelques semaines jusqu'à atteindre un maximum de 48, pendant que les développeurs surveilleront pour s'assurer que le mécanisme fonctionne comme prévu et n'a pas d'effets négatifs sur les nœuds qui exécutent le réseau.
+
+## Orientations futures {#future-directions}
+
+PeerDAS n'est qu'une étape [vers une vision plus large de mise à l'échelle avec FullDAS](https://ethresear.ch/t/fulldas-towards-massive-scalability-with-32mb-blocks-and-beyond/19529), ou Danksharding. Alors que PeerDAS utilise un codage d'effacement 1D pour chaque blob individuellement, le Danksharding complet utilisera un schéma de codage d'effacement 2D plus complet sur toute la matrice de données de blob. L'extension des données dans deux dimensions crée des propriétés de redondance encore plus fortes et une reconstruction et une vérification plus efficaces. La réalisation de FullDAS nécessitera des optimisations substantielles du réseau et du protocole, ainsi que des recherches supplémentaires.
+
+## En savoir plus {#further-reading}
+
+- [PeerDAS : Échantillonnage de la disponibilité des données par les pairs par Francesco D'Amato](https://www.youtube.com/watch?v=WOdpO1tH_Us)
+- [Une documentation du PeerDAS d'Ethereum](https://eprint.iacr.org/2024/1362.pdf)
+- [Prouver la sécurité de PeerDAS sans l'AGM](https://eprint.iacr.org/2025/1683)
+- [Vitalik à propos de PeerDAS, de son impact et des tests de Fusaka](https://x.com/VitalikButerin/status/1970983281090085200)
\ No newline at end of file
diff --git a/public/content/translations/fr/roadmap/future-proofing/index.md b/public/content/translations/fr/roadmap/future-proofing/index.md
index e5f246b63b4..9c2c85d1862 100644
--- a/public/content/translations/fr/roadmap/future-proofing/index.md
+++ b/public/content/translations/fr/roadmap/future-proofing/index.md
@@ -1,6 +1,6 @@
 ---
-title: Ethereum à l’épreuve du temps
-description: Ces mises à niveau consolident Ethereum en tant que couche de base résiliente et décentralisée pour l’avenir, quoi qu’elle réserve.
+title: "Ethereum à l’épreuve du temps"
+description: "Ces mises à niveau consolident Ethereum en tant que couche de base résiliente et décentralisée pour l’avenir, quoi qu’elle réserve."
 lang: fr
 image: /images/roadmap/roadmap-future.png
 alt: "Feuille de route d'Ethereum"
@@ -11,28 +11,43 @@ Certaines parties de la feuille de route ne sont pas nécessairement requises po
 
 ## Résistance quantique {#quantum-resistance}
 
-Une partie de la sécurisation de la [cryptographie](/glossary/#cryptography) actuelle d'Ethereum sera compromise lorsque le calcul quantique deviendra une réalité. Bien que les ordinateurs quantiques soient probablement à des décennies de constituer une véritable menace pour la cryptographie moderne, Ethereum est construit pour être sécurisé pour les siècles à venir. Cela signifie rendre [Ethereum quantique résistant](https://consensys.net/blog/developers/how-will-quantum-supremacy-affect-blockchain/) dès que possible.
+Une partie de la [cryptographie](/glossary/#cryptography) qui sécurise Ethereum aujourd'hui sera compromise lorsque l'informatique quantique deviendra une réalité. Bien que les ordinateurs quantiques soient probablement à des décennies de constituer une véritable menace pour la cryptographie moderne, Ethereum est construit pour être sécurisé pour les siècles à venir. Cela signifie rendre [Ethereum résistant au quantique](https://consensys.net/blog/developers/how-will-quantum-supremacy-affect-blockchain/) dès que possible.
 
-Le défi auquel sont confrontés les développeurs d'Ethereum est que le protocole actuel de [preuve d'enjeu](/glossary/#pos) repose sur un système de signature très efficace connu sous le nom de BLS pour regrouper les votes sur les [blocs](/glossary/#block) valides. Ce schéma de signature est rompu par les ordinateurs quantiques, mais les alternatives de résistance quantique ne sont pas aussi efficaces.
+Le défi auquel sont confrontés les développeurs Ethereum est que le protocole actuel de [preuve d'enjeu](/glossary/#pos) repose sur un système de signature très efficace connu sous le nom de BLS pour agréger les votes sur les [blocs](/glossary/#block) valides. Ce schéma de signature est rompu par les ordinateurs quantiques, mais les alternatives de résistance quantique ne sont pas aussi efficaces.
 
-Les [schémas d'engagement « KZG»](/roadmap/danksharding/#what-is-kzg) utilisés à plusieurs endroits à travers Ethereum pour générer des secrets cryptographiques sont connus pour être vulnérables. Actuellement, cela est contourné en utilisant des « configurations de confiance » où de nombreux utilisateurs génèrent un aléa qui ne peut pas être inversé par un ordinateur quantique. Cependant, la solution idéale serait simplement d'intégrer la cryptographie quantique sûre. Il y a deux approches principales qui pourraient devenir des remplacements efficaces pour le schéma BLS : la signature [basée sur le STARK](https://hackmd.io/@vbuterin/stark_aggregation) et la signature [basée sur le treillis](https://medium.com/asecuritysite-when-bob-met-alice/so-what-is-lattice-encryption-326ac66e3175). **Ils sont encore en cours de recherche et de prototype**.
+Les schémas d'engagement [« KZG »](/roadmap/danksharding/#what-is-kzg) utilisés à plusieurs endroits au sein d'Ethereum pour générer des secrets cryptographiques sont connus pour leur vulnérabilité quantique. Actuellement, cela est contourné à l’aide de « configurations de confiance » (dont la principale cérémonie de configuration s’est achevée avec succès en 2023), au cours desquelles de nombreux utilisateurs ont généré des éléments aléatoires qui ne peuvent pas être rétro-construits par un ordinateur quantique. Cependant, la solution à long terme idéale serait plutôt d'intégrer une cryptographie quantique sûre. Il existe deux approches principales qui pourraient devenir des remplacements efficaces pour le schéma BLS : la signature [basée sur STARK](https://hackmd.io/@vbuterin/stark_aggregation) et la signature [basée sur les réseaux](https://medium.com/asecuritysite-when-bob-met-alice/so-what-is-lattice-encryption-326ac66e3175). **Ils sont encore en cours de recherche et de prototype**.
 
-<ButtonLink variant="outline-color" href="/roadmap/danksharding#what-is-kzg"> En savoir plus sur KZG et les configurations fiables</ButtonLink>
+[En savoir plus sur KZG et les configurations de confiance](/roadmap/danksharding#what-is-kzg)
 
-## Ethereum plus simple et plus efficace {#simpler-more-efficient-ethereum}
+## Un Ethereum plus simple et plus efficace {#simpler-more-efficient-ethereum}
 
-La complexité crée des opportunités pour les bogues ou les vulnérabilités que des assaillants peuvent exploiter. Par conséquent, une partie de la feuille de route simplifie Ethereum et supprime le code qui a été mis à jour par diverses mises à jour, mais qui n'est plus nécessaire ou peut maintenant être amélioré. Une base de code plus souple et plus simple est plus facile à maintenir et à raisonner pour les développeurs.
+La complexité crée des opportunités de bugs ou de vulnérabilités pouvant être exploitées par des attaquants. Par conséquent, une partie de la feuille de route simplifie Ethereum et supprime ou modifier le code qui a été mis à jour par diverses mises à jour, mais qui n'est plus nécessaire ou peut maintenant être amélioré. Un code plus léger et plus simple est plus facile à maintenir et à comprendre pour les développeurs.
 
-Il y a plusieurs mises à jour qui seront faites sur la [machine virtuelle Ethereum (EVM)](/developers/docs/evm) pour la rendre plus simple et plus efficace. Celles-ci incluent [la suppression de l'opcode SELFDESTRUCT](https://hackmd.io/@vbuterin/selfdestruct) - une commande rarement utilisée qui n'est plus nécessaire et dans certaines circonstances peut être dangereuse à utiliser, surtout lorsqu’elle est combinée à d’autres mises à jour futures vers le modèle de stockage Ethereum. Les [clients Ethereum](/glossary/#consensus-client) supportent également certains vieux types de transactions qui peuvent maintenant être complètement supprimés. La façon dont le [gaz](/glossary/#gas) est calculé peut également être amélioré et des méthodes plus efficaces pour l'arithmétique qui sous-tendent certaines opérations cryptographiques peuvent être introduites.
+Pour rendre la [Machine Virtuelle Ethereum (EVM)](/developers/docs/evm) plus simple et plus efficace, des améliorations sont continuellement recherchées et mises en œuvre. Cela implique à la fois de traiter les composants hérités et d’introduire des optimisations.
 
-De même, il y a des mises à jour qui peuvent être faites à d'autres parties des clients actuels d'Ethereum. Un exemple est que l'exécution courante et les clients de consensus utilisent un autre type de compression de données. Il sera beaucoup plus facile et plus intuitif de partager des données entre les clients lorsque le système de compression sera unifié sur l'ensemble du réseau.
+**Modifications récentes mises en œuvre :**
+
+- **Révision du calcul du gaz :** la manière dont le [gaz](/glossary/#gas) est calculé a été considérablement améliorée avec l'**EIP-1559 (mis en œuvre lors de la mise à niveau London, 2021)**, qui a introduit des frais de base et un mécanisme de combustion pour une tarification des transactions plus prévisible.
+- **Restriction de `SELFDESTRUCT` :** l'opcode `SELFDESTRUCT`, bien que rarement utilisé, présentait des risques potentiels. Sa fonctionnalité a été fortement **restreinte lors de la mise à niveau Dencun (mars 2024) via l'EIP-6780** pour atténuer les dangers, notamment en ce qui concerne la gestion de l'état.
+- **Types de transactions modernisés :** de nouveaux formats de transaction ont été introduits (par exemple, via **EIP-2718** et **EIP-4844** pour les blobs dans la mise à niveau Dencun) pour prendre en charge de nouvelles fonctionnalités et améliorer l'efficacité par rapport aux types hérités.
+
+**Objectifs en cours et à venir :**
+
+- **Gestion ultérieure de `SELFDESTRUCT` :** bien que restreinte, la **suppression complète potentielle** de l'opcode `SELFDESTRUCT` est toujours envisagée pour les futures mises à niveau afin de simplifier davantage l'état de l'EVM. ([Plus de contexte sur les problèmes de SELFDESTRUCT](https://hackmd.io/@vbuterin/selfdestruct)).
+- **Suppression progressive des transactions héritées :** bien que les [clients Ethereum](/glossary/#consensus-client) prennent toujours en charge les anciens types de transactions pour des raisons de compatibilité descendante, l'objectif est d'encourager la migration vers de nouveaux types et de **potentiellement déprécier ou supprimer complètement la prise en charge des formats les plus anciens** à l'avenir.
+- **Poursuite de la recherche sur l'efficacité du gaz :** l'exploration se poursuit pour **affiner davantage le calcul du gaz**, en incluant potentiellement des concepts comme le gaz multidimensionnel pour mieux refléter l'utilisation des ressources.
+- **Opérations cryptographiques optimisées :** des efforts sont en cours pour **introduire des méthodes plus efficaces pour l'arithmétique** qui sous-tend les opérations cryptographiques utilisées au sein de l'EVM.
+
+De même, des mises à jour peuvent être apportées à d’autres parties des clients Ethereum actuels. Un exemple est que les clients d’exécution et de consensus actuels utilisent un type de compression de données différent. Il sera beaucoup plus facile et plus intuitif de partager des données entre les clients lorsque le schéma de compression sera unifié sur l’ensemble du réseau. Cela reste un domaine à explorer.
 
 ## Progrès actuels {#current-progress}
 
-La plupart des mises à jour requises pour la pérennité d'Ethereum sont **toujours en phase de recherche et peuvent prendre plusieurs années** avant d'être mises en œuvre. Les mises à niveau telles que la suppression de SELFDESTRUCT et l'harmonisation du système de compression utilisé dans l'exécution et les clients de consensus sont susceptibles d'advenir plus tôt que la cryptographie résistante au quantique.
+Bon nombre des mises à niveau à long terme visant à pérenniser le protocole, en particulier la **résistance quantique totale pour les protocoles de base, en sont encore à la phase de recherche et leur mise en œuvre pourrait prendre plusieurs années**.
+
+Cependant, des **progrès significatifs ont déjà été réalisés dans les efforts de simplification.** Par exemple, des changements clés comme la **restriction de `SELFDESTRUCT` (EIP-6780)** et l'introduction des **transactions transportant des blobs (EIP-4844)** ont été mis en œuvre dans la **mise à niveau Dencun (mars 2024)**. Le travail sur l’harmonisation des schémas de compression des clients et d’autres améliorations d’efficacité se poursuit également.
 
-**Complément d'information**
+**En savoir plus**
 
 - [Gaz](/developers/docs/gas)
 - [EVM](/developers/docs/evm)
-- [Structures des données](/developers/docs/data-structures-and-encoding)
+- [Structures de données](/developers/docs/data-structures-and-encoding)
\ No newline at end of file
diff --git a/public/content/translations/fr/roadmap/merge/index.md b/public/content/translations/fr/roadmap/merge/index.md
index eafb0fc0cb0..58cc329b593 100644
--- a/public/content/translations/fr/roadmap/merge/index.md
+++ b/public/content/translations/fr/roadmap/merge/index.md
@@ -1,14 +1,14 @@
 ---
 title: La Fusion
-description: En savoir plus sur La Fusion - quand le réseau principal Ethereum adopte la preuve d'enjeu.
+description: "En savoir plus sur La Fusion - quand le réseau principal Ethereum adopte la preuve d'enjeu."
 lang: fr
 template: upgrade
 image: /images/upgrades/merge.png
 alt:
-summaryPoint1: Le réseau principal Ethereum utilise la preuve d'enjeu, mais cela n'a pas toujours été le cas.
-summaryPoint2: La mise à niveau du mécanisme original de preuve de travail à celui de la preuve d'enjeu a été appelé La Fusion.
-summaryPoint3: La Fusion fait référence à la fusion du réseau principal original Ethereum avec une blockchain distincte de preuve d'enjeu appelée la Chaîne phare, qui existe maintenant sous la forme d'une chaîne unique.
-summaryPoint4: La Fusion a réduit la consommation d'énergie d'Ethereum de ~99,95 %.
+summaryPoint1: "Le réseau principal Ethereum utilise la preuve d'enjeu, mais cela n'a pas toujours été le cas."
+summaryPoint2: "La mise à niveau du mécanisme original de preuve de travail à celui de la preuve d'enjeu a été appelé La Fusion."
+summaryPoint3: "La Fusion fait référence à la fusion du réseau principal original Ethereum avec une blockchain distincte de preuve d'enjeu appelée la Chaîne phare, qui existe maintenant sous la forme d'une chaîne unique."
+summaryPoint4: "La Fusion a réduit la consommation d'énergie d'Ethereum de ~99,95 %."
 ---
 
 <UpgradeStatus isShipped dateKey="page-upgrades:page-upgrades-beacon-date">
@@ -17,15 +17,15 @@ summaryPoint4: La Fusion a réduit la consommation d'énergie d'Ethereum de ~99,
 
 ## Qu'est-ce que La Fusion ? {#what-is-the-merge}
 
-La Fusion est la réunion de la couche d'exécution originale d'Ethereum (le réseau principal qui existe depuis [genesis](/ethereum-forks/#frontier)) avec sa nouvelle couche de consensus de preuve d'enjeu ; la Chaîne phare. Elle a également permis d'éliminer la nécessité d'un minage gourmand en énergie et de sécuriser le réseau via la mise en jeu d'ETH. Ce fut une étape vraiment passionnante dans la réalisation de la vision Ethereum - plus d'évolutivité, de sécurité et de durabilité.
+La Fusion était l'union de la couche d’exécution originale d'Ethereum (le Mainnet qui existe depuis la [genèse](/ethereum-forks/#frontier)) et de sa nouvelle couche de consensus à preuve d'enjeu, la Chaîne phare. Elle a également permis d'éliminer la nécessité d'un minage gourmand en énergie et de sécuriser le réseau via la mise en jeu d'ETH. Ce fut une étape vraiment passionnante dans la réalisation de la vision Ethereum - plus d'évolutivité, de sécurité et de durabilité.
 
 <MergeInfographic />
 
-Initialement, la [Chaîne phare](/roadmap/beacon-chain/) était envoyée séparément du [réseau principal](/glossary/#mainnet). Le réseau principal Ethereum - avec tous ses comptes, ses soldes, ses contrats intelligents et l'état de la blockchain - continuait d'être sécurisé par [la preuve de travail](/developers/docs/consensus-mechanisms/pow/), même si la Chaîne Phare fonctionnait en parallèle en utilisant [la preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). La Fusion a été le moment où ces deux systèmes se sont finalement combinés, et la preuve de travail a été remplacée de façon permanente par la preuve d'enjeu.
+Initialement, la [Beacon Chain](/roadmap/beacon-chain/) a été livrée séparément du [Mainnet](/glossary/#mainnet). Le Mainnet Ethereum — avec tous ses comptes, soldes, contrats intelligents et état de la blockchain — a continué d'être sécurisé par la [preuve de travail](/developers/docs/consensus-mechanisms/pow/), même si la Beacon Chain fonctionnait en parallèle en utilisant la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos/). La Fusion a été le moment où ces deux systèmes se sont finalement combinés, et la preuve de travail a été remplacée de façon permanente par la preuve d'enjeu.
 
-Imaginez qu'Ethereum est un vaisseau spatial qui a été lancé avant qu'il ne soit prêt pour un voyage interstellaire. Avec la Chaîne phare, la communauté a construit un nouveau moteur et un fuselage renforcé. Après de nombreux tests, il a été temps de remplacer à chaud le nouveau moteur par l'ancien en plein vol. Cela a permis de fusionner le nouveau moteur, plus efficace, avec le vaisseau existant, prêt à franchir plusieurs années-lumière et à conquérir l'univers.
+Imaginez qu'Ethereum est un vaisseau spatial qui a été lancé avant qu'il ne soit prêt pour un voyage interstellaire. Avec la Chaîne phare, la communauté a construit un nouveau moteur et un fuselage renforcé. Après de nombreux tests, il a été temps de remplacer à chaud le nouveau moteur par l'ancien en plein vol. Cette fusion a intégré le nouveau moteur plus efficace au vaisseau existant, lui permettant de parcourir des années-lumière et de conquérir l'univers.
 
-## La fusion avec le réseau principal {#merging-with-mainnet}
+## Fusionner avec le Mainnet {#merging-with-mainnet}
 
 La preuve de travail a sécurisé le réseau principal Ethereum de la genèse jusqu'à La Fusion. Cela a permis à la blockchain Ethereum que nous utilisons tous de voir le jour en juillet 2015 avec toutes ses fonctionnalités familières — transactions, contrats intelligents, comptes, etc.
 
@@ -40,7 +40,7 @@ Aucun historique n'a été perdu dans la Fusion. Au fur et à mesure que le rés
 <Alert variant="update">
 <AlertContent>
 <AlertDescription>
-Cette transition vers la preuve d'enjeu a modifié la façon dont l'éther est émis. En savoir plus sur l'émission d'[éthers avant et après la Fusion](/roadmap/merge/issuance/).
+Cette transition vers la preuve d'enjeu a modifié la façon dont l'éther est émis. En savoir plus sur [l'émission d'ether avant et après La Fusion](/roadmap/merge/issuance/).
 </AlertDescription>
 </AlertContent>
 </Alert>
@@ -49,20 +49,20 @@ Cette transition vers la preuve d'enjeu a modifié la façon dont l'éther est 
 
 **La Fusion n'a rien changé pour les détenteurs/utilisateurs.**
 
-_Ceci nécessite d'être répété _: en tant qu'utilisateur ou détenteur d'ETH ou de tout autre actif numérique sur Ethereum, ainsi que pour les stakers qui n'opèrent pas sur les nœuds, **vous n'avez pas besoin de faire quoi que ce soit avec vos fonds ou votre portefeuille pour vous rendre compte de La Fusion.**. L'ETH n'est que l'ETH. Il n'existe rien de tel que « les anciens ETH »/« les nouveaux ETH » ou « ETH1 »/« ETH2 » et les portefeuilles fonctionnent exactement de la même manière après La Fusion qu'auparavant — les personnes vous disant l'inverse sont probablement des escrocs.
+_Il convient de le répéter_ : en tant qu'utilisateur ou détenteur d'ETH ou de tout autre actif numérique sur Ethereum, ainsi que pour les validateurs n'exploitant pas de nœud, **vous n'avez rien à faire avec vos fonds ou votre portefeuille pour tenir compte de La Fusion.** L'ETH est juste de l'ETH. Il n'existe rien de tel que « les anciens ETH »/« les nouveaux ETH » ou « ETH1 »/« ETH2 » et les portefeuilles fonctionnent exactement de la même manière après La Fusion qu'auparavant — les personnes vous disant l'inverse sont probablement des escrocs.
 
 Malgré le passage de la preuve de travail vers la preuve d'enjeu, tout l'historique d'Ethereum depuis sa genèse reste intact et inaltéré depuis ladite transition. Tous les fonds détenus dans votre portefeuille avant La Fusion restent accessibles après La Fusion. **Aucune action n'est requise pour mettre à jour de votre côté.**
 
-[En savoir plus sur la sécurité et Ethereum](/security/#eth2-token-scam)
+[En savoir plus sur la sécurité d'Ethereum](/security/#eth2-token-scam)
 
-### Opérateurs de nœuds et développeurs de dApps {#node-operators-dapp-developers}
+### Opérateurs de nœuds et développeurs de dapps {#node-operators-dapp-developers}
 
 <ExpandableCard
-title="Opérateurs et fournisseurs de nœuds de mise en jeu"
-contentPreview="If you are a staker running your own node setup or a node infrastructure provider, there are a few things you need to be aware of after The Merge."
+title="Opérateurs et fournisseurs de nœuds de staking"
+contentPreview="Si vous êtes un staker qui gère son propre nœud ou un fournisseur d'infrastructure de nœuds, il y a quelques éléments à prendre en compte suite à La Fusion."
 id="staking-node-operators">
 
-Les principaux éléments d'action incluent :
+Les actions clés à entreprendre sont notamment :
 
 1. Exécutez _à la fois_ un client de consensus et un client d'exécution  ; les points de terminaison tiers pour obtenir des données d'exécution ne fonctionnent plus depuis La Fusion.
 2. Authentifier à la fois les clients d'exécution et de consensus avec un secret JWT partagé pour qu'ils puissent communiquer en toute sécurité.
@@ -74,26 +74,25 @@ Ne pas définir un « destinataire de frais » permettra toujours à votre valid
 </ExpandableCard>
 
 <ExpandableCard
-title="Opérateurs de nœuds non validés et fournisseurs d'infrastructure"
-contentPreview="If you're operating a non-validating Ethereum node, the most significant change that came with The Merge was the requirement to run clients for BOTH the execution layer AND the consensus layer."
+title="Opérateurs de nœuds non-validateurs et fournisseurs d'infrastructure"
+contentPreview="Si vous gérez un nœud Ethereum non-validateur, le changement le plus important apporté par La Fusion a été l'obligation d'exécuter des clients à la fois pour la couche d’exécution ET la couche de consensus."
 id="node-operators">
 
 Jusqu'au moment de La Fusion, un client d'exécution (comme Geth, Erigon, Besu ou Nethermind) suffisait pour recevoir, valider correctement et diffuser les blocs créés par le réseau. Après La Fusion, la validité des transactions contenues dans un bloc d'exécution dépend désormais également de la validité du « bloc de consensus » qu'il contient.
 
 Par conséquent, un nœud Ethereum complet nécessite maintenant à la fois un client d'exécution et un client de consensus. Ces deux clients travaillent ensemble en utilisant une nouvelle API Moteur. L'API Moteur nécessite une authentification à l'aide d'un secret JWT, qui est fourni aux deux clients permettant ainsi une communication sécurisée.
 
-Les éléments clés d'action incluent le fait :
+Les actions clés à entreprendre sont notamment :
 
-- D'installer un client de consensus en plus d'un client d'exécution
-- D'authentifier les clients d'exécution et de consensus avec un secret JWT partagé pour qu'ils puissent communiquer en toute sécurité entre eux.
+- Installer un client de consensus en plus d'un client d'exécution
+- Authentifier les clients d'exécution et de consensus avec un secret JWT partagé afin qu'ils puissent communiquer en toute sécurité l'un avec l'autre.
 
 Si vous ne répondez pas aux exigences ci-dessus, votre nœud apparaîtra comme « hors ligne » jusqu'à ce que les deux couches soient synchronisées et authentifiées.
-
 </ExpandableCard>
 
 <ExpandableCard
-title="Développeurs de dApps et de contrats intelligents"
-contentPreview="The Merge was designed to have minimal impact on smart contract and dapp developers."
+title="Développeurs de dapps et de contrats intelligents"
+contentPreview="La Fusion a été conçue pour avoir un impact minimal sur les développeurs de contrats intelligents et de dapps."
 id="developers">
 
 La Fusion s'est accompagnée de changements apportés au consensus, qui incluent également des changements liés à :
@@ -106,75 +105,70 @@ La Fusion s'est accompagnée de changements apportés au consensus, qui incluent
   <li>concept de <em>safe head</em> et de <em>blocs finalisés</em></li>
 </ul>
 
-Pour plus d'informations, consultez ce billet de blog de Tim Beiko sur <a href="https://blog.ethereum.org/2021/11/29/how-the-merge-impacts-app-layer">Comment La Fusion a un impact sur la couche d'application d'Ethereum</a>.
-
+Pour plus d'informations, consultez ce billet de blog de Tim Beiko sur <a href="https://blog.ethereum.org/2021/11/29/how-the-merge-impacts-app-layer/">Comment La Fusion a un impact sur la couche d'application d'Ethereum</a>.
 </ExpandableCard>
 
-## La Fusion et la consommation énergétique {#merge-and-energy}
+## La Fusion et la consommation d'énergie {#merge-and-energy}
 
-La Fusion marque la fin de la preuve de travail pour Ethereum, et le début d'un Ethereum plus durable et plus écologique. La consommation énergétique d'Ethereum a chuté d'environ 99,95 %, faisant de l'Ethereum une blockchain verte. Apprenez-en plus à propos de [la consommation énergétique d'Ethereum](/energy-consumption/).
+La Fusion marque la fin de la preuve de travail pour Ethereum, et le début d'un Ethereum plus durable et plus écologique. La consommation énergétique d'Ethereum a chuté d'environ 99,95 %, faisant de l'Ethereum une blockchain verte. En savoir plus sur [la consommation d'énergie d'Ethereum](/energy-consumption/).
 
-## La Fusion et la fragmentation {#merge-and-scaling}
+## La Fusion et l'évolutivité {#merge-and-scaling}
 
-La Fusion permet également de préparer le terrain pour d'autres améliorations des mises à niveau non envisageables avec la preuve de travail, en rapprochant Ethereum d'une étape de la réalisation d'évolutivité, de sécurité et de durabilité décrite dans la [vision d'Ethereum](/roadmap/).
+La Fusion a également préparé le terrain pour de nouvelles mises à niveau d'évolutivité qui n'étaient pas possibles avec la preuve de travail, rapprochant ainsi Ethereum de la réalisation de la pleine échelle, de la sécurité et de la durabilité vers lesquelles [sa feuille de route](/roadmap/) tend.
 
-## Les idées fausses sur La Fusion {#misconceptions}
+## Idées reçues sur La Fusion {#misconceptions}
 
 <ExpandableCard
-title="Idée reçue : &quot;L'exécution d'un nœud nécessite la mise en jeu de 32 ETH.&quot;"
-contentPreview="False. Anyone is free to sync their own self-verified copy of Ethereum (i.e., run a node). No ETH is required—not before The Merge, not after The Merge, not ever.">
+title="Idée reçue : &quot;L'exécution d'un nœud nécessite de mettre en jeu 32 ETH.&quot;"
+contentPreview="Faux. Tout le monde est libre de synchroniser sa propre copie auto-vérifiée d'Ethereum (c'est-à-dire, d'exécuter un nœud). Aucun ETH n'est requis — ni avant La Fusion, ni après La Fusion, ni jamais.">
 
 Il existe deux types de nœuds sur Ethereum : ceux qui peuvent proposer de nouveaux blocs, et ceux qui ne le peuvent pas.
 
 Les nœuds qui peuvent proposer des blocs représentent une petite fraction du nombre total de nœuds existants. Cette catégorie inclut les nœuds de minage sous preuve de travail (PoW) et les nœuds des validateurs sous preuve d'enjeu (PoS). Cette catégorie nécessite d'engager des ressources économiques (que ce soient le pouvoir d'hachage des GPU pour la preuve de travail ou des ETH mis en jeu par les validateurs en preuve d'enjeu) afin de pouvoir, occasionnellement, proposer un nouveau bloc et gagner les récompenses offertes par le protocole.
 
-Les autres nœuds sur le réseau (la majorité en fait) ne nécessitent pas d'engager des ressources économiques, exception faite d'un ordinateur grand public bénéficiant d'un ou deux TO de stockage disponible et d'une connexion internet. Ces nœuds ne proposent pas de blocs mais ils jouent quand même un rôle critique dans la sécurité du réseau, en tenant tous les promoteurs responsables de l'énumération des blocs déjà existants et de la vérification de la validité des nouveaux blocs, conformément aux règles de consensus du réseau. Si le bloc est valide, le noeud permettra sa diffusion sur le réseau. Si le bloc n'est pas valable pour une raison quelconque, le logiciel ne le considérera pas valable et empêchera sa propagation.
+Les autres nœuds du réseau (c'est-à-dire la majorité) ne sont pas tenus d'engager des ressources économiques au-delà d'un ordinateur grand public avec 1 à 2 To de stockage disponible et une connexion Internet. Ces nœuds ne proposent pas de blocs mais ils jouent quand même un rôle critique dans la sécurité du réseau, en tenant tous les promoteurs responsables de l'énumération des blocs déjà existants et de la vérification de la validité des nouveaux blocs, conformément aux règles de consensus du réseau. Si le bloc est valide, le noeud permettra sa diffusion sur le réseau. Si le bloc n'est pas valable pour une raison quelconque, le logiciel ne le considérera pas valable et empêchera sa propagation.
 
 L’exécution d’un nœud non producteur de blocs est possible pour toute personne sous l’un ou l’autre mécanisme de consensus (preuve de travail ou preuve d'enjeu) ; c'est <em>fortement encouragé</em> pour tous les utilisateurs s'ils en ont les moyens. L'exécution d'un noeud est extrêmement précieuse pour Ethereum et permet à chaque personne qui opère son propre noeud de bénéficier d'avantages supplémentaires en matière de sécurité, de vie privée, et de résistance à la censure améliorées.
 
 La possibilité pour quiconque de pouvoir exécuter son propre noeud est <em>absolument essentielle</em> afin de maintenir la décentralisation du réseau Ethereum.
 
-[En savoir plus sur l'exécution de son propre nœud](/run-a-node/)
-
+[En savoir plus sur l'exécution de votre propre nœud](/run-a-node/)
 </ExpandableCard>
 
 <ExpandableCard
 title="Idée reçue : &quot;La Fusion n'a pas réussi à réduire les frais de gaz.&quot;"
-contentPreview="False. The Merge was a change of consensus mechanism, not an expansion of network capacity, and was never intended to lower gas fees.">
+contentPreview="Faux. La Fusion était un changement de mécanisme de consensus, pas une augmentation de la capacité du réseau, et n'a jamais été destinée à réduire les frais de gaz.">
 
 Les frais de gaz sont le produit des demandes envoyées au réseau par rapport à sa capacité. La Fusion a rendu obsolète l'utilisation de la preuve de travail pour une transition vers le consensus par la preuve d'enjeu, mais elle n'a pas modifié de manière significative les paramètres qui influencent directement la capacité ou le débit du réseau.
 
-Avec une <a href="https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698">feuille de route axée sur les rollups</a>, les efforts sont concentrés sur la mise à l'échelle de l'activité des utilisateurs sur la [couche 2](/layer-2/), tout en activant le réseau principal de couche 1 en tant que couche de règlement décentralisée, sécurisée et optimisée pour le stockage de données cumulatives afin de rendre les transactions rollups exponentiellement moins chères. La transition vers la preuve d'enjeu est une étape préalable essentielle afin de réaliser cela. [Plus d'infos sur le gaz et les frais](/developers/docs/gas/)
-
+Avec une <a href="https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698">feuille de route centrée sur le rollup</a>, les efforts sont concentrés sur la mise à l'échelle de l'activité des utilisateurs au niveau de la [couche 2](/layer-2/), tout en permettant au réseau principal de couche 1 d'être une couche de règlement décentralisée sécurisée optimisée pour le stockage des données de rollup afin de rendre les transactions de rollup exponentiellement moins chères. La transition vers la preuve d'enjeu est une étape préalable essentielle afin de réaliser cela. [En savoir plus sur le gaz et les frais.](/developers/docs/gas/)
 </ExpandableCard>
 
 <ExpandableCard
 title="Idée reçue : &quot;Les transactions ont été considérablement accélérées par La Fusion.&quot;"
-contentPreview="False. Though some slight changes exist, transaction speed is mostly the same on layer 1 now as it was before The Merge.">
-La « vitesse » d'une transaction peut être mesurée de différentes façons, y compris le délai à inclure dans un bloc et le temps pour la finalisation. Ces deux facteurs sont légèrement modifiés, mais pas dans des proportions suffisantes pour que les utilisateurs le remarquent.
-
-Historiquement, concernant la preuve de travail, l'objectif était de permettre la création d'un nouveau bloc toutes les 13,3 secondes. Avec la preuve d'enjeu, cette production sera effective toutes les 12 secondes, ce qui constituera à chaque fois une opportunité pour un validateur de publier un nouveau bloc. La plupart des slots ont des blocs, mais pas nécessairement tous (lorsqu'un validateur est hors ligne). Avec la preuve d'enjeu, les blocs sont produits ~10 % plus fréquemment qu'avec la preuve de travail. Il s'agit d'un changement trop insignifiant pour qu'il soit réellement perçu par les utilisateurs.
+contentPreview="Faux. Bien que de légers changements existent, la vitesse des transactions sur la couche 1 est maintenant sensiblement la même qu'avant La Fusion.">
+La &quot;vitesse&quot; d'une transaction peut être mesurée de plusieurs manières, y compris le temps nécessaire pour être incluse dans un bloc et le temps de finalisation. Ces deux facteurs sont légèrement modifiés, mais pas dans des proportions suffisantes pour que les utilisateurs le remarquent.
 
-La preuve d’enjeu a introduit le concept de finalité des transactions qui n’existait pas auparavant. Avec la de preuve de travail, la possibilité d'inverser un bloc devient exponentiellement plus difficile avec chaque nouveau bloc créé, mais elle n'atteindra jamais zéro. Avec la preuve d'enjeu, les blocs sont regroupés dans des périodes (6,4 minutes de temps contenant 32 chances pour les blocs) sur lesquelles les validateurs votent. Lorsqu'une période se termine, les validateurs se prononcent sur la question de savoir s'il faut considérer la période comme « justifiée ». Si les validateurs acceptent de justifier la période, elle sera finalisée lors de la prochaine période. L'annulation des transactions finalisées n'est pas viable économiquement, car cela nécessiterait l'obtention et la combustion de plus d'un tiers du total de l'ETH misé.
+Historiquement, concernant la preuve de travail, l'objectif était de permettre la création d'un nouveau bloc toutes les 13,3 secondes. Avec la preuve d'enjeu, cette production sera effective toutes les 12 secondes, ce qui constituera à chaque fois une opportunité pour un validateur de publier un nouveau bloc. La plupart des créneaux ont des blocs, mais pas nécessairement tous (c'est-à-dire qu'un validateur est hors ligne). Avec la preuve d'enjeu, les blocs sont produits ~10 % plus fréquemment qu'avec la preuve de travail. Il s'agit d'un changement trop insignifiant pour qu'il soit réellement perçu par les utilisateurs.
 
+La preuve d’enjeu a introduit le concept de finalité des transactions qui n’existait pas auparavant. Avec la de preuve de travail, la possibilité d'inverser un bloc devient exponentiellement plus difficile avec chaque nouveau bloc créé, mais elle n'atteindra jamais zéro. Avec la preuve d'enjeu, les blocs sont regroupés dans des périodes (6,4 minutes de temps contenant 32 chances pour les blocs) sur lesquelles les validateurs votent. Lorsqu'une période se termine, les validateurs se prononcent sur la question de savoir s'il faut considérer la période comme « justifiée ». Si les validateurs acceptent de justifier la période, elle sera finalisée lors de la prochaine période. L'annulation des transactions finalisées est économiquement non viable, car elle nécessiterait d'obtenir et de brûler plus d'un tiers du total des ETH mis en jeu.
 </ExpandableCard>
 
 <ExpandableCard
-title="Idée reçue : &quot;La Fusion a permis la mise en jeu des retraits.&quot;"
-contentPreview="False, but staking withdrawals have since been enabled via the Shanghai/Capella upgrade.">
+title="Idée reçue : &quot;La Fusion a activé les retraits de staking.&quot;"
+contentPreview="Faux, mais les retraits de staking ont depuis été activés via la mise à niveau Shanghai/Capella.">
 
 Initialement après La Fusion, les stakers ne pouvaient accéder qu'à des frais de priorité et MEV qui ont été gagnés à la suite de propositions de blocs. Ces récompenses sont créditées sur un compte non-staking contrôlé par le validateur (connu sous le nom de <em>bénéficiaire de frais</em>) et sont disponibles immédiatement. Ces récompenses sont séparées des récompenses de protocole pour l'exercice de fonctions de validateur.
 
 Depuis la mise à niveau du réseau Shanghai/Capella, les validateurs peuvent maintenant désigner <em>une adresse de retrait</em> pour commencer à recevoir des paiements automatiques de tout solde excédentaire de mise en jeu (plus de 32 ETH à partir de récompenses de protocole). Cette mise à jour a également permis à un validateur de déverrouiller et de récupérer tout son solde en quittant le réseau.
 
-[En savoir plus sur les retraits de mise en jeu](/staking/withdrawals/)
-
+[En savoir plus sur les retraits](/staking/withdrawals/)
 </ExpandableCard>
 
 <ExpandableCard
-title="Mauvaise conception : &quot;Maintenant que La Fusion est terminée, et que les retraits sont activés, les stakers pourraient tous sortir en même temps.&quot;"
-contentPreview="False. Validator exits are rate limited for security reasons.">
-Depuis que les retraits ont été activés à la suite de la mise à jour Shanghai/Capella, tous les validateurs seront incités à retirer leur solde d'ETH si celui-ci est supérieur à 32 car ces fonds n'augmentent pas le rendement et sont par ailleurs bloqués. En fonction de l'APR (déterminé par l'ETH total mis en jeu), ils peuvent être encouragés à quitter leur(s) validateur(s) pour récupérer leur solde en entier ou potentiellement en miser encore plus en utilisant leurs récompenses pour obtenir plus de rendement.
+title="Idée reçue : &quot;Maintenant que La Fusion est terminée et que les retraits sont activés, les validateurs pourraient tous se retirer en même temps.&quot;"
+contentPreview="Faux. Les sorties de validateurs sont limitées pour des raisons de sécurité.">
+Depuis que la mise à niveau Shanghai/Capella a activé les retraits, les validateurs sont incités à retirer leur solde de mise supérieur à 32 ETH, car ces fonds n'augmentent pas le rendement et sont autrement bloqués. En fonction de l'APR (déterminé par l'ETH total mis en jeu), ils peuvent être encouragés à quitter leur(s) validateur(s) pour récupérer leur solde en entier ou potentiellement en miser encore plus en utilisant leurs récompenses pour obtenir plus de rendement.
 
 Une mise en garde importante ici : les sorties complètes des validateurs sont limitées par le protocole, et seul un nombre limité de validateurs peuvent sortir par période (toutes les 6,4 minutes). Cette limite fluctue en fonction du nombre de validateurs actifs, mais passe à environ 0,33 % du total des ETH stakés qui peuvent être sortis du réseau en une seule journée.
 
@@ -194,15 +188,15 @@ Pour limiter la confusion, la communauté a mis à jour ces termes :
 
 Ces mises à jour d'ordre terminologique ne concernent que les conventions de nommage ; les objectifs et la feuille de route d'Ethereum restent inchangés.
 
-[En savoir plus sur le changement de nom « Eth2 »](https://blog.ethereum.org/2022/01/24/the-great-eth2-renaming)
+[En savoir plus sur le changement de nom de l'« Eth2 »](https://blog.ethereum.org/2022/01/24/the-great-eth2-renaming/)
 
 ## Relation entre les mises à niveau {#relationship-between-upgrades}
 
-Les mises à niveau Ethereum sont plus ou moins interdépendantes. Alors résumons comment la fusion est liée aux autres mises à niveau.
+Les mises à niveau d'Ethereum sont plus ou moins interdépendantes. Alors résumons comment la fusion est liée aux autres mises à niveau.
 
-### La Fusion et la chaîne phare {#merge-and-beacon-chain}
+### La Fusion et la Chaîne phare {#merge-and-beacon-chain}
 
-La Fusion représente l'adoption formelle de la Chaîne phare comme nouvelle couche de consensus pour la couche d'exécution sur le réseau principal d'origine. Depuis La Fusion, les validateurs sont affectés au réseau principal sécurisé d'Ethereum et le minage par [preuve de travail](/developers/docs/consensus-mechanisms/pow/) n'est plus un moyen valide de production de blocs.
+La Fusion représente l'adoption formelle de la Chaîne phare comme nouvelle couche de consensus pour la couche d'exécution sur le réseau principal d'origine. Depuis La Fusion, les validateurs sont chargés de sécuriser le Mainnet d'Ethereum, et le minage en [preuve de travail](/developers/docs/consensus-mechanisms/pow/) n'est plus un moyen valide de production de blocs.
 
 Les blocs sont dès lors proposés par validation des nœuds qui ont misé l'ETH en échange du droit de participer au consensus. Ces mises à niveau permettent de préparer le terrain pour de futures améliorations d'évolutivité, y compris la fragmentation.
 
@@ -210,15 +204,15 @@ Les blocs sont dès lors proposés par validation des nœuds qui ont misé l'ETH
   La Chaîne phare
 </ButtonLink>
 
-### La Fusion et la mise à niveau de Shanghai {#merge-and-shanghai}
+### La Fusion et la mise à niveau Shanghai {#merge-and-shanghai}
 
 Afin de simplifier et de permettre une transition aussi rapide et réussie que possible vers le système de preuve d'enjeu, la mise à jour vers La Fusion n'intègre pas certaines fonctionnalités anticipées telles que, par exemple, la possibilité de retirer les ETH bloqués sur la chaîne phare. Cette fonctionnalité a été activée séparément avec la mise à niveau Shanghai/Capella.
 
-Pour ceux qui sont curieux, apprenez-en plus sur [Ce qui se passe après la fusion](https://youtu.be/7ggwLccuN5s?t=101), une présentation par Vitalik lors de l'événement ETHGlobal d'avril 2021.
+Pour les curieux, apprenez-en plus sur [What Happens After The Merge](https://youtu.be/7ggwLccuN5s?t=101), présenté par Vitalik lors de l'événement ETHGlobal d'avril 2021.
 
 ### La Fusion et la fragmentation {#merge-and-data-sharding}
 
-Initialement, l'objectif était de travailler sur la fragmentation avant la Fusion afin d'optimiser l'évolutivité d'Ethereum. Cela dit, avec l'expansion des [solutions d'évolutivité de la couche 2](/layer-2/), la priorité a été de passer de la preuve de travail à la preuve d'enjeu.
+Initialement, l'objectif était de travailler sur la fragmentation avant la Fusion afin d'optimiser l'évolutivité d'Ethereum. Cependant, avec l'essor des [solutions d'évolutivité de couche 2](/layer-2/), la priorité a été de passer d'abord de la preuve de travail à la preuve d'enjeu.
 
 Les plans liés à la fragmentation évoluent rapidement, mais compte tenu du développement et du succès rencontré par les technologies de couche 2 visant à augmenter l'évolutivité de l'exécution des transactions, ces plans de fragmentation ont été modifiés afin de trouver la meilleure manière de répartir le poids lié au stockage des données d'appel comprimées émanant des contrats roll-up et de permettre la croissance exponentielle du réseau. Cela ne serait pas possible sans opérer d'abord une transition vers le système de preuve d'enjeu.
 
@@ -226,7 +220,7 @@ Les plans liés à la fragmentation évoluent rapidement, mais compte tenu du d
   Fragmentation
 </ButtonLink>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 <MergeArticleList />
 
diff --git a/public/content/translations/fr/roadmap/merge/issuance/index.md b/public/content/translations/fr/roadmap/merge/issuance/index.md
index 834377f1d9d..69c15a001c6 100644
--- a/public/content/translations/fr/roadmap/merge/issuance/index.md
+++ b/public/content/translations/fr/roadmap/merge/issuance/index.md
@@ -4,117 +4,123 @@ description: Analyse de l'impact de La Fusion sur l'offre d'ETH
 lang: fr
 ---
 
-# Impact de La Fusion sur l'offre d'ETH {#how-the-merge-impacts-ETH-supply}
+# Comment La Fusion a affecté l'offre d'ETH {#how-the-merge-impacts-ETH-supply}
 
-La Fusion a marqué la transition du réseau Ethereum de la preuve de travail à la preuve d'enjeu, qui a eu lieu en septembre 2022. La manière dont l'ETH est émis a subi des changements lors de cette transition. Auparavant, de nouveaux ETH étaient émis à partir de deux sources : la couche d'exécution (c'est-à-dire Réseau principal) et la couche de consensus (c'est-à-dire  la chaîne phare). Depuis La Fusion, l'émission sur la couche d'exécution est désormais nulle. Analysons cela en détail.
+La Fusion a représenté la transition du réseau Ethereum de la preuve de travail à la preuve d'enjeu, qui a eu lieu en septembre 2022. La manière dont l'ETH est émis a subi des changements lors de cette transition. Auparavant, les nouveaux ETH étaient émis à partir de deux sources : la couche d'exécution (c.-à-d. le réseau principal) et la couche de consensus (c.-à-d. la chaîne phare). Depuis La Fusion, l'émission sur la couche d'exécution est désormais nulle. Analysons cela en détail.
 
-## La répartition de l'émission d'ETH {#components-of-eth-issuance}
+## Composants de l'émission d'ETH {#components-of-eth-issuance}
 
 Nous pouvons diviser l'offre d'ETH en deux composantes principales : l'émission et la destruction en le brulant.
 
-**L'émission** d'ETH est le processus de création d'ETH qui n'existait pas auparavant. Le **brûlage** de l'ETH se produit lorsque l'ETH existant est détruit, le retirant de la circulation. Le taux d'émission et de destruction est calculé par plusieurs paramètres, et l'équilibre entre eux détermine le taux d'inflation/déflation résultant de l'éther.
+L'**émission** d'ETH est le processus de création d'ETH qui n'existait pas auparavant. Le **brûlage** de l'ETH a lieu lorsque de l'ETH existant est détruit, le retirant de la circulation. Le taux d'émission et de destruction est calculé par plusieurs paramètres, et l'équilibre entre eux détermine le taux d'inflation/déflation résultant de l'éther.
 
 <Card
 emoji=":chart_decreasing:"
-title="Résumé de l'émission d'ETH">
+title="Émission d'ETH en bref">
 
 - Avant la transition vers la preuve d'enjeu, les mineurs recevaient environ 13 000 ETH/jour
-- Les validateurs reçoivent environ 1 700 ETH/jour, basés sur un total d'environ 14 millions d'ETH mis en jeu
-- L'émission exacte liée à la preuve d'enjeu fluctue en fonction du montant total d'ETH mis en jeu
-- **Depuis La Fusion, seul le ~1 700 ETH/jour subsiste, réduisant l'émission totale d'ETH neuf de ~88 %**
-- La destruction en brûlant : celle-ci varie en fonction de la demande du réseau. _Si_ un prix moyen du gaz d'au moins 16 gwei est observé pour une journée donnée, cela compense totalement les ~1 700 ETH émis pour les validateurs et ramène l'inflation nette d'ETH à zéro ou moins pour cette journée.
-
+- Les validateurs reçoivent environ 1 700 ETH/jour, sur la base d'environ 14 millions d'ETH au total mis en jeu
+- L'émission exacte de la mise en jeu fluctue en fonction du montant total d'ETH mis en jeu
+- **Depuis La Fusion, seuls les ~1 700 ETH/jour subsistent, ce qui fait chuter l'émission totale de nouveaux ETH de ~88 %**
+- Le brûlage : Il fluctue en fonction de la demande du réseau. _Si_ un prix moyen du gaz d'au moins 16 gwei est observé pour une journée donnée, cela compense totalement les ~1 700 ETH émis pour les validateurs et ramène l'inflation nette d'ETH à zéro ou moins pour cette journée.
 </Card>
 
-## Avant la fusion (historique) {#pre-merge}
+## Avant La Fusion (historique) {#pre-merge}
 
 ### Émission de la couche d'exécution {#el-issuance-pre-merge}
 
-En preuve de travail, les mineurs n'interagissaient qu'avec la couche d'exécution et étaient récompensés par des récompenses de bloc, si et seulement s'ils étaient les premiers mineurs à résoudre le nouveau bloc. Depuis [la mise à jour Constantinople](/ethereum-forks/#constantinople) en 2019, cette récompense était de 2 ETH par bloc. Les mineurs étaient également récompensés pour la publication de blocs [oncle](/glossary/#ommer), qui étaient des blocs valides mais qui n'avaient pas abouti à la chaîne la plus longue/canonique. Ces récompenses étaient plafonnées à 1,75 ETH par bloc oncle et _s'ajoutaient à_ la récompense émise à partir du bloc canonique. Le processus de minage était une activité économiquement intensive, qui nécessitait historiquement des niveaux élevés d'émission d'ETH pour être soutenu.
+En preuve de travail, les mineurs n'interagissaient qu'avec la couche d'exécution et étaient récompensés par des récompenses de bloc, si et seulement s'ils étaient les premiers mineurs à résoudre le nouveau bloc. Depuis la [mise à niveau Constantinople](/ethereum-forks/#constantinople) en 2019, cette récompense était de 2 ETH par bloc. Les mineurs étaient également récompensés pour la publication de blocs [ommer](/glossary/#ommer), qui étaient des blocs valides n'ayant pas abouti à la chaîne la plus longue/canonique. Ces récompenses étaient plafonnées à 1,75 ETH par ommer et s'ajoutaient _en plus de_ la récompense émise par le bloc canonique. Le processus de minage était une activité économiquement intensive, qui nécessitait historiquement des niveaux élevés d'émission d'ETH pour être soutenu.
 
 ### Émission de la couche de consensus {#cl-issuance-pre-merge}
 
-La [Chaîne phare](/ethereum-forks/#beacon-chain-genesis) est entrée en service en 2020. Au lieu de mineurs, elle est sécurisée par des validateurs utilisant la preuve d'enjeu. Cette chaîne a été lancée grâce aux utilisateurs d'Ethereum qui déposaient de l'ETH de manière unidirectionnelle dans un contrat intelligent sur le réseau principal (la couche d'exécution), que la Chaîne phare écoute, en créditant l'utilisateur d'une quantité égale d'ETH sur la nouvelle chaîne. Jusqu'à ce que La Fusion ait lieu, les validateurs de la Chaîne phare ne traitaient pas les transactions et avaient seulement comme mission d'établir un consensus sur l'état du groupe de validateurs lui-même.
+La [chaîne phare](/ethereum-forks/#beacon-chain-genesis) a été mise en service en 2020. Au lieu de mineurs, elle est sécurisée par des validateurs utilisant la preuve d'enjeu. Cette chaîne a été lancée grâce aux utilisateurs d'Ethereum qui déposaient de l'ETH de manière unidirectionnelle dans un contrat intelligent sur le réseau principal (la couche d'exécution), que la Chaîne phare écoute, en créditant l'utilisateur d'une quantité égale d'ETH sur la nouvelle chaîne. Jusqu'à ce que La Fusion ait lieu, les validateurs de la Chaîne phare ne traitaient pas les transactions et avaient seulement comme mission d'établir un consensus sur l'état du groupe de validateurs lui-même.
 
-Les validateurs de la Chaîne phare sont récompensés en ETH pour attester de l'état de la chaîne et proposer des blocs. Les récompenses (ou les pénalités) sont calculées et distribuées à chaque période (toutes les 6,4 minutes) en fonction des performances des validateurs. Les récompenses des validateurs sont **nettement** moins élevées que les récompenses de minage qui étaient précédemment émises sous la preuve de travail (2 ETH toutes les ~13,5 secondes), car l'exploitation d'un nœud de validation n'est pas aussi économiquement intense et ne nécessite donc ni ne garantit une récompense aussi élevée.
+Les validateurs de la Chaîne phare sont récompensés en ETH pour attester de l'état de la chaîne et proposer des blocs. Les récompenses (ou les pénalités) sont calculées et distribuées à chaque période (toutes les 6,4 minutes) en fonction des performances des validateurs. Les récompenses des validateurs sont **nettement** moins élevées que les récompenses de minage qui étaient précédemment émises sous la preuve de travail (2 ETH toutes les ~13,5 secondes), car l'exploitation d'un nœud de validation n'est pas aussi intense sur le plan économique et ne nécessite donc ni ne garantit une récompense aussi élevée.
 
-### Répartition de l'émission avant la fusion {#pre-merge-issuance-breakdown}
+### Répartition des émissions avant La Fusion {#pre-merge-issuance-breakdown}
 
 Offre totale d'ETH : **~120 520 000 ETH** (au moment de La Fusion en septembre 2022)
 
-**Émission de la couche d'exécution :**
+**Émission de la couche d'exécution:**
 
-- Était estimée à 2,08 ETH par période de 13,3 secondes\* : **~4 930 000** ETH émis en un an
-- Entraînant un taux d'inflation **d'environ 4,09 %** (4,93 millions par an / 120,5 millions au total)
-- \*Cela comprend les 2 ETH par bloc canonique, ainsi qu'une moyenne de 0,08 ETH sur la durée provenant des blocs oncles. En utilisant également 13,3 secondes, le temps cible de base pour un bloc sans aucune influence de la [bombe de difficulté](/glossary/#difficulty-bomb). ([Voir la source](https://bitinfocharts.com/ethereum/))
+- A été estimée à 2,08 ETH par 13,3 secondes\* : **~4 930 000** ETH émis en un an
+- A entraîné un taux d'inflation d'**environ 4,09 %** (4,93 M par an / 120,5 M au total)
+- \*Cela comprend les 2 ETH par bloc canonique, ainsi qu'une moyenne de 0,08 ETH sur la durée provenant des blocs oncles. Utilise également 13,3 secondes, le temps de bloc cible de référence sans aucune influence d'une [bombe de difficulté](/glossary/#difficulty-bomb). ([Voir la source](https://bitinfocharts.com/ethereum/))
 
-**Émission de la couche de consensus :**
+**Émission de la couche de consensus:**
 
-- En utilisant un total de 14 000 000 d'ETH en jeu, le taux d'émission d'ETH est d'environ 1 700 ETH par jour ([Voir la source](https://ultrasound.money/))
-- Cela résulte en **~620 500** ETH émis en un an
-- Cela a entraîné un taux d'inflation **d'environ 0,52 %** (620,5 K par an / 119,3 M au total)
+- Avec un total de 14 000 000 d'ETH mis en jeu, le taux d'émission d'ETH est d'environ 1 700 ETH/jour ([Voir la source](https://ultrasound.money/))
+- Résultat : **~620 500** ETH émis en un an
+- A entraîné un taux d'inflation d'**environ 0,52 %** (620,5 k par an / 119,3 M au total)
 
 <Alert variant="update">
 <AlertContent>
 <AlertDescription>
-**Taux d'émission annuel totalisé (avant la fusion) : ~4,61 %** (4,09 % + 0,52 %)
+**Taux d'émission annualisé total (avant La Fusion) : ~4,61 %** (4,09 % + 0,52 %)
 
-**~88,7 %** de l'émission allaient aux mineurs de la couche d'exécution (4,09 / 4,61 * 100)
+**~88,7 %** de l'émission était destinée aux mineurs sur la couche d'exécution (4,09 / 4,61 \* 100)
 
-**~11,3 %** étaient émis aux validateurs de la couche de consensus (0,52 / 4,61 * 100)
+**~11,3 %** étaient émis aux validateurs sur la couche de consensus (0,52 / 4,61 \* 100)
 </AlertDescription>
+
 </AlertContent>
+
 </Alert>
 
-## Après la fusion (à présent) {#post-merge}
+## Après La Fusion (actuellement) {#post-merge}
 
 ### Émission de la couche d'exécution {#el-issuance-post-merge}
 
-L'émission de la couche d'exécution depuis La Fusion est nulle. La preuve de travail n'est plus un moyen valide de production de blocs selon les nouvelles règles de consensus. Toute l'activité de la couche d'exécution est regroupée dans des « blocs de phare », qui sont publiés et attestés par les validateurs de la preuve d'enjeu. Les récompenses pour l'attestation et la publication des blocs de phare sont comptabilisées séparément sur la couche de consensus.
+L'émission de la couche d'exécution depuis La Fusion est nulle. La preuve de travail n'est plus un moyen valide de production de blocs selon les règles de consensus mises à niveau. Toute l'activité de la couche d'exécution est regroupée en « blocs-phare », qui sont publiés et attestés par des validateurs de preuve d'enjeu. Les récompenses pour l'attestation et la publication des blocs-phare sont comptabilisées séparément sur la couche de consensus.
 
 ### Émission de la couche de consensus {#cl-issuance-post-merge}
 
-L'émission de la couche de consensus se poursuit aujourd'hui comme avant La Fusion, avec des récompenses pour les validateurs qui attestent et proposent des blocs. Les récompenses des validateurs continuent de s'accumuler sur _les soldes des validateurs_ qui sont gérés au sein de la couche de consensus. Contrairement aux comptes actuels (« comptes d'exécution »), qui peuvent effectuer des transactions sur le réseau principal, ces comptes Ethereum séparés ne peuvent pas effectuer librement des transactions avec d'autres comptes Ethereum. Les fonds de ces comptes ne peuvent être retirés que vers une seule adresse d'exécution préalablement spécifiée.
+L'émission sur la couche de consensus se poursuit aujourd'hui comme avant La Fusion, avec de petites récompenses pour les validateurs qui attestent et proposent des blocs. Les récompenses des validateurs continuent de s'accumuler sur les _soldes des validateurs_ qui sont gérés au sein de la couche de consensus. Contrairement aux comptes actuels (comptes d'« exécution »), qui peuvent effectuer des transactions sur le réseau principal, ces comptes Ethereum séparés ne peuvent pas effectuer librement des transactions avec d'autres comptes Ethereum. Les fonds de ces comptes ne peuvent être retirés que vers une seule adresse d'exécution spécifiée.
 
-Depuis la mise à jour de Shanghai/Capella qui a eu lieu en avril 2023, ces retraits ont été activés pour les validateurs. Les stakers sont incités à retirer leurs _gains/récompenses (solde supérieur à 32 ETH)_ car ces fonds ne contribuent pas plus à leur poids d'enjeu (qui atteint un maximum à 32).
+Depuis la mise à niveau Shanghai/Capella qui a eu lieu en avril 2023, ces retraits ont été activés pour les validateurs. Les validateurs sont incités à retirer leurs _gains/récompenses (solde supérieur à 32 ETH)_ car ces fonds ne contribuent pas autrement à leur poids de mise (qui est plafonné à 32).
 
 Les validateurs peuvent également choisir de sortir et de retirer l'intégralité de leur solde de validateur. Pour garantir la stabilité d'Ethereum, le nombre de validateurs quittant simultanément est plafonné.
 
 Environ 0,33 % du nombre total de validateurs peuvent sortir en une journée donnée. Par défaut, quatre (4) validateurs peuvent sortir par période (toutes les 6,4 minutes, soit 900 par jour). Un (1) validateur supplémentaire est autorisé à sortir pour chaque 65 536 (2<sup>16</sup>) validateurs supplémentaires au-delà de 262 144 (2<sup>18</sup>). Par exemple, avec plus de 327 680 validateurs, cinq (5) peuvent sortir par période (1 125 par jour). Six (6) seront autorisés avec un nombre total de validateurs actifs supérieur à 393 216, et ainsi de suite.
 
-À mesure que davantage de validateurs se retirent, le nombre maximum de validateurs sortants sera progressivement réduit à un minimum de quatre pour empêcher intentionnellement de grandes quantités d'ETH en jeu d'être retirées simultanément, ce qui pourrait provoquer des perturbations majeures.
+À mesure que de plus en plus de validateurs se retirent, le nombre maximal de validateurs sortants sera progressivement réduit à un minimum de quatre afin d'empêcher intentionnellement le retrait simultané de montants importants et déstabilisateurs d'ETH mis en jeu.
 
-### Répartition de l'inflation après la fusion {#post-merge-inflation-breakdown}
+### Répartition de l'inflation après La Fusion {#post-merge-inflation-breakdown}
 
 - Offre totale d'ETH : **~120 520 000 ETH** (au moment de La Fusion en septembre 2022)
 - Émission de la couche d'exécution : **0**
-- Émission de la couche de consensus : Identique à ce qui précède, taux d'émission annualisé d'environ **0,52 %** (avec un total de 14 millions d'ETH en jeu)
+- Émission de la couche de consensus : Identique à ce qui précède, taux d'émission annualisé de **~0,52 %** (avec un total de 14 millions d'ETH mis en jeu)
 
 <Alert variant="update">
 <AlertContent>
 <AlertDescription>
 Taux d'émission annualisé total : **~0,52 %**
 
-Réduction nette de l'émission annuelle d'ETH : **~88,7 %** ((4,61 % - 0,52 %) / 4,61 % * 100)
+Réduction nette de l'émission annuelle d'ETH : **~88,7 %** ((4,61 % - 0,52 %) / 4,61 % \* 100)
 </AlertDescription>
+
 </AlertContent>
+
 </Alert>
 
-## <Emoji text=":fire:" size="1" />La destruction par brûlage {#the-burn}
+## <Emoji text=":fire:" size="1" /> La combustion {#the-burn}
 
-La force opposée à l'émission d'ETH est le taux auquel l'ETH est brûlé. Pour qu'une transaction soit exécutée sur Ethereum, des frais minimum (appelés « frais de base ») doivent être payés, qui fluctuent continuellement (de bloc à bloc) en fonction de l'activité du réseau. Les frais sont payés en ETH et sont _nécessaires_ pour que la transaction soit considérée comme valide. Ces frais sont _brûlés_ pendant le processus de transaction, les retirant ainsi de la circulation.
+La force opposée à l'émission d'ETH est le taux auquel l'ETH est brûlé. Pour qu'une transaction soit exécutée sur Ethereum, des frais minimum (appelés « frais de base ») doivent être payés, qui fluctuent continuellement (de bloc à bloc) en fonction de l'activité du réseau. Les frais sont payés en ETH et sont _requis_ pour que la transaction soit considérée comme valide. Ces frais sont _brûlés_ pendant le processus de transaction, les retirant de la circulation.
 
 <Alert variant="update">
 <AlertContent>
 <AlertDescription>
-La combustion des frais a été mise en place avec [la mise à jour London](/ethereum-forks/#london) en août 2021 et est restée inchangée depuis la Fusion.
+
+La combustion des frais a été mise en service avec [la mise à niveau de Londres](/ethereum-forks/#london) en août 2021 et reste inchangée depuis La Fusion.
 </AlertDescription>
+
 </AlertContent>
+
 </Alert>
 
 En plus de la combustion des frais mise en œuvre par la mise à niveau London, les validateurs peuvent également subir des pénalités s'ils sont hors ligne, ou pire, ils peuvent être sanctionnés pour avoir enfreint des règles spécifiques qui menacent la sécurité du réseau. Ces pénalités entraînent une réduction d'ETH du solde du validateur, qui n'est alors pas directement donné à un autre compte, ce qui équivaut à le brûler/le retirer de la circulation.
 
-### Calcul de la moyenne du prix du gaz pour être déflationniste {#calculating-average-gas-price-for-deflation}
+### Calcul du prix moyen du gaz pour la déflation {#calculating-average-gas-price-for-deflation}
 
 Comme discuté précédemment, la quantité d'ETH émise en une journée donnée dépend de la totalité des ETH mis en jeu. Au moment de l'écriture de ses lignes, cela représente environ 1 700 ETH/jour.
 
@@ -124,26 +130,26 @@ Pour déterminer le prix moyen du gaz nécessaire pour compenser complètement c
 - `(5 blocs/minute) * (60 minutes/heure) = 300 blocs/heure`
 - `(300 blocs/heure) * (24 heures/jour) = 7 200 blocs/jour`
 
-Chaque bloc cible `15x10^6 gaz/bloc` ([plus d'informations sur le gaz](/developers/docs/gas/)). En utilisant cela, nous pouvons en déduire le prix moyen du gaz (en unités de gwei/gaz) nécessaire pour compenser l'émission, étant donné une émission quotidienne totale d'ETH de 1 700 :
+Chaque bloc cible `15x10^6 gaz/bloc` ([en savoir plus sur le gaz](/developers/docs/gas/)). En utilisant cela, nous pouvons en déduire le prix moyen du gaz (en unités de gwei/gaz) nécessaire pour compenser l'émission, étant donné une émission quotidienne totale d'ETH de 1 700 :
 
-- `7 200 blocs/jour * 15x10^6 gaz/bloc *`**` Y gwei/gaz`**`* 1 ETH/ 10^9 gwei = 1 700 ETH/jour`
+- `7200 blocs/jour * 15x10^6 gaz/bloc * `**`Y gwei/gaz`**` * 1 ETH/ 10^9 gwei = 1700 ETH/jour`
 
-En cherchant `Y` :
+Résolution pour `Y` :
 
-- `Y = (1 700(10^9))/(7 200 * 15(10^6)) = (17x10^3)/(72 * 15) = 16 gwei` (arrondi à seulement deux chiffres significatifs)
+- `Y = (1700(10^9))/(7200 * 15(10^6)) = (17x10^3)/(72 * 15) = 16 gwei` (arrondi à deux chiffres significatifs)
 
-Une autre façon de réarranger cette dernière étape serait de remplacer `1 700` par une variable `X` qui représente l'émission quotidienne d'ETH, et de simplifier le reste en :
+Une autre façon de réarranger cette dernière étape serait de remplacer `1700` par une variable `X` qui représente l'émission quotidienne d'ETH, et de simplifier le reste en :
 
 - `Y = (X(10^3)/(7200 * 15)) = X/108`
 
 Nous pouvons simplifier et écrire ceci comme une fonction de `X` :
 
-- `F(X) = X/108` où `X` représente l'émission quotidienne d'ETH et `F(X)` représente le prix en gwei requis pour compenser entièrement la nouvelle émission d'ETH.
+- `f(X) = X/108` où `X` est l'émission quotidienne d'ETH, et `f(X)` représente le prix en gwei/gaz requis pour compenser tous les nouveaux ETH émis.
 
-Ainsi, par exemple, si `X` (l'émission quotidienne d'ETH) augmente à 1 800 en fonction de la totalité des ETH mis en jeu, `f(X)` (le gwei requis pour compenser toute l'émission) serait alors de `17 gwei` (en utilisant 2 chiffres significatifs)
+Ainsi, par exemple, si `X` (émission quotidienne d'ETH) passe à 1 800 en fonction du total des ETH mis en jeu, `f(X)` (gwei requis pour compenser toute l'émission) serait alors de `17 gwei` (en utilisant 2 chiffres significatifs)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [La Fusion](/roadmap/merge/)
-- [Ultrasound.money](https://ultrasound.money/) - _Tableaux de bord disponibles pour visualiser l'émission et la destruction d'ETH en temps réel_
-- [Graphique de l'émission Ethereum](https://www.attestant.io/posts/charting-ethereum-issuance/) - _Jim McDonald 2020_
+- [Ultrasound.money](https://ultrasound.money/) - _Tableaux de bord disponibles pour visualiser l'émission et le brûlage d'ETH en temps réel_
+- [Cartographie de l'émission d'Ethereum](https://www.attestant.io/posts/charting-ethereum-issuance/) - _Jim McDonald 2020_
diff --git a/public/content/translations/fr/roadmap/pbs/index.md b/public/content/translations/fr/roadmap/pbs/index.md
index fc549b3b811..73a35d9304a 100644
--- a/public/content/translations/fr/roadmap/pbs/index.md
+++ b/public/content/translations/fr/roadmap/pbs/index.md
@@ -1,51 +1,50 @@
 ---
-title: Séparation entre le validateur et le constructeur de blocs
-description: Découvrez la raison, mais aussi de quelle manière, les validateurs d'Ethereum vont séparer leurs responsabilités concernant la construction et la diffusion de blocs.
+title: "Séparation proposeur-constructeur"
+description: "Découvrez la raison, mais aussi de quelle manière, les validateurs d'Ethereum vont séparer leurs responsabilités concernant la construction et la diffusion de blocs."
 lang: fr
 ---
 
-# Séparation entre le validateur et le constructeur de blocs {#proposer-builder-separation}
+# Séparation proposant-constructeur {#proposer-builder-separation}
 
-Actuellement, les validateurs d'Ethereum produisent _et_ diffusent les blocs. Ils regroupent les transactions dont ils ont entendu parler via le réseau d'informations et les regroupent dans un bloc qui est envoyé aux pairs du réseau Ethereum. La **séparation proposant-constructeur (PBS)** répartit ces tâches entre plusieurs validateurs. Les constructeurs de blocs deviennent ainsi responsables de la création des blocs et les remettent au proposant de blocs, lors de chaque intervalle. Le proposant de bloc ne peut voir le contenu d'un bloc, mais se dirige simplement vers le plus rentable, en payant une commission au constructeur de bloc avant d'envoyer celui-ci vers ses pairs.
+Actuellement, les validateurs d'Ethereum créent _et_ diffusent les blocs. Ils regroupent les transactions dont ils ont entendu parler via le réseau d'informations et les regroupent dans un bloc qui est envoyé aux pairs du réseau Ethereum. **La séparation proposant-constructeur (PBS)** répartit ces tâches entre plusieurs validateurs. Les constructeurs de blocs deviennent ainsi responsables de la création des blocs et les remettent au proposant de blocs, lors de chaque intervalle. Le proposant de bloc ne peut voir le contenu d'un bloc, mais se dirige simplement vers le plus rentable, en payant une commission au constructeur de bloc avant d'envoyer celui-ci vers ses pairs.
 
 C'est une mise à jour qui s'avère très importante, et ce pour plusieurs raisons. Premièrement, cela crée des opportunités afin de prévenir toute censure de transaction au niveau du protocole. Deuxièmement, cela évite que les validateurs amateurs ne soient concurrencés par des acteurs institutionnels capables de mieux optimiser la rentabilité de leur construction de blocs. Troisièmement, cela aide à faire évoluer Ethereum en permettant les mises à niveau de Danksharding.
 
-## PBS et la résistance à la censure {#pbs-and-censorship-resistance}
+## PBS et résistance à la censure {#pbs-and-censorship-resistance}
 
 La séparation entre constructeurs et proposants de blocs, rend bien plus ardue la censure des transactions par les constructeurs de blocs. En effet, des critères d'inclusion relativement complexes peuvent être ajoutés pour garantir qu'aucune censure n'a eu lieu avant que le blocage ne soit proposé. Comme le proposant du bloc est une entité distincte du constructeur du bloc, il peut assumer le rôle de protecteur contre la censure des constructeurs de blocs.
 
 Par exemple, des listes d'inclusion peuvent être introduites. Ainsi, quand les validateurs prennent connaissance des transactions mais ne les voient point incluses dans les blocs, celles-ci peuvent alors êtres rendues indispensables dans le bloc suivant. La liste d'inclusion est générée depuis le « mempool » local des proposants de blocs (liste des transactions dont ils ont connaissance), puis adressée à leurs homologues juste avant la proposition d'un bloc. Si certaines transactions de la liste d'inclusion sont manquantes, le proposant de bloc peut soit rejeter le bloc, ajouter les transactions manquantes avant de soumettre celui-ci, soit le proposer et le laisser être rejeté une fois reçu par les autres validateurs. Potentiellement, il existe aussi une version bien plus efficace de ce concept, stipulant que les constructeurs de blocs se doivent pleinement d'utiliser le bloc disponible ; en cas contraire, les transactions sont de facto ajoutées à partir de la liste d'inclusion du proposant de bloc. Il s'agit encore d'un domaine de recherche active et la configuration optimale des listes d'inclusion, n'est encore pas à ce jour, pleinement définie.
 
-[Les mempools encryptés](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpktWkixc1gUqkyc1-iE6TT0RWQTBJELe&index=3) peuvent aussi empêcher les proposants et constructeurs de blocs de connaître quelles transactions ils incluent dans un bloc, mais seulement après que ledit bloc ait été déjà émis.
+[Les mempools chiffrés](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpktWkixc1gUqkyc1-iE6TT0RWQTBJELe&index=3) pourraient également rendre impossible pour les constructeurs et les proposants de savoir quelles transactions ils incluent dans un bloc jusqu'à ce que le bloc ait déjà été diffusé.
 
-<ExpandableCard title="Quel genre de censure la séparation entre le constructeur et le proposant de blocs (PBS) résout-elle ?" eventCategory="/roadmap/pbs" eventName="clicked what kinds of censorship does PBS solve?">
+<ExpandableCard title="Quels types de censure la PBS résout-elle ?" eventCategory="/roadmap/pbs" eventName="clicked what kinds of censorship does PBS solve?">
 
 Des organisations puissantes peuvent aussi faire pression sur les validateurs pour qu'ils censurent des transactions issues ou à destination de certaines adresses. Ces derniers se plient à cette exigence en détectant les adresses blacklistées au sein de leur pool de transaction puis en les excluant de leur proposition de blocs. Après la séparation proposants et constructeurs de blocs (PBS), cette action ne sera plus possible car les proposants de blocs ne sauront pas quelles transactions ils diffusent dans leurs blocs. Il peut être important que certaines personnes ou applications se conforment aux règles de censure, par exemple lorsqu'elles sont adoptées dans leur région. Dans ces cas, la conformité se produit au niveau de l’application, tandis que le protocole reste sans autorisation et sans censure.
-
 </ExpandableCard>
 
 ## PBS et MEV {#pbs-and-mev}
 
-**Maximum Extractable Value ou Valeur Maximale Extractible (MEV)** fait référence aux validateurs maximisant leur rentabilité en ordonnant des transactions de manière profitable. Des situations courantes incluent des manipulations d'arbitrage sur les échanges décentralisés (p. ex. anticiper un achat ou une vente conséquents) ou encore identifier des opportunités de liquidation de positions DeFi. Maximiser la MEV nécessite un savoir-faire technique sophistiqué et des logiciels personnalisés ajoutés aux validateurs normaux, ce qui rend beaucoup plus probable le fait que les opérateurs institutionnels surpassent les particuliers et les validateurs amateurs au niveau des applications d'extraction MEV. Cela signifie que les rendements du stacking sont susceptibles d'être plus élevés via des opérateurs centralisés, créant ainsi un pouvoir de centralisation amené à décourager le stacking à domicile.
+La **valeur extractible maximale (MEV)** désigne le fait que les validateurs maximisent leur rentabilité en ordonnant les transactions de manière favorable. Les exemples courants incluent l'arbitrage de swaps sur les échanges décentralisés (par ex., le front-running d'une vente ou d'un achat important) ou l'identification d'opportunités de liquidation de positions DeFi. Maximiser la MEV nécessite un savoir-faire technique sophistiqué et des logiciels personnalisés ajoutés aux validateurs normaux, ce qui rend beaucoup plus probable le fait que les opérateurs institutionnels surpassent les particuliers et les validateurs amateurs au niveau des applications d'extraction MEV. Cela signifie que les rendements du stacking sont susceptibles d'être plus élevés via des opérateurs centralisés, créant ainsi un pouvoir de centralisation amené à décourager le stacking à domicile.
 
 La séparation entre le constructeur et le proposant de bloc (PBS) résout ce dilemme en repensant les critères économiques de la valeur maximale extractible (MEV). Pour éviter au proposant de bloc d'effectuer ses propres recherches sur la Valeur maximale extractible (MEV), celui-ci choisit simplement un bloc parmi tous ceux soumis par les constructeurs de blocs. Les constructeurs de blocs ont peut-être effectué une extraction MEV sophistiquée, mais la récompense revient au proposant du bloc. Cela signifie que même si un petit groupe de constructeurs de blocs spécialisés dominent l’extraction de MEV, la récompense pourrait revenir à n’importe quel validateur du réseau, y compris les parieurs individuels.
 
-<ExpandableCard title="Pourquoi est-ce acceptable de centraliser la construction des blocs ?" eventCategory="/roadmap/pbs" eventName="clicked why is it OK to centralize block building?">
+<ExpandableCard title="Pourquoi est-il acceptable de centraliser la construction de blocs ?" eventCategory="/roadmap/pbs" eventName="clicked why is it OK to centralize block building?">
 
 Les individus pourraient être incités à miser dans des pools plutôt que seuls en raison des récompenses améliorées offertes par les stratégies MEV sophistiquées. Séparer la construction de blocs de la proposition de bloc signifie que la MEV extraite sera distribuée entre davantage de validateurs plutôt que d'être centralisée avec le chercheur de MEV le plus efficace. Dans le même temps, permettre à des constructeurs de blocs spécialisés d'exister soulage les individus du fardeau de la construction de blocs et empêche également les individus de voler la MEV pour eux-mêmes, tout en maximisant le nombre de validateurs individuels et indépendants qui peuvent vérifier que les blocs sont honnêtes. Le concept important est « l'asymétrie prouveur-vérificateur », qui fait référence à l'idée selon laquelle la production centralisée de blocs est acceptable tant qu'il existe un réseau robuste et décentralisé au maximum de validateurs capables de prouver que les blocs sont honnêtes. La décentralisation reste un moyen, non un but final en soi. Nous désirons simplement des blocs intègres.
 </ExpandableCard>
 
 ## PBS et Danksharding {#pbs-and-danksharding}
 
-Danksharding est la solution qu'Ethereum adoptera pour atteindre une échelle de >100,000 transactions par seconde tout en réduisant les frais des utilisateurs rollup. Celle-ci s'appuie sur la séparation entre constructeurs et proposants de blocs (PBS), car elle ajoute une charge de travail supplémentaire pour les constructeurs de blocs, qui devront générer des validations allant jusqu'à 64 MB de données rollup, le tout en moins d'une seconde. Cela nécessitera probablement des constructeurs spécialisés capables de consacrer du matériel assez conséquent à cette tâche. Or, dans la situation actuelle, la construction des blocs pourrait devenir de plus en plus centralisée autour d'opérateurs plus exigeants et puissants en raison de l'extraction de MEV. La séparation entre le proposant et le constructeur de blocs est une façon d'embrasser cette réalité et d'éviter qu'elle n'exerce une force centralisatrice sur la validation des blocs (la partie importante) ou sur la distribution des récompenses issues du stacking. Un grand avantage secondaire est que les constructeurs de blocs spécialisés sont également disposés et capables de calculer les preuves de données nécessaires pour Danksharding.
+Danksharding est la façon dont Ethereum va monter en charge pour atteindre >100,000 transactions par seconde et minimiser les frais pour les utilisateurs de rollups. Celle-ci s'appuie sur la séparation entre constructeurs et proposants de blocs (PBS), car elle ajoute une charge de travail supplémentaire pour les constructeurs de blocs, qui devront générer des validations allant jusqu'à 64 MB de données rollup, le tout en moins d'une seconde. Cela nécessitera probablement des constructeurs spécialisés capables de consacrer du matériel assez conséquent à cette tâche. Or, dans la situation actuelle, la construction des blocs pourrait devenir de plus en plus centralisée autour d'opérateurs plus exigeants et puissants en raison de l'extraction de MEV. La séparation entre le proposant et le constructeur de blocs est une façon d'embrasser cette réalité et d'éviter qu'elle n'exerce une force centralisatrice sur la validation des blocs (la partie importante) ou sur la distribution des récompenses issues du stacking. Un grand avantage secondaire est que les constructeurs de blocs spécialisés sont également disposés et capables de calculer les preuves de données nécessaires pour Danksharding.
 
 ## Progrès actuels {#current-progress}
 
-La séparation entre le constructeur de blocs et le proposant de blocs (PBS) est maintenant à un stade avancé de recherche, mais il reste encore quelques interrogations importantes de conception à résoudre, avant que celles-ci puissent être prototypées chez les clients d'Ethereum. Il n’y a pas encore de spécifications finalisées. Cela signifie que le délai de réalisation de la séparation entre le constructeur et le proposant de blocs (PBS) s'étale sur un délai d'un an, voire plus. Vérifier le dernier [état de recherche](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance).
+La séparation entre le constructeur de blocs et le proposant de blocs (PBS) est maintenant à un stade avancé de recherche, mais il reste encore quelques interrogations importantes de conception à résoudre, avant que celles-ci puissent être prototypées chez les clients d'Ethereum. Il n’y a pas encore de spécifications finalisées. Cela signifie que le délai de réalisation de la séparation entre le constructeur et le proposant de blocs (PBS) s'étale sur un délai d'un an, voire plus. Consultez le dernier [état de la recherche](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [État de la recherche : résistance à la censure sous PBS](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance)
-- [Conceptions de marchés de frais compatibles avec PBS](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725)
-- [PBS et la résistance à la censure](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Secondary-auctions)
+- [Conceptions de marché de frais compatibles avec le PBS](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725)
+- [PBS et résistance à la censure](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Secondary-auctions)
 - [Listes d'inclusion](https://notes.ethereum.org/@fradamt/H1ZqdtrBF)
diff --git a/public/content/translations/fr/roadmap/pectra/7702/index.md b/public/content/translations/fr/roadmap/pectra/7702/index.md
new file mode 100644
index 00000000000..2d108aa0082
--- /dev/null
+++ b/public/content/translations/fr/roadmap/pectra/7702/index.md
@@ -0,0 +1,149 @@
+---
+title: Directives Pectra 7702
+description: En savoir plus sur la 7702 dans la publication de Pectra
+lang: fr
+---
+
+# Pectra 7702
+
+## Résumé {#abstract}
+
+L’EIP 7702 définit un mécanisme permettant d’ajouter du code à un EOA. Cette proposition permet aux EOA, les anciens comptes Ethereum, de bénéficier d'améliorations de fonctionnalités à court terme, augmentant la convivialité des applications. Cela se fait en définissant un pointeur vers du code déjà déployé à l’aide d’un nouveau type de transaction : 4.
+
+Ce nouveau type de transaction introduit une liste d’autorisation. Chaque tuple d’autorisation dans la liste est défini comme
+
+```
+[ chain_id, address, nonce, y_parity, r, s ]
+```
+
+**address** désigne la délégation (le bytecode déjà déployé qui sera utilisé par l’EOA)
+**chain_id** restreint l’autorisation à une chaîne spécifique (ou à 0 pour toutes les chaînes)
+**nonce** limite l’autorisation à un nonce spécifique du compte
+(**y_parity, r, s**) est la signature du tuple d’autorisation, définie comme keccak(0x05 || rlp([chain_id, address, nonce])) signée avec la clé privée de l’EOA concerné (également appelé l’autorité)
+
+Une délégation peut être réinitialisée en la redirigeant vers l’adresse nulle.
+
+La clé privée de l’EOA conserve un contrôle total sur le compte après la délégation. Par exemple, la délégation à un coffre-fort ne fait pas du compte un multisig car il existe toujours une clé unique qui peut contourner toute politique de signature. À l’avenir, les développeurs devraient concevoir leurs applications en partant du principe que tout participant dans le système pourrait être un contrat intelligent. Pour les développeurs de contrats intelligents, il n’est plus sûr de supposer que `tx.origin` fait référence à un EOA.
+
+## Bonnes pratiques {#best-practices}
+
+**Abstraction de compte** : un contrat de délégation devrait être conforme aux normes plus larges de l’abstraction de compte (AA) d’Ethereum afin de maximiser la compatibilité. En particulier, il devrait idéalement être conforme ou compatible avec l’ERC-4337.
+
+**Conception sans autorisation et résistante à la censure** : Ethereum valorise la participation sans autorisation. Un contrat de délégation NE DOIT PAS coder en dur ni dépendre d’un seul relai ou service « de confiance ». Cela rendrait le compte inutilisable si le relai devenait indisponible. Des fonctionnalités comme le regroupement (par exemple, approve+transferFrom) peuvent être utilisées par l'EOA lui-même sans passer par un relai. Pour les développeurs d'applications souhaitant utiliser les fonctionnalités avancées permises par 7702 (abstraction du gaz, retraits préservant la confidentialité), un relais sera nécessaire. Bien qu’il existe différentes architectures de relais, nous recommandons d’utiliser des [bundlers 4337](https://www.erc4337.io/bundlers) pointant au minimum vers [le point d'entrée 0.8](https://github.com/eth-infinitism/account-abstraction/releases/tag/v0.8.0), car :
+
+- Ils offrent des interfaces standardisées pour le relais
+- Incluent des systèmes de trésorier intégrés
+- Garantissent la compatibilité avec les versions futures
+- Peuvent assurer une résistance à la censure grâce à un [mempool public](https://notes.ethereum.org/@yoav/unified-erc-4337-mempool)
+- Peuvent exiger que la fonction `init` ne soit appelée que depuis [EntryPoint](https://github.com/eth-infinitism/account-abstraction/releases/tag/v0.8.0)
+
+Autrement dit, n’importe qui devrait pouvoir agir en tant que sponsor ou relai de la transaction, tant qu’il fournit la signature valide requise ou une UserOperation émise par le compte. Cela garantit une résistance à la censure : si aucune infrastructure personnalisée n’est nécessaire, les transactions d’un utilisateur ne peuvent pas être bloquées arbitrairement par un relai faisant office de gardien. Par exemple, le [Delegation Toolkit de MetaMask](https://github.com/MetaMask/delegation-framework/releases/tag/v1.3.0) fonctionne explicitement avec n’importe quel bundler ou paymaster compatible ERC-4337, sur n’importe quelle chaîne, sans nécessiter de serveur spécifique à MetaMask.
+
+**Intégration des dApps via les interfaces de portefeuille** :
+
+Étant donné que les portefeuilles vont approuver une liste spécifique de contrats de délégation pour l’EIP-7702, les dApps ne doivent pas s’attendre à pouvoir demander directement des autorisations 7702. À la place, l’intégration doit se faire via des interfaces de portefeuille standardisées :
+
+- **ERC-5792 (`wallet_sendCalls`)** : permet aux dApps de demander aux portefeuilles d’exécuter des appels groupés, facilitant des fonctionnalités comme le regroupement de transactions et l’abstraction du gaz.
+
+- **ERC-6900** : permet aux dApps de tirer parti des fonctionnalités modulaires des comptes intelligents, comme les clés de session et la récupération de compte, via des modules gérés par le portefeuille.
+
+En utilisant ces interfaces, les dApps peuvent accéder aux fonctionnalités des comptes intelligents offertes par l’EIP-7702 sans avoir à gérer directement les délégations, garantissant ainsi compatibilité et sécurité entre différentes implémentations de portefeuilles.
+
+> Remarque : Il n’existe actuellement aucune méthode standardisée permettant aux dApps de demander directement des signatures d’autorisation 7702. Les dApps doivent s’appuyer sur des interfaces spécifiques de portefeuille, comme l’ERC-6900, pour tirer parti des fonctionnalités de l’EIP-7702.
+
+Pour plus d'informations :
+
+- [Spécification ERC-5792](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-5792.md)
+- [Spécification ERC-6900](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-6900.md)
+
+**Éviter l’enfermement propriétaire** : Dans le prolongement de ce qui précède, une bonne implémentation doit être neutre vis-à-vis des fournisseurs et interopérable. Cela implique souvent de suivre les normes émergentes pour les comptes intelligents. Par exemple, le [compte modulaire d’Alchemy](https://github.com/alchemyplatform/modular-account) utilise la norme ERC-6900 pour les comptes intelligents modulaires et est conçu dans une optique d’usage interopérable et sans autorisation.
+
+**Préservation de la vie privée** : Bien que la confidentialité onchain soit limitée, un contrat de délégation devrait s’efforcer de minimiser l’exposition des données et leur traçabilité. Cela peut être réalisé en prenant en charge des fonctionnalités telles que le paiement du gaz en jetons ERC-20 (ce qui permet aux utilisateurs de ne pas avoir à maintenir un solde public en ETH, améliorant ainsi la confidentialité et l’expérience utilisateur) et les clés de session à usage unique (réduisant la dépendance à une seule clé à long terme). Par exemple, l’EIP-7702 permet de payer le gaz en jetons via des transactions sponsorisées, et une bonne implémentation facilitera l’intégration de tels trésoriers sans divulguer plus d’informations que nécessaire. De plus, la délégation hors chaîne de certaines autorisations (au moyen de signatures vérifiées sur la blockchain) permet de réduire le nombre de transactions onchain effectuées avec la clé principale de l’utilisateur, ce qui renforce la confidentialité. Les comptes nécessitant l’utilisation d’un relai obligent les utilisateurs à révéler leur adresse IP. Les Mempools Publics améliorent cette situation : lorsqu’une transaction/UserOp se propage dans la mempool, il est impossible de savoir si elle provient de l’adresse IP qui l’a envoyée ou si elle a simplement été relayée via le protocole pair-à-pair.
+
+**Extensibilité et sécurité modulaire** : les implémentations de comptes doivent être extensibles afin de pouvoir évoluer avec de nouvelles fonctionnalités et des améliorations de sécurité. La possibilité de mise à jour est intrinsèquement offerte par l’EIP-7702 (puisqu’un EOA peut toujours déléguer à un nouveau contrat à l’avenir pour faire évoluer sa logique). Au-delà de la possibilité de mise à jour, une bonne conception permet la modularité – par exemple, des modules plug-in pour différentes méthodes de signature ou politiques de dépense – sans nécessiter un redéploiement complet. Le kit Account d’Alchemy en est un excellent exemple, permettant aux développeurs d’ajouter des modules de validation (pour différents types de signatures comme ECDSA, BLS, etc.) ainsi que des modules d’exécution pour une logique personnalisée. Pour offrir plus de flexibilité et de sécurité aux comptes compatibles avec l’EIP-7702, il est recommandé aux développeurs de déléguer à un contrat proxy plutôt que directement à une implémentation spécifique. Cette approche permet des mises à jour et une modularité transparentes, sans nécessiter de nouvelles autorisations EIP-7702 pour chaque modification.
+
+Avantages du modèle proxy :
+
+- **Mise à jour facilitée** : mettez à jour la logique du contrat en redirigeant le proxy vers un nouveau contrat d'implémentation.
+
+- **Logique d’initialisation personnalisée** : intégrez des fonctions d’initialisation dans le proxy pour configurer en toute sécurité les variables d’état nécessaires.
+
+Par exemple, le [SafeEIP7702Proxy](https://docs.safe.global/advanced/eip-7702/7702-safe) montre comment un proxy peut être utilisé pour initialiser et gérer en toute sécurité les délégations dans des comptes compatibles avec l’EIP-7702.
+
+Inconvénients du modèle proxy :
+
+- **Dépendance à des acteurs externes** : il faut faire confiance à une équipe externe pour ne pas effectuer de mise à jour vers un contrat non sécurisé.
+
+## Considérations de sécurité {#security-considerations}
+
+**Protection contre la réentrance** : avec l’introduction de la délégation via l’EIP-7702, le compte d’un utilisateur peut basculer dynamiquement entre un compte détenu en externe (EOA) et un contrat intelligent (SC). Cette flexibilité permet au compte à la fois d’initier des transactions et d’être la cible d’appels. En conséquence, dans les scénarios où un compte s’appelle lui-même et effectue des appels externes, `msg.sender` sera égal à `tx.origin`, ce qui compromet certaines hypothèses de sécurité qui reposaient auparavant sur le fait que `tx.origin` faisait toujours référence à un EOA.
+
+Pour les développeurs de contrats intelligents, il n’est plus sûr de supposer que `tx.origin` fait référence à un EOA. De même, utiliser `msg.sender == tx.origin` comme protection contre les attaques par réentrance n’est plus une stratégie fiable.
+
+À l’avenir, les développeurs devraient concevoir leurs applications en partant du principe que tout participant dans le système pourrait être un contrat intelligent. Une alternative consiste à mettre en place une protection explicite contre la réentrance en utilisant des garde-fous de réentrance avec des modèles de type modificateur `nonReentrant`. Nous recommandons d’utiliser un modificateur audité, par exemple le [Reentrancy Guard d’OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol). Ils peuvent également utiliser une [variable de stockage transitoire](https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html).
+
+**Considérations de sécurité liées à l’initialisation**
+
+La mise en œuvre de contrats de délégation selon l’EIP-7702 introduit des défis de sécurité spécifiques, notamment en ce qui concerne le processus d’initialisation. Une vulnérabilité critique survient lorsque la fonction d’initialisation (`init`) est liée de manière atomique au processus de délégation. Dans de tels cas, un attaquant pratiquant le frontrunning pourrait intercepter la signature de délégation et exécuter la fonction `init` avec des paramètres modifiés, prenant ainsi potentiellement le contrôle du compte.
+
+Ce risque est particulièrement important lorsqu’on tente d’utiliser des implémentations existantes de comptes de contrat intelligent (SCA) avec l’EIP-7702 sans adapter leurs mécanismes d’initialisation.
+
+**Solutions pour atténuer les vulnérabilités liées à l’initialisation**
+
+- Implémenter `initWithSig`
+  Remplacer la fonction `init` standard par une fonction `initWithSig` qui exige que l’utilisateur signe les paramètres d’initialisation. Cette approche garantit que l’initialisation ne peut se poursuivre qu’avec le consentement explicite de l’utilisateur, réduisant ainsi les risques d’initialisation non autorisée.
+
+- Utiliser l’EntryPoint de l’ERC-4337
+  Exiger que la fonction d’initialisation soit appelée exclusivement depuis le contrat EntryPoint de l’ERC-4337. Cette méthode s’appuie sur le cadre standardisé de validation et d’exécution fourni par l’ERC-4337, ajoutant ainsi une couche de sécurité supplémentaire au processus d’initialisation.  
+  _(Voir : [Safe Docs](https://docs.safe.global/advanced/eip-7702/7702-safe))_
+
+En adoptant ces solutions, les développeurs peuvent améliorer la sécurité des contrats de délégation EIP-7702, en se protégeant contre les attaques potentielles de premier plan pendant la phase d'initialisation.
+
+**Collisions de stockage** : déléguer du code ne réinitialise pas le stockage existant. Lors de la migration d’un contrat de délégation vers un autre, les données résiduelles du contrat précédent restent en place. Si le nouveau contrat utilise les mêmes emplacements de stockage mais les interprète différemment, cela peut entraîner des comportements inattendus. Par exemple, si la première délégation était destinée à un contrat dans lequel un emplacement de stockage représente un `bool`, et que la délégation suivante était destinée à un contrat dans lequel le même emplacement représente un `uint`, l'inadéquation peut conduire à des résultats imprévisibles.
+
+**Risques de phishing** : avec la mise en œuvre de la délégation via l’EIP-7702, les actifs du compte d’un utilisateur peuvent être entièrement contrôlés par des contrats intelligents. Si un utilisateur délègue son compte à un contrat malveillant sans le savoir, un attaquant pourrait facilement en prendre le contrôle et dérober des fonds. Lorsqu’on utilise `chain_id=0`, la délégation s’applique à tous les identifiants de chaîne. Ne déléguez qu’à un contrat définitif (jamais à un proxy), et uniquement à des contrats déployés via CREATE2 (avec un initcode standard - pas de contrats métamorphes), afin d’éviter qu’un déployeur ne puisse déployer un contrat différent à la même adresse sur une autre chaîne. Sinon, votre délégation met votre compte en danger sur toutes les autres chaînes compatibles EVM.
+
+Lorsque les utilisateurs effectuent des signatures déléguées, le contrat cible recevant la délégation doit être affiché de manière claire et visible afin de limiter les risques de phishing.
+
+**Surface de confiance minimale et sécurité** : tout en offrant de la flexibilité, un contrat de délégation doit conserver sa logique de base minimale et vérifiable. Le contrat agit en pratique comme une extension de l’EOA de l’utilisateur, si bien que toute faille peut avoir des conséquences catastrophiques. Les implémentations doivent suivre les bonnes pratiques établies par la communauté spécialisée dans la sécurité des contrats intelligents. Par exemple, les fonctions de construction ou d’initialisation doivent être rigoureusement sécurisées – comme l’a souligné Alchemy, si l’on utilise un modèle proxy avec l’EIP-7702, une initialisation non protégé pourrait permettre à un attaquant de prendre le contrôle du compte. Les équipes devraient s’efforcer de garder le code sur la blockchain simple : le contrat 7702 d’Ambire compte environ 200 lignes de Solidity, avec une complexité volontairement réduite afin de limiter les risques de bugs. Il est essentiel de trouver un équilibre entre une logique riche en fonctionnalités et une simplicité qui facilite l’audit.
+
+### Implémentations connues {#known-implementations}
+
+En raison de la nature de l’EIP 7702, il est recommandé que les portefeuilles fassent preuve de prudence lorsqu’ils aident les utilisateurs à déléguer à un contrat tiers. Voici une liste d’implémentations connues ayant fait l’objet d’un audit :
+
+| Adresse du contrat                         | Source                                                                                                                                            | Audits                                                                                                                                                        |
+| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 0x000000009B1D0aF20D8C6d0A44e162d11F9b8f00 | [Uniswap/calibur](https://github.com/Uniswap/calibur)                                                                                             | [audits](https://github.com/Uniswap/calibur/tree/main/audits)                                                                                                 |
+| 0x69007702764179f14F51cdce752f4f775d74E139 | [alchemyplatform/modular-account](https://github.com/alchemyplatform/modular-account)                                                             | [audits](https://github.com/alchemyplatform/modular-account/tree/develop/audits)                                                                              |
+| 0x5A7FC11397E9a8AD41BF10bf13F22B0a63f96f6d | [AmbireTech/ambire-common](https://github.com/AmbireTech/ambire-common/blob/feature/eip-7702/contracts/AmbireAccount7702.sol)                     | [audits](https://github.com/AmbireTech/ambire-common/tree/feature/eip-7702/audits)                                                                            |
+| 0x63c0c19a282a1b52b07dd5a65b58948a07dae32b | [MetaMask/delegation-framework](https://github.com/MetaMask/delegation-framework)                                                                 | [audits](https://github.com/MetaMask/delegation-framework/tree/main/audits)                                                                                   |
+| 0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9 | [Équipe AA de la Fondation Ethereum](https://github.com/eth-infinitism/account-abstraction/blob/develop/contracts/accounts/Simple7702Account.sol) | [audits](https://github.com/eth-infinitism/account-abstraction/blob/develop/audits/SpearBit%20Account%20Abstraction%20Security%20Review%20-%20Mar%202025.pdf) |
+| 0x17c11FDdADac2b341F2455aFe988fec4c3ba26e3 | [Luganodes/Pectra-Batch-Contract](https://github.com/Luganodes/Pectra-Batch-Contract)                                                             | [audits](https://certificate.quantstamp.com/full/luganodes-pectra-batch-contract/23f0765f-969a-4798-9edd-188d276c4a2b/index.html)                             |
+
+## Recommandations pour les portefeuilles matériels {#hardware-wallet-guidelines}
+
+Les portefeuilles matériels ne doivent pas exposer de délégation arbitraire. Le consensus dans le domaine des portefeuilles matériels est d’utiliser une liste de contrats délégateurs de confiance. Nous suggérons d’autoriser les implémentations connues listées ci-dessus et d’examiner les autres au cas par cas. Comme déléguer votre EOA à un contrat donne le contrôle sur l’ensemble des actifs, les portefeuilles matériels doivent faire preuve de prudence dans la manière dont ils implémentent l’EIP 7702.
+
+### Scénarios d’intégration pour les applications compagnons {#integration-scenarios-for-companion-apps}
+
+#### Paresseux {#lazy}
+
+Puisque l’EOA fonctionne toujours comme d’habitude, aucune action n’est nécessaire.
+
+Remarque : certains actifs peuvent être automatiquement rejetés par le code de délégation, comme les NFT ERC-1155, et l'équipe de support doit en être informée.
+
+#### Conscient {#aware}
+
+Avertir l’utilisateur qu’une délégation est en place pour l’EOA en vérifiant son code, et proposer éventuellement de supprimer cette délégation.
+
+#### Délégation courante {#common-delegation}
+
+Le fournisseur de matériel met sur liste blanche les contrats de délégation connus et met en œuvre leur support dans un logiciel compagnon. Il est recommandé de choisir un contrat prenant en charge l’ERC 4337 dans son intégralité.
+
+Les EOA délégués à un autre seront traités comme des EOA standards.
+
+#### Délégation personnalisée {#custom-delegation}
+
+Le fournisseur de portefeuille matériel implémente son propre contrat de délégation, l’ajoute aux listes, et en intègre la prise en charge dans le compagnon logiciel. Il est recommandé de concevoir un contrat prenant en charge l’ERC 4337 dans son intégralité.
+
+Les EOA délégués à un autre seront traités comme des EOA standards.
diff --git a/public/content/translations/fr/roadmap/pectra/index.md b/public/content/translations/fr/roadmap/pectra/index.md
new file mode 100644
index 00000000000..e75a72144c2
--- /dev/null
+++ b/public/content/translations/fr/roadmap/pectra/index.md
@@ -0,0 +1,127 @@
+---
+title: Prague-Electra (Pectra)
+description: "En savoir plus sur la mise à niveau du protocole Pectra"
+lang: fr
+---
+
+# Pectra {#pectra}
+
+La mise à niveau du réseau Pectra a suivi [Dencun](/roadmap/dencun/) et a apporté des changements à la fois à la couche d’exécution et à la couche de consensus d’Ethereum. Le nom abrégé Pectra est une combinaison de Prague et Electra, qui sont les noms respectifs des changements de spécifications des couches d’exécution et de consensus. Ensemble, ces changements apportent un certain nombre d’améliorations aux utilisateurs, développeurs et validateurs d’Ethereum.
+
+Cette mise à niveau a été activée avec succès sur le réseau principal d’Ethereum à l’époque `364032`, le **07 mai 2025 à 10:05 (UTC)**.
+
+<Alert variant="update">
+<AlertContent>
+<AlertDescription>
+La mise à niveau Pectra n'est qu'une étape dans les objectifs de développement à long terme d'Ethereum. Apprenez-en plus sur [la feuille de route du protocole](/roadmap/) et les [mises à niveau précédentes](/ethereum-forks/).
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Améliorations dans Pectra {#new-improvements}
+
+Pectra apporte le plus grand nombre de [EIP](https://eips.ethereum.org/) jamais inclus dans une mise à niveau précédente ! Il y a de nombreux changements mineurs mais aussi quelques nouvelles fonctionnalités importantes. La liste complète des changements et les détails techniques se trouvent dans les EIP individuels inclus.
+
+### Code du compte EOA {#7702}
+
+[EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) représente une étape majeure vers une [abstraction de compte](/roadmap/account-abstraction/) généralisée. Avec cette fonctionnalité, les utilisateurs peuvent définir leur adresse ([EOA](/glossary/#eoa)) pour qu'elle soit étendue avec un contrat intelligent. L’EIP introduit un nouveau type de transaction avec une fonction spécifique : permettre aux propriétaires d’adresse de signer une autorisation qui configure leur adresse pour imiter un contrat intelligent choisi.
+
+Avec cet EIP, les utilisateurs peuvent opter pour des portefeuilles programmables qui permettent de nouvelles fonctionnalités telles que le regroupement de transactions, les transactions sans frais de gaz et l’accès personnalisé aux actifs pour des schémas de récupération alternatifs. Cette approche hybride combine la simplicité des Comptes détenus en externe (EOA) avec la programmabilité des comptes basés sur des contrats.
+
+Lisez une analyse approfondie de 7702 [ici](/roadmap/pectra/7702/)
+
+### Augmentation du solde effectif maximal {#7251}
+
+Le solde effectif actuel du validateur est exactement de 32 ETH. C’est le montant minimum nécessaire pour participer au consensus, mais aussi le maximum qu’un seul validateur peut miser.
+
+[EIP-7251](https://eips.ethereum.org/EIPS/eip-7251) augmente le solde effectif maximal possible à 2048 ETH, ce qui signifie qu’un seul validateur peut désormais miser entre 32 et 2048 ETH. Au lieu de multiples de 32, les stakers peuvent désormais choisir un montant arbitraire d’ETH à miser et recevoir des récompenses pour chaque ETH au-dessus du minimum. Par exemple, si le solde d’un validateur augmente avec ses récompenses jusqu’à 33 ETH, l’ETH supplémentaire est également considéré comme faisant partie du solde effectif et reçoit des récompenses.
+
+Mais l’avantage d’un meilleur système de récompense pour les validateurs n’est qu’une partie de cette amélioration. Les [stakers](/staking/) exécutant plusieurs validateurs peuvent désormais les regrouper en un seul, ce qui permet une exploitation plus simple et réduit la surcharge du réseau. Comme chaque validateur dans la Beacon Chain soumet une signature à chaque époque, les besoins en bande passante augmentent avec le nombre de validateurs et le grand volume de signatures à propager. Regrouper les validateurs allègera la charge du réseau et ouvrira de nouvelles possibilités de mise à l’échelle tout en maintenant la même sécurité économique.
+
+Lisez une analyse approfondie sur maxEB [ici](/roadmap/pectra/maxeb/)
+
+### Augmentation du débit des blobs {#7691}
+
+Les blobs assurent la [disponibilité des données](/developers/docs/data-availability/#data-availability-and-layer-2-rollups) pour les L2. Ils ont été introduits lors de [la mise à niveau précédente du réseau](/roadmap/dencun/).
+
+Actuellement, le réseau vise une moyenne de 3 blobs par bloc avec un maximum de 6 blobs. Avec [EIP-7691](https://eips.ethereum.org/EIPS/eip-7691), le nombre moyen de blobs sera porté à 6, avec un maximum de 9 par bloc, ce qui augmentera la capacité pour les rollups Ethereum. Cet EIP aide à combler l’écart jusqu’à ce que [PeerDAS](https://eips.ethereum.org/EIPS/eip-7594) permette un nombre de blobs encore plus élevé.
+
+### Augmentation du coût des calldata {#7623}
+
+Avant l’introduction des [blobs dans la mise à niveau Dencun](/roadmap/danksharding), les L2 utilisaient les [calldata](/developers/docs/data-availability/blockchain-data-storage-strategies/#calldata) pour stocker leurs données sur Ethereum. Les blobs et les calldata influencent tous deux l’utilisation de la bande passante d’Ethereum. Bien que la plupart des blocs n’utilisent qu’une quantité minimale de calldata, les blocs riches en données contenant également de nombreux blobs peuvent nuire au réseau p2p d’Ethereum.
+
+Pour remédier à cela, [EIP-7623](https://eips.ethereum.org/EIPS/eip-7623) augmente le coût des calldata, mais uniquement pour les transactions avec un grand nombre de données. Cela limite la taille maximale des blocs dans le pire des cas, incite les L2 à utiliser uniquement des blobs et laisse plus de 99 % des transactions inchangées.
+
+### Sorties déclenchables depuis la couche d'exécution {#7002}
+
+Actuellement, quitter un validateur et [retirer de l’ETH mis en jeu](/staking/withdrawals/) est une opération de la couche de consensus qui nécessite une clé de validateur active, c’est-à-dire la même clé BLS utilisée par le validateur pour effectuer des tâches actives comme les attestations. Les identifiants de retrait constituent une clé froide distincte qui reçoit les fonds retirés, mais ne peut pas déclencher la sortie. La seule manière pour les validateurs de sortir est d’envoyer un message spécial au réseau de la Beacon Chain, signé avec la clé active du validateur. Cela est limitant dans les scénarios où les identifiants de retrait et la clé du validateur sont détenus par des entités différentes ou lorsque la clé du validateur est perdue.
+
+[EIP-7002](https://eips.ethereum.org/EIPS/eip-7002) introduit un nouveau contrat qui peut être utilisé pour déclencher la sortie en utilisant les identifiants de retrait de la couche d'exécution. Les stakers pourront quitter leur validateur en appelant une fonction dans ce contrat spécial, sans avoir besoin de leur clé de signature du validateur ni d’un accès à la Beacon Chain. Il est important de noter que permettre les retraits des validateurs en chaîne ouvre la voie à des protocoles de mise en jeu avec des hypothèses de confiance réduites envers les opérateurs de nœuds.
+
+### Dépôts des validateurs en chaîne {#6110}
+
+Les dépôts du validateur sont actuellement traités par [eth1data poll](https://eth2book.info/capella/part2/deposits-withdrawals/deposit-processing/) qui est une fonction de la chaîne Beacon qui récupère les données de la couche d'exécution. C’est en quelque sorte une dette technique datant d’avant la Fusion, lorsque la chaîne Beacon était un réseau séparé et devait se préoccuper des réorganisations liées à la preuve de travail.
+
+[EIP-6110](https://eips.ethereum.org/EIPS/eip-6110) est une nouvelle méthode de transmission des dépôts de la couche d’exécution à la couche de consensus, permettant un traitement instantané avec une complexité de mise en œuvre réduite. C’est une méthode plus sécurisée de gestion des dépôts, propre à Ethereum après la fusion. Elle contribue également à pérenniser le protocole, car elle ne nécessite pas de dépôts historiques pour amorcer un nœud, ce qui est essentiel pour l’expiration de l’historique.
+
+### Précompilé pour BLS12-381 {#2537}
+
+Les précompilés sont un ensemble spécial de contrats intelligents intégrés directement dans la machine virtuelle Ethereum ([EVM](/developers/docs/evm/)). Contrairement aux contrats classiques, les précompilés ne sont pas déployés par les utilisateurs mais font partie intégrante de l’implémentation du client, écrits dans son langage natif (par exemple Go, Java, etc., et non en Solidity). Les précompilés servent à exécuter des fonctions largement utilisées et standardisées, comme les opérations cryptographiques. Les développeurs de contrats intelligents peuvent appeler les précompilés comme un contrat classique, mais avec plus de sécurité et d’efficacité.
+
+[EIP-2537](https://eips.ethereum.org/EIPS/eip-2537) ajoute de nouveaux précompilés pour les opérations sur courbes utilisant [BLS12-381](https://hackmd.io/@benjaminion/bls12-381). Cette courbe elliptique est devenue largement utilisée dans les écosystèmes de cryptomonnaies grâce à ses propriétés pratiques. Plus précisément, elle a été adoptée par la couche de consensus d’Ethereum, où elle est utilisée par les validateurs.
+
+Le nouveau précompilé permet à chaque développeur d’effectuer facilement, efficacement et en toute sécurité des opérations cryptographiques avec cette courbe, par exemple pour vérifier des signatures. Les applications sur la blockchain qui dépendent de cette courbe peuvent devenir plus économes en gaz et plus sécurisées en s’appuyant sur un précompilé plutôt que sur un contrat personnalisé. Cela s'applique principalement aux applications qui souhaitent raisonner sur les validateurs au sein de l'EVM, par exemple les groupes de mise en jeu, [la remise en jeu](/restaking/), les clients légers, les ponts, mais aussi la preuve à divulgation nulle de connaissance.
+
+### Fournir les hachages de blocs historiques depuis l'état {#2935}
+
+L’EVM fournit actuellement l’opcode `BLOCKHASH`, qui permet aux développeurs de contrats de récupérer le hachage d’un bloc directement dans la couche d’exécution. Cependant, cela se limite uniquement aux 256 derniers blocs et pourrait poser problème aux clients sans état à l’avenir.
+
+[EIP-2935](https://eips.ethereum.org/EIPS/eip-2935) crée un nouveau contrat système qui peut fournir les hachages des 8192 derniers blocs sous forme d’emplacements de stockage. Cela contribue à pérenniser le protocole pour l’exécution sans état et devient plus efficace avec l’adoption des arbres de Verkle. Cependant, en dehors de cela, les rollups peuvent en bénéficier immédiatement, car ils peuvent interroger directement le contrat avec une fenêtre historique plus large.
+
+### Déplacement de l’index du comité en dehors d’Attestation {#7549}
+
+Le consensus de la chaîne Beacon repose sur le fait que les validateurs votent pour le dernier bloc et l’époque finalisée. L’attestation comprend 3 éléments, dont 2 sont des votes, et le troisième est la valeur de l’index du comité.
+
+[EIP-7549](https://eips.ethereum.org/EIPS/eip-7549) déplace cet index en dehors du message d’attestation signé, ce qui facilite la vérification et l’agrégation des votes de consensus. Cela permettra une plus grande efficacité dans chaque client de consensus et pourra apporter des améliorations significatives de performance aux circuits de preuve à divulgation nulle de connaissance pour prouver le consensus d’Ethereum.
+
+### Ajout du calendrier des blobs aux fichiers de configuration de la couche d'exécution {#7840}
+
+[EIP-7840](https://eips.ethereum.org/EIPS/eip-7840) est une modification simple qui ajoute un nouveau champ à la configuration des clients de la couche d’exécution. Il configure le nombre de blocs, permettant un réglage dynamique du nombre cible et maximal de blobs par bloc ainsi que l’ajustement des frais de blobs. Avec une configuration définie directement, les clients peuvent éviter la complexité liée à l’échange de ces informations via l’API Engine.
+
+<Alert variant="update">
+<AlertContent>
+<AlertDescription>
+Pour en savoir plus sur la façon dont Pectra vous affecte spécifiquement en tant qu'utilisateur, développeur ou validateur Ethereum, consultez la <a href="https://epf.wiki/#/wiki/pectra-faq">FAQ Pectra</a>.
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Cette mise à niveau affecte-t-elle tous les nœuds et validateurs Ethereum ? {#client-impact}
+
+Oui, la mise à niveau Pectra nécessite des mises à jour à la fois des [clients d'exécution et des clients de consensus](/developers/docs/nodes-and-clients/). Tous les principaux clients Ethereum publieront des versions prenant en charge la hard fork, marquées comme hautement prioritaires. Pour maintenir la synchronisation avec le réseau Ethereum après la mise à jour, les opérateurs de nœuds doivent s'assurer qu'ils utilisent une version de client prise en charge. Notez que les informations concernant les versions des clients sont tributaires du temps, et les utilisateurs doivent se référer aux dernières mises à jour pour obtenir les derniers détails.
+
+## Comment ETH peut-il être converti après la fourche majeure ? {#scam-alert}
+
+- **Aucune action requise pour vos ETH** : Suite à la mise à niveau Pectra d'Ethereum, il n'est pas nécessaire de convertir ou de mettre à niveau vos ETH. Vos soldes de compte resteront inchangés, et les ETH que vous détenez actuellement resteront accessibles sous leur forme actuelle après la fourche majeure.
+- **Attention aux arnaques !** <Emoji text="⚠️" />**quiconque vous demandant de "mettre àniveau" vos ETH essaie de vous arnaquer.** Vous n'avez rien à faire en relation avec cette mise à niveau. Vos actifs resteront totalement inchangés. N'oubliez pas, rester informé est la meilleure défense contre les arnaques.
+
+[En savoir plus sur comment reconnaitre et éviter les arnaques](/security/)
+
+## Davantage qu'un apprenant visuel ? {#visual-learner}
+
+<YouTube id="ufIDBCgdGwY" />
+
+_Qu’est-ce qui entre dans la mise à niveau Pectra ? - Christine Kim_
+
+<YouTube id="_UpAFpC7X6Y" />
+
+_Mise à jour Pectra d'Ethereum : ce que les stakers doivent savoir — Blockdaemon_
+
+## En savoir plus {#further-reading}
+
+- [Feuille de route d'Ethereum](/roadmap/)
+- [FAQ de Pectra](https://epf.wiki/#/wiki/pectra-faq)
+- [Page d'information Pectra.wtf](https://pectra.wtf)
+- [Comment Pectra améliore l'expérience des stakers](https://www.kiln.fi/post/next-ethereum-upgrade-how-pectra-will-enhance-the-staking-experience)
+- [Page d'information EIP7702](https://eip7702.io/)
+- [devnets Pectra](https://github.com/ethereum/pm/blob/master/Pectra/pectra-pm.md)
diff --git a/public/content/translations/fr/roadmap/pectra/maxeb/index.md b/public/content/translations/fr/roadmap/pectra/maxeb/index.md
new file mode 100644
index 00000000000..3f72f389cbc
--- /dev/null
+++ b/public/content/translations/fr/roadmap/pectra/maxeb/index.md
@@ -0,0 +1,204 @@
+---
+title: MaxEB Pectra
+description: En savoir plus sur MaxEB dans la publication de Pectra
+lang: fr
+---
+
+# MaxEB {#maxeb}
+
+_tl;dr:_ Le hard fork de Pectra permet aux validateurs d'Ethereum d'opter pour un solde effectif maximal et une composition plus élevés en convertissant les informations de retrait de **Type 1** en **Type 2**. L’outil officiel pour effectuer cette conversion est la plateforme de lancement. Cette opération ne peut pas être annulée.
+
+## Vue d'ensemble {#overview}
+
+### Qui est concerné ? {#who-is-affected}
+
+Toute personne qui exploite un validateur - il s'agit probablement de quelqu’un qui connaît l’index (par exemple [Validateur n°12345](https://beaconcha.in/validator/12345)) d’un validateur qu’il contrôle. Si vous utilisez un protocole pour faire fonctionner un validateur (par exemple Lido CSM ou Rocket Pool), vous devrez vérifier auprès d’eux s’ils prennent en charge maxEB, et à quel moment.
+
+Si vous effectuez du staking via un jeton de staking liquide (par exemple rETH ou stETH), aucune action n’est requise ni recommandée.
+
+### Qu’est-ce que « maxEB » ? {#what-is-maxeb}
+
+maxEB = le solde effectif MAXimal d’un validateur. Jusqu’à la fourche majeure Pectra, chaque validateur gagne des récompenses sur un maximum de 32 ETH. Après Pectra, les validateurs ont la possibilité de gagner des récompenses sur n’importe quel solde compris entre 32 et 2048 ETH, par incréments de 1 ETH, en choisissant d’adopter ce changement.
+
+### Comment un validateur peut-il choisir d’adopter cette modification ? {#how-does-a-validator-opt-in}
+
+Un validateur choisit d’adopter le changement maxEB en convertissant ses identifiants de retrait de **Type 1** vers **Type 2**. Cela peut être fait sur la [Plateforme de lancement (Actions du validateur)](https://launchpad.ethereum.org/validator-actions) après la mise en service de la fourche majeure Pectra. Comme pour la conversion de **Type 0** → **Type 1**, passer de **Type 1** → **Type 2** est un processus irréversible.
+
+### Qu’est-ce qu’un identifiant de retrait ? {#whats-a-withdrawal-credential}
+
+Lorsque vous exploitez un validateur, vous disposez d’un ensemble d’identifiants de retrait. Ils peuvent être trouvés dans votre fichier json de données de dépôt ou consultés dans l’onglet [deposit](https://beaconcha.in/validator/12345#deposits) de votre validateur sur beaconcha.in.
+
+1. **Identifiants de retrait de Type 0** : Si les identifiants de retrait de votre validateur commencent par `0x00...`, vous avez effectué le dépôt avant le hard fork Shapella et vous n’avez pas encore d’adresse de retrait définie.
+
+![Identifiant de retrait de Type 0](./0x00-wd.png)
+
+2. **Identifiants de retrait de Type 1** : Si les identifiants de retrait de votre validateur commencent par `0x01...`, vous avez effectué le dépôt après la mise à jour Shapella ou vous avez déjà converti vos identifiants de **Type 0** en identifiants de **Type 1**.
+
+![Identifiant de retrait de Type 1](./0x01-wd.png)
+
+3. **Identifiants de retrait de Type 2** : Ce nouveau type d’identifiant de retrait commencera par `0x02...` et sera activé après la mise à jour Pectra. Les validateurs avec des identifiants de retrait **Type 2** sont parfois appelés « **validateurs à capitalisation** »
+
+| **Autorisé**      | **Non autorisé**  |
+| ----------------- | ----------------- |
+| ✅ Type 0 → Type 1 | ❌ Type 0 → Type 2 |
+| ✅ Type 1 → Type 2 | ❌ Type 1 → Type 0 |
+|                   | ❌ Type 2 → Type 1 |
+|                   | ❌ Type 2 → Type 0 |
+
+### Risques {#risks}
+
+MaxEB permet à un validateur d’envoyer la totalité de son solde à un autre validateur. Les utilisateurs soumettant une demande de consolidation doivent vérifier la source et le contenu de la transaction qu’ils signent. L’outil officiel pour profiter des fonctionnalités de maxEB est la plateforme de lancement. Si vous décidez d’utiliser un outil tiers, vous devez vérifier que :
+
+- La clé publique du validateur source et son adresse de retrait correspondent bien au validateur qu’ils contrôlent
+- La clé publique du validateur cible est correcte et lui appartient
+- La demande est une conversion, et non une consolidation, s’ils n’ont pas l’intention d’envoyer des fonds à un autre validateur
+- La transaction est signée par la bonne adresse de retrait
+
+Nous **recommandons fortement** de discuter de tout outil tiers que vous envisagez d’utiliser avec la [communauté EthStaker](https://ethstaker.org/about). C’est un endroit utile pour vérifier la pertinence de votre démarche et éviter les erreurs. Si vous utilisez un outil malveillant ou mal configuré, **l’intégralité du solde de votre validateur pourrait être envoyée à un validateur que vous ne contrôlez pas** — sans aucun moyen de le récupérer.
+
+## Détails techniques {#technical-details}
+
+### Le processus {#the-flow}
+
+Il y aura deux utilisations de l’opération `ConsolidationRequest` :
+
+1. Convertir un validateur existant de **Type 1** en validateur **Type 2**
+2. Consolider d’autres validateurs dans un validateur **Type 2** existant
+
+Lors de la conversion d’un validateur **Type 1** en **Type 2**, la _source_ et la _cible_ seront tous deux le validateur que vous êtes en train de convertir. L’opération coûtera du gaz et sera mise en file d’attente derrière les autres demandes de consolidation. Cette file d’attente est **distincte** de la file d’attente des dépôts, n’est pas affectée par les nouveaux dépôts de validateurs, et peut être consultée sur [pectrified.com](https://pectrified.com/).
+
+Pour consolider des validateurs, vous devez disposer d’un _validateur cible_ possédant un identifiant de retrait **Type 2**. C’est la destination des soldes de validateurs en cours de consolidation, ainsi que l’index qui sera conservé.
+
+### Exigences pour la conversion en Type 2 {#requirements-for-converting-to-type-2}
+
+Cela sera requis pour le premier validateur que vous convertirez en **Type 2**. L’index de ce validateur est conservé et reste actif. Pour une conversion, le _validateur source_ == le _validateur cible._
+
+Le validateur doit...
+
+- être actif
+- avoir des identifiants de retrait **Type 1**
+- ne pas être en cours de sortie (ni avoir été sanctionné)
+- ne pas avoir de retraits déclenchés manuellement en attente (cela ne s’applique pas aux retraits automatiques)
+
+![illustration de la conversion](./conversion.png)
+
+### Exigences pour la consolidation {#requirements-for-consolidating}
+
+Il s’agit de la _même opération_ que la conversion, mais dans ce cas, le _validateur source_ est différent du _validateur cible_. L’index du validateur cible est conservé et il reçoit le solde du validateur source. L’index du validateur source est placé dans l’état `EXITED`.
+
+Dans ce cas, le validateur source doit remplir toutes les exigences mentionnées ci-dessus, plus les suivantes :
+
+- a été actif pendant au moins ~27,3 heures (soit une `SHARD_COMMITTEE_PERIOD`)
+
+Le validateur cible doit
+
+- avoir des identifiants de retrait **Type 2**
+- ne pas être en cours de sortie.
+
+![illustration de la consolidation](./consolidation.png)
+
+### La demande de consolidation {#the-consolidation-request}
+
+La demande de consolidation sera signée par l’adresse de retrait associée au validateur source et contiendra :
+
+1. L’adresse du validateur source (par exemple `0x15F4B914A0cCd14333D850ff311d6DafbFbAa32b`)
+2. La clé publique du validateur source (par exemple `0xa1d1ad0714035353258038e964ae9675dc0252ee22cea896825c01458e1807bfad2f9969338798548d9858a571f7425c`)
+3. La clé publique du validateur cible
+
+Dans une conversion, les éléments 2 et 3 seront identiques. Cette opération peut être effectuée sur [la plateforme de lancement](https://launchpad.ethereum.org/).
+
+### Exigences de signature {#signing-requirements}
+
+Pour soumettre une `ConsolidationRequest`, **l’adresse de retrait du validateur source** doit signer la demande. Cela prouve le contrôle sur les fonds du validateur.
+
+### Que doit-on signer ? {#what-is-signed}
+
+Une [racine de signature](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/beacon-chain.md#compute_signing_root) avec séparation de domaine de l’objet `ConsolidationRequest` est utilisée.
+
+- **Domaine :** `DOMAIN_CONSOLIDATION_REQUEST`
+- **Champs de la racine de signature :**
+  - `source_pubkey`: `BLSPubkey`
+  - `target_pubkey`: `BLSPubkey`
+  - `source_address`: `ExecutionAddress`
+
+La **signature BLS** résultante est soumise avec la demande.
+
+Remarque : la signature est effectuée par l’adresse de retrait, et non par la clé du validateur.
+
+### Retraits partiels {#partial-withdrawals}
+
+Les validateurs avec des identifiants **Type 1** reçoivent automatiquement, sans frais de gas, le transfert de leur solde excédentaire (tout ce qui dépasse 32 ETH) vers leur adresse de retrait. Comme le **Type 2** permet à un validateur de faire croître son solde par incréments de 1 ETH, aucun retrait automatique ne sera effectué tant que le solde n’atteint pas 2048 ETH. Les retraits partiels sur les validateurs **Type 2** doivent être déclenchés manuellement et entraîneront des frais de gaz.
+
+## Outils de consolidation {#consolidation-tooling}
+
+Plusieurs outils sont disponibles pour gérer les consolidations. L’outil officiel, créé par la Fondation Ethereum, est la [plateforme de lancement](https://launchpad.ethereum.org/en/validator-actions). Il existe également des outils tiers créés par des acteurs de la communauté du staking, qui peuvent offrir des fonctionnalités non proposées par la plateforme de lancement. Bien que les outils présentés ici ne soient ni audités ni approuvés par la Fondation Ethereum, ce sont des outils open source développés par des membres reconnus de la communauté.
+
+| Outil                           | Site Web                                                                                                  | Open Source                     | Créateur                                       | Audité                                                                                                                                              | Interface                                                                                | Signes particuliers                                                                                             |
+| ------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------- | ---------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| Gestionnaire de staking Pectra  | pectrastaking.com                                                                         | Oui, Apache 2.0 | [Pier Two](https://piertwo.com/)               | Non                                                                                                                                                 | Interface Web                                                                            | Wallet Connect, fonctionne avec SAFE                                                                            |
+| Outil CLI Pectra Validator Ops  | [GitHub](https://github.com/Luganodes/Pectra-Batch-Contract)                                              | Oui, MIT                        | [Luganodes](https://www.luganodes.com/)        | Oui, Quantstamp [Mai 2025](https://certificate.quantstamp.com/full/luganodes-pectra-batch-contract/23f0765f-969a-4798-9edd-188d276c4a2b/index.html) | Ligne de commande                                                                        | Traitement par lots, pour plusieurs validateurs en une seule fois                                               |
+| Ethereal                        | [GitHub](https://github.com/wealdtech/ethereal)                                                           | Oui, Apache 2.0 | [Jim McDonald](https://www.attestant.io/team/) | Non                                                                                                                                                 | Ligne de commande                                                                        | Ensemble complet de fonctionnalités pour la gestion des validateurs et des nœuds                                |
+| Siren                           | [GitHub](https://github.com/sigp/siren)                                                                   | Oui, Apache 2.0 | [Sigma Prime](https://sigmaprime.io/)          | Non                                                                                                                                                 | Quelques lignes de commande, mais principalement une interface utilisateur web           | Fonctionne uniquement si vous utilisez le client de consensus Lighthouse                                        |
+| Consolideth.app | https://consolideth.app/ [GitHub](https://github.com/Stakely/consolideth) | Oui, licences MIT               | [Stakely](https://stakely.io/)                 | Non                                                                                                                                                 | UI Web, hébergée par Stakely et prête à être auto-hébergée gratuitement. | Prend en charge les connexions aux portefeuilles principaux, y compris Safe avec WalletConnect. |
+
+## FAQ {#faq}
+
+### Le fait d’opter pour ce changement modifie-t-il mes chances de proposer des blocs ou mes récompenses ? {#change-luck-or-rewards}
+
+Non. Faire ce changement ne diminue pas vos chances de proposer des blocs - vos tâches et la sélection des propositions restent inchangées. Par exemple, si vous avez deux validateurs de 32 ETH contre un seul validateur de 64 ETH, vous aurez exactement les mêmes chances totales d’être sélectionné pour proposer un bloc et gagner des récompenses.
+
+### Le fait d’opter pour ce changement modifie-t-il mon risque d'être sanctionné ? {#change-slashing-risk}
+
+Pour les petits opérateurs ou les opérateurs non professionnels, la réponse est non. La réponse plus détaillée est que, pour les opérateurs professionnels faisant tourner de nombreux validateurs par nœud avec un système d’alerte rapide, consolider en un plus petit nombre de validateurs peut réduire leur capacité à réagir rapidement à une sanction et à éviter les événements en cascade. La _pénalité_ initiale de sanction pour tous les validateurs a été fortement réduite, passant de 1 ETH (par tranche de 32 ETH) à 0,0078125 ETH (par tranche de 32 ETH), afin de compenser ce risque.
+
+### Dois-je faire sortir mon validateur pour effectuer la conversion ? {#exit-validator}
+
+Non. Vous pouvez effectuer la conversion directement, sans faire sortir votre validateur.
+
+### Combien de temps faut-il pour convertir ou consolider ? {#how-long}
+
+Un minimum de 27,3 heures, mais les consolidations sont également soumises à une file d’attente. Cette file d’attente est indépendante des files de dépôt et de retrait, et n’est pas affectée par celles-ci.
+
+### Puis-je conserver l’index de mon validateur ? {#keep-validator-index}
+
+Oui. La conversion conserve le même index de validateur. Si vous consolidez plusieurs validateurs, vous ne pourrez conserver que l’index du _validateur cible_.
+
+### Vais-je manquer des attestations ? {#miss-attestations}
+
+Lors d’une consolidation vers un autre validateur, le validateur source est sorti, et il y a une période d’attente d’environ 27 heures avant que le solde ne soit actif sur le validateur cible. Cette période **n’affecte pas les indicateurs de performance**.
+
+### Vais-je subir des pénalités ? {#incur-penalties}
+
+Non. Tant que votre validateur est en ligne, vous ne subirez pas de pénalités.
+
+### Les adresses de retrait des validateurs à consolider doivent-elles correspondre ? {#withdrawal-addresses-match}
+
+Non. Mais le _validateur source_ doit autoriser la demande depuis sa propre adresse.
+
+### Mes récompenses seront-elles capitalisées après la conversion ? {#rewards-compound}
+
+Oui. Avec des identifiants **Type 2**, les récompenses au-delà de 32 ETH sont automatiquement réinvesties — mais pas instantanément. En raison d’une petite marge (appelée [_hystérésis_](https://eth2book.info/capella/part2/incentives/balances/#hysteresis)), votre solde doit atteindre **environ 1,25 ETH de plus** avant que l’excédent ne soit réinvesti. Ainsi, au lieu d’être capitalisées à 33,0 ETH, les récompenses le sont à 33,25 ETH (solde effectif = 33 ETH), puis à 34,25 ETH (solde effectif = 34 ETH), et ainsi de suite.
+
+### Puis-je encore bénéficier des retraits automatiques après la conversion ? {#automatic-sweep}
+
+Les retraits automatiques n’auront lieu que pour les soldes excédentaires dépassant 2048 ETH. Pour tous les autres retraits partiels, vous devrez les déclencher manuellement.
+
+### Puis-je changer d’avis et repasser de Type 2 à Type 1 ? {#go-back-to-type1}
+
+Non. La conversion en **Type 2** est irréversible.
+
+### Si je veux consolider plusieurs validateurs, dois-je d’abord convertir chacun d’eux en Type 2 ? {#consolidate-multiple-validators}
+
+Non ! Convertissez un validateur en Type 2, puis utilisez-le comme validateur cible. Tous les autres validateurs consolidés dans ce validateur cible de Type 2 peuvent être de Type 1 ou de Type 2
+
+### Mon validateur est hors ligne ou possède moins de 32 ETH - puis-je quand même le convertir ? {#offline-or-below-32eth}
+
+Oui. Tant qu’il est actif (non sorti) et que vous pouvez signer avec son adresse de retrait, vous pouvez le convertir.
+
+## Ressources {#resources}
+
+- [Spécifications du consensus Electra](https://github.com/ethereum/consensus-specs/blob/master/specs/electra/beacon-chain.md) : Il s’agit de la version la plus fiable sur laquelle vous devriez vous appuyer. En cas de doute, lisez les spécifications
+- Tout le monde n’est pas à l’aise avec la lecture du code, donc [ce maxEB-GPT](https://chatgpt.com/g/g-67f1650fb48081918f555e0c8d1c2ae9-maxeb-gpt) peut aider à interpréter les spécifications. _Avertissement : ce sont les spécifications, et non l’IA, qui doivent être considérées comme source de vérité, car l’IA peut mal interpréter certaines informations ou produire des réponses erronées_
+- [pectrified.com](https://pectrified.com/) : Permet de consulter l’état des consolidations, des dépôts et des temps d’attente dans les files d’attente
+- [Ethereal](https://github.com/wealdtech/ethereal) : Outil en ligne de commande créé par la communauté pour gérer les tâches courantes des validateurs
+- [batch-validator-depositor](https://github.com/attestantio/batch-validator-depositor) : Contrat créé par la communauté permettant de déposer plusieurs validateurs Ethereum en une seule transaction
diff --git a/public/content/translations/fr/roadmap/scaling/index.md b/public/content/translations/fr/roadmap/scaling/index.md
index e55a71aeb3d..73699769930 100644
--- a/public/content/translations/fr/roadmap/scaling/index.md
+++ b/public/content/translations/fr/roadmap/scaling/index.md
@@ -1,6 +1,6 @@
 ---
-title: Mise à l'échelle d'Ethereum
-description: Les rollups regroupent des transactions hors chaîne, ce qui réduit les coûts pour l'utilisateur. Cependant, la manière dont les rollups utilisent les données est pour l'heure trop coûteuse, ce qui limite le coût des transactions. La solution Proto-Danksharding règle ce problème.
+title: "Mise à l'échelle d'Ethereum"
+description: "Les rollups regroupent des transactions hors chaîne, ce qui réduit les coûts pour l'utilisateur. Cependant, la manière dont les rollups utilisent les données est pour l'heure trop coûteuse, ce qui limite le coût des transactions. La solution Proto-Danksharding règle ce problème."
 lang: fr
 image: /images/roadmap/roadmap-transactions.png
 alt: "Feuille de route d'Ethereum"
@@ -23,7 +23,7 @@ Ethereum est mis à l'échelle à l'aide de [couches 2](/layer-2/#rollups) (éga
 </AlertContent>
 </Alert>
 
-## Rendre les données moins onéreuses {#making-data-cheaper}
+## Rendre les données moins chères {#making-data-cheaper}
 
 Les rollups collectent un grand nombre de transactions, les exécutent et soumettent les résultats à Ethereum. Ceci génère un maximum de données qui doivent être publiquement disponibles, pour que quiconque puisse exécuter les transactions et vérifier que l'opérateur du rollup soit intègre. Si une personne constate une divergence, cette dernière peut être contestée.
 
@@ -35,22 +35,24 @@ Avec le Proto-Danksharding, il est possible d'ajouter de nombreux blobs aux bloc
 
 ### Danksharding {#danksharding}
 
-La seconde étape de l'expansion des données blob est compliquée car elle nécessite de nouvelles méthodes pour vérifier que les données rollup sont disponibles sur le réseau, et elle dépend de [validateurs](/glossary/#validator) séparant leur responsabilité de création de [bloc](/glossary/#block) et de proposition de bloc. Cela nécessite également un moyen de prouver cryptographiquement que les validateurs ont vérifié de petits sous-ensembles de données blob.
+La deuxième étape de l'expansion des données blob est compliquée car elle nécessite de nouvelles méthodes pour vérifier que les données de rollup sont disponibles sur le réseau et repose sur la séparation, par les [validateurs](/glossary/#validator), de leurs responsabilités de construction de [bloc](/glossary/#block) et de proposition de bloc. Cela nécessite également un moyen de prouver cryptographiquement que les validateurs ont vérifié de petits sous-ensembles de données blob.
 
-Cette seconde étape est nommée [« Danksharding »](/roadmap/danksharding/). **Celle-ci prendra certainement plusieurs années** avant d'être totalement implémentée. La solution Danksharding repose sur d'autres développements tels que [la séparation entre la construction et la proposition de blocs](/roadmap/pbs) et de nouveaux modèles de réseau qui permettent à celui-ci de confirmer avec efficacité, que les données sont disponibles en échantillonnant de manière aléatoire quelques kilo-octets à la fois, aussi appelé [Échantillonnage de disponibilité des données (DAS)](/developers/docs/data-availability).
+Cette deuxième étape est connue sous le nom de [« Danksharding »](/roadmap/danksharding/). Les travaux d'implémentation se poursuivent, avec des progrès sur les prérequis comme [la séparation de la construction et de la proposition de blocs](/roadmap/pbs) et de nouvelles conceptions de réseau qui permettent au réseau de confirmer efficacement que les données sont disponibles en échantillonnant de manière aléatoire quelques kilo-octets à la fois, une méthode connue sous le nom [d'échantillonnage de disponibilité des données (DAS)](/developers/docs/data-availability).
 
-<ButtonLink variant="outline-color" href="/roadmap/danksharding/">En savoir plus sur la fragmentation</ButtonLink>
+<ButtonLink variant="outline-color" href="/roadmap/danksharding/">En savoir plus sur Danksharding</ButtonLink>
 
-## Décentraliser les rollups {#decentralizing-rollups}
+## Décentralisation des rollups {#decentralizing-rollups}
 
-[Les rollups](/layer-2) permettent déjà la mise à l'échelle d'Ethereum. Un[ riche écosystème de projets rollups](https://l2beat.com/scaling/tvl) permet aux utilisateurs d'effectuer des transactions rapidement et à moindre coût, avec divers niveaux de garantie de sécurité. Cependant, les rollups ont été initiés en utilisant des séquenceurs centralisés (ordinateurs qui effectuent l'ensemble du traitement et l'agrégation des transactions avant de les soumettre à Ethereum). Cette approche est vulnérable à la censure car, en d'autres termes, les opérateurs-séquenceurs peuvent être sanctionnés, soudoyés ou corrompus. Parallèlement,[ les rollups fluctuent](https://l2beat.com) de la façon dont ils valident les données entrantes. La meilleure voie possible, consiste à ce que les « provers/ceux qui prouvent » soumettent des [preuves de fraude](/glossary/#fraud-proof) ou de validité, mais tous les rollups n'ont pas encore atteint ce niveau. Même ceux qui utilisent des preuves de validité/fraude font appel à un petit groupe de « provers » réputés. Par conséquent, la prochaine étape cruciale dans la mise à l'échelle d'Ethereum consiste à répartir la responsabilité de l'exécution des séquenceurs et des provers, parmi davantage de personnes.
+[Les rollups](/layer-2) permettent déjà la mise à l'échelle d'Ethereum. Un [riche écosystème de projets de rollup](https://l2beat.com/scaling/tvs) permet aux utilisateurs d'effectuer des transactions rapidement et à moindre coût, avec une gamme de garanties de sécurité. Cependant, les rollups ont été initiés en utilisant des séquenceurs centralisés (ordinateurs qui effectuent l'ensemble du traitement et l'agrégation des transactions avant de les soumettre à Ethereum). Cette approche est vulnérable à la censure car, en d'autres termes, les opérateurs-séquenceurs peuvent être sanctionnés, soudoyés ou corrompus. En même temps, [les rollups varient](https://l2beat.com/scaling/summary) dans la manière dont ils valident les données entrantes. La meilleure façon est que les « provers » soumettent des [preuves de fraude](/glossary/#fraud-proof) ou des preuves de validité, mais les rollups n'en sont pas encore tous là. Même ceux qui utilisent des preuves de validité/fraude font appel à un petit groupe de « provers » réputés. Par conséquent, la prochaine étape cruciale dans la mise à l'échelle d'Ethereum consiste à répartir la responsabilité de l'exécution des séquenceurs et des provers, parmi davantage de personnes.
 
-<ButtonLink variant="outline-color" href="/developers/docs/scaling/">Plus d'infos sur les rollups</ButtonLink>
+<ButtonLink variant="outline-color" href="/developers/docs/scaling/">En savoir plus sur les rollups</ButtonLink>
 
 ## Progrès actuels {#current-progress}
 
-Le Proto-Danksharding est le premier élément de cette feuille de route à être implémenté comme faisant partie de la mise à niveau du réseau Cancun-Deneb (« Dencun ») en mars 2024. Or, **la mise en œuvre complète de la solution Danksharding reste peu évidente avant plusieurs années**, tant celle-ci dépend de la réalisation de plusieurs autres éléments de la feuille de route devant être concrétisés en première instance. La décentralisation de l'infrastructure de rollup sera probablement un processus progressif : il existe de nombreux rollups différents qui construisent des systèmes légèrement différents et seront entièrement décentralisés à des rythmes différents.
+Le Proto-Danksharding a été mis en œuvre avec succès dans le cadre de la mise à niveau du réseau Cancun-Deneb (« Dencun ») en mars 2024. Depuis sa mise en œuvre, les rollups ont commencé à utiliser le stockage de blobs, entraînant une réduction des frais de transaction pour les utilisateurs et des millions de transactions traitées dans des blobs.
 
-[Plus d'informations sur la mise à niveau du réseau Dencun](/roadmap/dencun/)
+Les travaux sur le Danksharding complet se poursuivent, avec des avancées sur ses prérequis tels que PBS (Proposer-Builder Separation) et DAS (Data Availability Sampling). La décentralisation de l'infrastructure de rollup est un processus progressif : il existe de nombreux rollups différents qui construisent des systèmes légèrement différents et seront entièrement décentralisés à des rythmes différents.
+
+[En savoir plus sur la mise à niveau du réseau Dencun et son impact](/roadmap/dencun/)
 
 <QuizWidget quizKey="scaling" />
diff --git a/public/content/translations/fr/roadmap/secret-leader-election/index.md b/public/content/translations/fr/roadmap/secret-leader-election/index.md
index 88aaadd6f88..979524c2caa 100644
--- a/public/content/translations/fr/roadmap/secret-leader-election/index.md
+++ b/public/content/translations/fr/roadmap/secret-leader-election/index.md
@@ -1,6 +1,6 @@
 ---
-title: Élection d'un chef secret
-description: Explication sur la manière dont l'élection du leader secret peut aider à protéger les validateurs contre certaines attaques
+title: "Élection secrète du leader"
+description: "Explication sur la manière dont l'élection du leader secret peut aider à protéger les validateurs contre certaines attaques"
 lang: fr
 summaryPoints:
   - L'adresse IP des proposeurs de blocs peut être connue à l'avance, les rendant vulnérables aux attaques.
@@ -8,19 +8,19 @@ summaryPoints:
   - Une extension de cette idée est de rendre la sélection des validateurs aléatoire pour chaque créneau.
 ---
 
-# Élection d'un chef secret {#single-secret-leader-election}
+# Élection secrète d'un leader unique {#single-secret-leader-election}
 
 Dans le mécanisme de consensus actuel basé sur la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos), la liste des futurs proposeurs de blocs est publique et il est possible de cartographier leurs adresses IP. Cela signifie que les attaquants pourraient identifier les validateurs censés proposer un bloc et cibler ces derniers via une attaque par déni de service (DOS) les rendant incapables de proposer leur bloc dans le temps imparti.
 
-Cela pourrait créer des opportunités de profit pour un attaquant. Ainsi, un proposeur de bloc sélectionné pour un créneau `n+1` pourrait attaquer par Déni de service (DOS) un autre proposant lors du même créneau `n`, l'empêchant de proposer un bloc. Ceci permettrait au proposeur de bloc attaquant d'extraire la MEV (Valeur Maximale Extractible) des deux créneaux, ou de rassembler toutes les transactions qui auraient dû être réparties sur deux blocs et de les inclure toutes dans un seul bloc, et ainsi percevoir l'ensemble des frais associés. Ceci affecterait probablement plutôt les validateurs particuliers que les validateurs institutionnels aguerris qui peuvent utiliser des méthodes plus sophistiquées pour se protéger des attaques DOS, et ainsi former une force centralisatrice.
+Cela pourrait créer des opportunités de profit pour un attaquant. Par exemple, un proposeur de bloc sélectionné pour le créneau `n+1` pourrait attaquer par DOS le proposeur dans le créneau `n` afin qu'il manque son opportunité de proposer un bloc. Ceci permettrait au proposeur de bloc attaquant d'extraire la MEV (Valeur Maximale Extractible) des deux créneaux, ou de rassembler toutes les transactions qui auraient dû être réparties sur deux blocs et de les inclure toutes dans un seul bloc, et ainsi percevoir l'ensemble des frais associés. Ceci affecterait probablement plutôt les validateurs particuliers que les validateurs institutionnels aguerris qui peuvent utiliser des méthodes plus sophistiquées pour se protéger des attaques DOS, et ainsi former une force centralisatrice.
 
-Il y a plusieurs solutions à ce problème. L'une est la [Technologie des Validateurs Distribués](https://github.com/ethereum/distributed-validator-specs) qui vise à répartir plusieurs tâches nécessaires pour faire fonctionner un validateur sur plusieurs machines, avec de la redondance, de sorte qu'il soit bien plus difficile pour un attaquant d'empêcher un bloc d'être proposé sur un créneau particulier. Toutefois, la solution la plus robuste est **L'Élection d'un Leader Secret Unique (SSLE)**.
+Il y a plusieurs solutions à ce problème. L'une est la [Technologie des validateurs distribués](https://github.com/ethereum/distributed-validator-specs) qui vise à répartir les diverses tâches liées à l'exécution d'un validateur sur plusieurs machines, avec de la redondance, de sorte qu'il soit beaucoup plus difficile pour un attaquant d'empêcher qu'un bloc soit proposé dans un créneau particulier. Cependant, la solution la plus robuste est l'**élection secrète d'un leader unique (SSLE)**.
 
-## Élection d'un leader en secret unique {#secret-leader-election}
+## Élection secrète d'un leader unique {#secret-leader-election}
 
 Dans le SSLE, la cryptographie est utilisée de manière astucieuse pour assurer que seul le validateur sélectionné sache qu'il a été sélectionné. Pour que cela fonctionne, chaque validateur doit soumettre un engagement pour un secret qu'ils partagent tous. Les engagements sont mélangés et reconfigurés de sorte que personne ne puisse remonter aux validateurs à partir des engagements mais chaque validateur sait quel engagement lui appartient. Un engagement est alors choisi au hasard. Si un validateur détecte que leur engagement a été choisi, il sait que c'est à son tour de proposer un bloc.
 
-L'implémentation dominante de cette idée s'appelle [Whisk](https://ethresear.ch/t/whisk-a-practical-shuffle-based-ssle-protocol-for-ethereum/11763). Elle fonctionne comme ceci :
+La principale mise en œuvre de cette idée s'appelle [Whisk](https://ethresear.ch/t/whisk-a-practical-shuffle-based-ssle-protocol-for-ethereum/11763). Elle fonctionne comme ceci :
 
 1. Les validateurs s'engagent sur un secret partagé. Le schéma d'engagement est conçu de telle sorte qu'il peut être attaché à l'identité d'un validateur mais il peut aussi être soumis à un aléa afin qu'aucun tiers ne puisse retrouver par ingénierie inversée l'association et relier un engagement particulier à un validateur particulier.
 2. Au début d'une période, un ensemble aléatoire de validateurs est choisi pour échantillonner les engagements de 16 384 validateurs en utilisant RANDAO.
@@ -31,14 +31,14 @@ L'implémentation dominante de cette idée s'appelle [Whisk](https://ethresear.c
 
 Cela empêche les attaquants de connaître à l'avance quel validateur spécifique proposera le bloc suivant, écartant ainsi la possibilité d'attaques DOS.
 
-## Élection secrète d'un leader non-unique (SnSLE) {#secret-non-single-leader-election}
+## Élection secrète de leader non unique (SnSLE) {#secret-non-single-leader-election}
 
-Il existe également une proposition distincte visant à créer un scénario, dans lequel les validateurs possèdent chacun une chance aléatoire de proposer un bloc pour chaque créneau de manière similaire à la façon de proposer un bloc dans le cadre de la preuve de travail, plus connue sous l'appellation d'**élection secrète d'un leader non-unique (SnSLE)**. Une façon assez simple d'agir ainsi est d'utiliser la fonction RANDAO destinée à sélectionner des validateurs de manière aléatoire, au sein du protocole du jour. Le principe de RANDAO est qu'un nombre suffisamment aléatoire est généré en mixant les empreintes soumises par de multiples validateurs indépendants. Avec le protocole SnSLE, ces empreintes peuvent être exploitées pour choisir le proposeur du bloc suivant, par exemple en optant pour l'empreinte de valeur la plus faible. L'éventail des empreintes valides peut être limité, afin d'ajuster l'éventualité de la sélection de validateurs individuels dans chaque créneau. Ainsi, en affirmant que le hachage se doit d'être inférieur à` 2^256 * 5 / N`, où` N` = nombre de validateurs actifs, la probabilité qu'un validateur individuel soit sélectionné dans chaque créneau serait de` 5/N`. Dans cet exemple, il y aurait 99,3 % de chances qu'au moins un proposant génère un hachage valide dans chaque créneau.
+Il existe également une proposition distincte qui vise à créer un scénario où chaque validateur a une chance aléatoire de proposer un bloc dans chaque créneau, de la même manière que la proposition de bloc était décidée sous la preuve de travail ; ce mécanisme est connu sous le nom d'**élection secrète de leader non unique (SnSLE)**. Une façon assez simple d'agir ainsi est d'utiliser la fonction RANDAO destinée à sélectionner des validateurs de manière aléatoire, au sein du protocole du jour. Le principe de RANDAO est qu'un nombre suffisamment aléatoire est généré en mixant les empreintes soumises par de multiples validateurs indépendants. Avec le protocole SnSLE, ces empreintes peuvent être exploitées pour choisir le proposeur du bloc suivant, par exemple en optant pour l'empreinte de valeur la plus faible. L'éventail des empreintes valides peut être limité, afin d'ajuster l'éventualité de la sélection de validateurs individuels dans chaque créneau. En affirmant que le hachage doit être inférieur à `2^256 * 5 / N` où N = nombre de validateurs actifs, la chance pour un validateur individuel d'être sélectionné dans chaque créneau serait de `5/N`. Dans cet exemple, il y aurait 99,3 % de chances qu'au moins un proposant génère un hachage valide dans chaque créneau.
 
 ## Progrès actuels {#current-progress}
 
 Les protocoles SSLE et SnSLE sont tous deux en phase de recherche. À ce jour, il n'existe pas encore de spécification finalisée pour l'une ou l'autre de ces idées. SSLE et SnSLE sont des propositions concurrentes qui ne peuvent être toutes deux mises en œuvre. Avant d'être déployés, ces derniers doivent faire l'objet d'une recherche et d'un développement plus approfondis, d'un prototypage et d'une mise en œuvre sur des réseaux de test publics.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [SnSLE](https://ethresear.ch/t/secret-non-single-leader-election/11789)
diff --git a/public/content/translations/fr/roadmap/security/index.md b/public/content/translations/fr/roadmap/security/index.md
index d2b59ee23a3..2fdc591e5f6 100644
--- a/public/content/translations/fr/roadmap/security/index.md
+++ b/public/content/translations/fr/roadmap/security/index.md
@@ -1,48 +1,49 @@
 ---
-title: Un Ethereum plus sûr
-description: Ethereum est la plateforme de contrats intelligents la plus sûre et la plus décentralisée qui existe. Cependant, des améliorations peuvent encore être apportées pour qu'Ethereum reste résistant à tout niveau d'attaque à l'avenir.
+title: "Un Ethereum plus sûr"
+description: "Ethereum est la plateforme de contrats intelligents la plus sûre et la plus décentralisée qui existe. Cependant, des améliorations peuvent encore être apportées pour qu'Ethereum reste résistant à tout niveau d'attaque à l'avenir."
 lang: fr
-image: /images/roadmap/roadmap-ux.png
+image: /images/roadmap/roadmap-security.png
 alt: "Feuille de route d'Ethereum"
 template: roadmap
 ---
 
-**Ethereum est déjà une plateforme très sûre**, décentralisée, de [contrats intelligents](/glossary/#smart-contract). Néanmoins, des améliorations peuvent encore être apportées pour qu'Ethereum reste résistant à tous les types d'attaques à l'avenir. Il s'agit notamment de modifications subtiles de la manière dont les [clients Ethereum](/glossary/#consensus-client) traitent les [blocs](/glossary/#block) concurrents, ainsi que de l'augmentation de la vitesse à laquelle le réseau considère que les blocs sont [« finalisés »](/developers/docs/consensus-mechanisms/pos/#finality) (ce qui signifie qu'ils ne peuvent pas être modifiés sans entraîner des pertes économiques considérables pour un attaquant).
+**Ethereum est déjà une plateforme de [contrats intelligents](/glossary/#smart-contract) décentralisée et très sécurisée**. Néanmoins, des améliorations peuvent encore être apportées pour qu'Ethereum reste résistant à tous les types d'attaques à l'avenir. Il s'agit notamment de modifications subtiles de la manière dont les [clients Ethereum](/glossary/#consensus-client) traitent les [blocs](/glossary/#block) concurrents, ainsi que de l'augmentation de la vitesse à laquelle le réseau considère que les blocs sont [« finalisés »](/developers/docs/consensus-mechanisms/pos/#finality) (ce qui signifie qu'ils ne peuvent pas être modifiés sans entraîner des pertes économiques considérables pour un attaquant).
 
-Il existe également des améliorations qui rendent la censure des transactions beaucoup plus difficile en rendant les auteurs de propositions de blocs aveugles au contenu réel de leurs blocs, ainsi que de nouveaux moyens d'identifier lorsqu'un client censure. L'ensemble de ces améliorations permettra d'améliorer le protocole de [preuve d'enjeu](/glossary/#pos) afin que les utilisateurs - qu'il s'agisse de particuliers ou d'entreprises - aient une confiance instantanée dans leurs applications, leurs données et leurs actifs sur Ethereum.
+Il existe également des améliorations qui rendent la censure des transactions beaucoup plus difficile en rendant les auteurs de propositions de blocs aveugles au contenu réel de leurs blocs, ainsi que de nouveaux moyens d'identifier lorsqu'un client censure. Ensemble, ces améliorations mettront à niveau le protocole de [preuve d'enjeu](/glossary/#pos) afin que les utilisateurs, des particuliers aux entreprises, aient une confiance instantanée dans leurs applications, leurs données et leurs actifs sur Ethereum.
 
-## Retraits de la mise en jeu {#staking-withdrawals}
+## Retraits de staking {#staking-withdrawals}
 
-La transition de la [preuve de travail](/glossary/#pow) à la preuve d'enjeu a commencé avec les pionniers d'Ethereum qui ont « mis en jeu » leur ETH dans un contrat de dépôt. Cet ETH est utilisé pour protéger le réseau. Il y a eu une seconde mise à jour le 12 avril 2023 dans le but d'autoriser le retrait de l'ETH mis en jeu. Depuis lors, les validateurs peuvent librement mettre en jeu ou retirer leurs ETH.
+La mise à niveau de la [preuve de travail](/glossary/#pow) vers la preuve d'enjeu a commencé avec les pionniers d'Ethereum qui ont « staké » leur ETH dans un contrat de dépôt. Cet ETH est utilisé pour protéger le réseau. Une deuxième mise à jour a eu lieu le 12 avril 2023 pour permettre aux validateurs de retirer l'ETH staké. Depuis lors, les validateurs peuvent librement mettre en jeu ou retirer leurs ETH.
 
-<ButtonLink variant="outline-color" href="/staking/withdrawals/">À propos des retraits</ButtonLink>
+<ButtonLink variant="outline-color" href="/staking/withdrawals/">En savoir plus sur les retraits</ButtonLink>
 
-## Se défendre contre les attaques {#defending-against-attacks}
+## Défense contre les attaques {#defending-against-attacks}
 
-Il existe un certain nombre d'améliorations qui peuvent être apportées au protocole de preuve d'enjeu d'Ethereum. L'une est connue sous le nom de [agrégation de points de vue](https://ethresear.ch/t/view-merge-as-a-replacement-for-proposer-boost/13739) - un algorithme de choix de [bifurcation](/glossary/#fork) plus sécurisé qui rend certains types d'attaques sophistiquées plus difficiles.
+Il existe un certain nombre d'améliorations qui peuvent être apportées au protocole de preuve d'enjeu d'Ethereum. L'un est connu sous le nom de [view-merge](https://ethresear.ch/t/view-merge-as-a-replacement-for-proposer-boost/13739) - un algorithme de choix de [fourche](/glossary/#fork) plus sécurisé qui rend plus difficiles certains types d'attaques sophistiquées.
 
-Réduire le temps que prend Ethereum pour [finaliser](/glossary/#finality) les blocs offrirait une meilleure expérience utilisateur et empêcherait les attaques sophistiquées de « reorg » où les attaquants essaient de réorganiser les blocs très récents pour en tirer profit ou censurer certaines transactions. [**La finalité à créneau unique (SSF)**](/roadmap/single-slot-finality/) est un **moyen de minimiser le délai de finalisation**. Actuellement, il y a l'équivalent de 15 minutes de blocs qu'un attaquant pourrait théoriquement convaincre d'autres validateurs de reconfigurer. Avec SSF, il y en aurait 0. Les utilisateurs, des individus aux applications jusqu'aux échanges, bénéficient d'une assurance rapide que leurs transactions ne seront pas annulées, et le réseau bénéficie lui de l'élimination d'une catégorie entière d'attaques.
+Réduire le temps qu'il faut à Ethereum pour [finaliser](/glossary/#finality) les blocs permettrait d'offrir une meilleure expérience utilisateur et d'empêcher les attaques sophistiquées de « réorganisation » où les attaquants tentent de remanier des blocs très récents pour en extraire des bénéfices ou pour censurer certaines transactions. [**La finalité à slot unique (SSF)**](/roadmap/single-slot-finality/) est un **moyen de minimiser le délai de finalisation**. Actuellement, il y a l'équivalent de 15 minutes de blocs qu'un attaquant pourrait théoriquement convaincre d'autres validateurs de reconfigurer. Avec SSF, il y en aurait 0. Les utilisateurs, des individus aux applications jusqu'aux échanges, bénéficient d'une assurance rapide que leurs transactions ne seront pas annulées, et le réseau bénéficie lui de l'élimination d'une catégorie entière d'attaques.
 
-<ButtonLink variant="outline-color" href="/roadmap/single-slot-finality/">En apprendre plus à propos de la finalité à créneau unique</ButtonLink>
+<ButtonLink variant="outline-color" href="/roadmap/single-slot-finality/">En savoir plus sur la finalité à slot unique</ButtonLink>
 
-## Se défendre contre la censure {#defending-against-censorship}
+## Défense contre la censure {#defending-against-censorship}
 
-La décentralisation empêche des individus ou de petits groupes de [validateurs](/glossary/#validator) de devenir trop influents. Les nouvelles technologies de mise en jeu peuvent aider à garantir que les validateurs d'Ethereum restent aussi décentralisés que possible tout en les protégeant contre les pannes matérielles, logicielles et de réseau. Cela inclut un logiciel qui partage les responsabilités du validateur entre plusieurs [nœuds](/glossary/#node). C'est ce qu'on appelle la **technologie de validation distribuée (DVT)**. [Les pools de mise en jeu](/glossary/#staking-pool) sont incités à utiliser le DVT car il permet à plusieurs ordinateurs de participer collectivement à la validation, ajoutant ainsi une redondance et une tolérance aux pannes. Cela divise également les clés du validateur entre plusieurs systèmes, plutôt que d'avoir des opérateurs individuels exécutant plusieurs validateurs. Cela rend plus difficile pour les opérateurs malhonnêtes de coordonner des attaques sur Ethereum. Globalement, l'idée est de gagner en matière de sécurité en faisant fonctionner les validateurs en tant que _communautés_ plutôt qu'en tant qu'individus.
+La décentralisation empêche des individus ou des petits groupes de [validateurs](/glossary/#validator) de devenir trop influents. Les nouvelles technologies de mise en jeu peuvent aider à garantir que les validateurs d'Ethereum restent aussi décentralisés que possible tout en les protégeant contre les pannes matérielles, logicielles et de
+réseau. Cela inclut des logiciels qui partagent les responsabilités des validateurs sur plusieurs [nœuds](/glossary/#node). Ceci est connu sous le nom de **technologie de validateur distribué (DVT)**. Les [pools de staking](/glossary/#staking-pool) sont incités à utiliser la DVT car elle permet à plusieurs ordinateurs de participer collectivement à la validation, ce qui ajoute de la redondance et de la tolérance aux pannes. Cela divise également les clés du validateur entre plusieurs systèmes, plutôt que d'avoir des opérateurs individuels exécutant plusieurs validateurs. Cela rend plus difficile pour les opérateurs malhonnêtes de coordonner des attaques sur Ethereum. Dans l'ensemble, l'idée est de tirer des avantages en matière de sécurité en faisant fonctionner les validateurs en tant que _communautés_ plutôt qu'en tant qu'individus.
 
-<ButtonLink variant="outline-color" href="/staking/dvt/">En apprendre plus à propos de la technologie de validation distribuée</ButtonLink>
+<ButtonLink variant="outline-color" href="/staking/dvt/">En savoir plus sur la technologie de validateur distribué</ButtonLink>
 
-La mise en œuvre de la **séparation proposeur-constructeur (PBS)** améliorera considérablement les défenses intégrées d'Ethereum contre la censure. PBS permet à un validateur de créer un bloc et à un autre de le diffuser à travers le réseau Ethereum. Cela garantit que les gains provenant des algorithmes de construction de blocs axés sur la maximisation des profits sont partagés plus équitablement à travers le réseau, **empêchant la concentration ** chez les stakers institutionnels les plus performants au fil du temps. Le proposeur de bloc a la possibilité de sélectionner le bloc le plus rentable qui lui est proposé par un marché de constructeurs de blocs. Pour censurer, un proposeur de bloc devrait souvent choisir un bloc moins rentable, ce qui serait **économiquement irrationnel et également évident pour le reste des validateurs** sur le réseau.
+La mise en œuvre de la **séparation proposant-constructeur (PBS)** améliorera considérablement les défenses intégrées d'Ethereum contre la censure. PBS permet à un validateur de créer un bloc et à un autre de le diffuser à travers le réseau Ethereum. Cela garantit que les gains des algorithmes de construction de blocs professionnels optimisant les profits sont partagés plus équitablement sur le réseau, **empêchant la concentration de la participation** au fil du temps entre les stakers institutionnels les plus performants. Le proposeur de bloc a la possibilité de sélectionner le bloc le plus rentable qui lui est proposé par un marché de constructeurs de blocs. Pour censurer, un proposant de bloc devrait souvent choisir un bloc moins rentable, ce qui serait **économiquement irrationnel et également évident pour le reste des validateurs** sur le réseau.
 
 Il existe des ajouts potentiels à PBS, tels que les transactions chiffrées et les listes d'inclusion, qui pourraient améliorer davantage la résistance à la censure d'Ethereum. Ces éléments rendent le constructeur de blocs et le proposeur ignorants des transactions réelles incluses dans leurs blocs.
 
-<ButtonLink variant="outline-color" href="/roadmap/pbs/">En apprendre plus à propos de la séparation entre le constructeur et le proposeur</ButtonLink>
+<ButtonLink variant="outline-color" href="/roadmap/pbs/">En savoir plus sur la séparation proposant-constructeur</ButtonLink>
 
-## Protéger les validateurs {#protecting-validators}
+## Protection des validateurs {#protecting-validators}
 
-Il est possible qu'un attaquant sophistiqué puisse identifier les validateurs imminents et les spammer pour les empêcher de proposer des blocs ; cela s'appelle une **attaque par déni de service (DoS)**. Implémenter [**l'élection secrète du leader (SLE)**](/roadmap/secret-leader-election) protégera contre ce type d'attaque en empêchant les proposants de bloc d'être connus à l'avance. Cela fonctionne en mélangeant continuellement un ensemble d'engagements cryptographiques représentant les candidats proposeurs de blocs et en utilisant leur ordre pour déterminer quel validateur est sélectionné de telle manière que seuls les validateurs eux-mêmes connaissent leur ordre à l'avance.
+Il est possible qu'un attaquant sophistiqué puisse identifier les validateurs à venir et les spammer pour les empêcher de proposer des blocs ; c'est ce que l'on appelle une attaque par **déni de service (DoS)**. La mise en œuvre de l'[**élection secrète du leader (SLE)**](/roadmap/secret-leader-election) protégera contre ce type d'attaque en empêchant les proposants de blocs d'être connus à l'avance. Cela fonctionne en mélangeant continuellement un ensemble d'engagements cryptographiques représentant les candidats proposeurs de blocs et en utilisant leur ordre pour déterminer quel validateur est sélectionné de telle manière que seuls les validateurs eux-mêmes connaissent leur ordre à l'avance.
 
-<ButtonLink variant="outline-color" href="/roadmap/secret-leader-election">En apprendre plus à propos de l'élection d'un leader secret</ButtonLink>
+<ButtonLink variant="outline-color" href="/roadmap/secret-leader-election">En savoir plus sur l'élection secrète du leader</ButtonLink>
 
 ## Progrès actuels {#current-progress}
 
-**Les mises à niveau de sécurité figurant sur la feuille de route sont à des stades de recherche avancés**, mais leur mise en œuvre n'est pas prévue avant un certain temps. Les prochaines étapes pour view-merge, PBS, SSF et SLE consistent à finaliser une spécification et à commencer à construire des prototypes.
+**Les mises à niveau de sécurité sur la feuille de route sont à des stades de recherche avancés**, mais leur mise en œuvre n'est pas attendue avant un certain temps. Les prochaines étapes pour view-merge, PBS, SSF et SLE sont de finaliser une spécification et de commencer à construire des prototypes.
diff --git a/public/content/translations/fr/roadmap/single-slot-finality/index.md b/public/content/translations/fr/roadmap/single-slot-finality/index.md
index ae46bdd68fe..4d6322cb011 100644
--- a/public/content/translations/fr/roadmap/single-slot-finality/index.md
+++ b/public/content/translations/fr/roadmap/single-slot-finality/index.md
@@ -1,22 +1,23 @@
 ---
-title: Finalité à créneau unique
-description: Tout savoir sur le protocole de Finalité à créneau unique
+title: "Finalité à créneau unique"
+description: "Tout savoir sur le protocole de Finalité à créneau unique"
 lang: fr
 ---
 
 # Finalité à créneau unique {#single-slot-finality}
 
-Cela demande à peu près 15 minutes pour qu’un bloc Ethereum soit finalisé. Cependant, nous pouvons faire en sorte que le mécanisme de consensus d'Ethereum valide les blocs plus efficacement et réduise considérablement le délai de finalisation. Plutôt que d'attendre quinze minutes, les blocs pourraient être proposés et finalisés dans le même créneau. Ce concept est connu** sous l'appellation de Single Slot Finality (SSF) ou Finalité à créneau unique.**
+Cela demande à peu près 15 minutes pour qu’un bloc Ethereum soit finalisé. Cependant, nous pouvons faire en sorte que le mécanisme de consensus d'Ethereum valide les blocs plus efficacement et réduise considérablement le délai de finalisation. Plutôt que d'attendre quinze minutes, les blocs pourraient être proposés et finalisés dans le même créneau. Ce concept est connu sous le nom de **finalité à créneau unique (SSF)**.
 
 ## Qu’est-ce que la finalité ? {#what-is-finality}
 
-Dans le mécanisme de consensus basé sur la preuve d'enjeu d'Ethereum, la finalité fait référence à la garantie qu'un bloc ne peut pas être modifié ou supprimé de la blockchain sans que cela n'entraîne de l'action brûler (destruction) au moins 33 % de l'ETH total mis en jeu. Il s'agit d'une sécurité « crypto-économique » car la confiance provient du coût extrêmement élevé, associé à la modification de l'ordre ou du contenu de la chaîne, ce qui empêcherait tout acteur économique rationnel de tenter d'effectuer ce genre d'action.
+Dans le mécanisme de consensus basé sur la preuve d'enjeu d'Ethereum, la finalité fait référence à la garantie qu'un bloc ne peut pas être modifié ou supprimé de la blockchain sans que cela n'entraîne de l'action brûler (destruction) au moins 33 % de l'ETH total mis en jeu.
+Il s'agit d'une sécurité « crypto-économique » car la confiance provient du coût extrêmement élevé, associé à la modification de l'ordre ou du contenu de la chaîne, ce qui empêcherait tout acteur économique rationnel de tenter d'effectuer ce genre d'action.
 
 ## Pourquoi viser une finalité plus rapide ? {#why-aim-for-quicker-finality}
 
 La durée actuelle de la finalité s'est avéré être trop longue. La plupart des utilisateurs ne désirent pas attendre 15 minutes pour le processus de finalité. C'est plutôt gênant pour les applications et autres plateformes d'échange qui ont plutôt besoin d'un débit de transaction élevé, mais doivent patienter tout ce temps afin d'être assurés que leurs transactions soient permanentes. Le délai entre la proposition d'un bloc et sa finalisation crée également une opportunité de courtes réorganisations qu'un attaquant pourrait utiliser pour censurer certains blocs ou extraire la Valeur maximale extractible (MEV). Le mécanisme qui gère la mise à niveau des blocs par étapes est également assez complexe et a été corrigé à plusieurs reprises pour corriger les vulnérabilités de sécurité, ce qui en fait l'une des parties de la base de code Ethereum où des bogues subtils sont les plus susceptibles de survenir. Ces dilemmes pourraient tous être éradiqués en réduisant le temps de finalité à un seul créneau.
 
-## Le compromis décentralisation/temps/frais généraux {#the-decentralization-time-overhead-tradeoff}
+## Le compromis décentralisation / temps / surcharge {#the-decentralization-time-overhead-tradeoff}
 
 La garantie de finalité n'est pas une propriété immédiate d'un nouveau bloc ; il faut du temps pour qu'un nouveau bloc se finalise. La raison en est que les validateurs représentant au moins 2/3 du total des ETH mis en jeu sur le réseau doivent voter pour le bloc (« attester ») afin qu'il soit considéré comme finalisé. Chaque nœud de validation du réseau doit traiter les attestations d'autres nœuds, dans le but de savoir si un bloc a ou n'a pas atteint ce fameux seuil des 2/3.
 
@@ -31,9 +32,9 @@ L'actuel mécanisme de consensus d'Ethereum a équilibré ces trois paramètres
 
 Avec l'actuelle conception du mécanisme, et dans l'espoir de réduire le délai à la finalité, il est donc impératif de réduire le nombre de validateurs sur le réseau, ou bien d'augmenter les exigences matérielles (hardware) pour chaque nœud. Cependant, des améliorations peuvent être apportées à la manière dont les attestations sont traitées, ce qui pourrait permettre de compter davantage d'attestations sans ajouter de surcharge à chaque nœud. C'est pourquoi le traitement le plus efficace permettra de déterminer la finalité à l'intérieur d'un seul créneau, plutôt qu'à travers deux périodes distinctes.
 
-## Routes vers la finalité à créneau unique ou Single Slot Finality (SSF) {#routes-to-ssf}
+## Voies vers la SSF {#routes-to-ssf}
 
-<ExpandableCard title= "Pourquoi nous ne pouvons pas bénéficier aujourd'hui de la Finalité à créneau unique (SSF) ?" eventCategory="/roadmap/single-slot-finality" eventName="clicked Why can't we hear SSF today?">
+<ExpandableCard title= "Pourquoi la SSF n'est-elle pas possible aujourd'hui ?" eventCategory="/roadmap/single-slot-finality" eventName="clicked Why can't we hear SSF today?">
 
 Le mécanisme de consensus actuel combine les attestations de plusieurs validateurs, aussi appelés comités, et ce, pour réduire le nombre de messages que chaque validateur doit traiter pour valider un bloc. Chaque validateur a la possibilité d'attester à chaque période (32 créneaux), cependant, dans chaque créneau, seul un sous-ensemble de validateurs, appelé « comité », a le pouvoir d'attester. Ils agissent ainsi en se divisant en sous-réseaux parmi lesquels quelques validateurs sont sélectionnés pour devenir « agrégateurs ». Ces agrégateurs combinent chacun toutes les signatures qu'ils voient provenant d'autres validateurs de leur sous-réseau en une seule signature globale. L'agrégateur qui comprend le plus grand nombre de contributions individuelles transmet sa signature globale à l'auteur du bloc (proposant), et ce dernier l'inclut dans le bloc avec la signature agrégée des autres comités.
 
@@ -44,23 +45,23 @@ Concernant ce schéma, chaque validateur n'a la possibilité de voter sur un blo
 
 Depuis la conception du mécanisme de consensus Ethereum, le système d'agrégation des signatures (BLS) s'est révélé beaucoup plus évolutif qu'on n'eût pu l'imaginer au départ, tandis que la capacité des clients à traiter et vérifier les signatures s'est également améliorée. Il s'avère que le traitement des attestations d'un grand nombre de validateurs est en fait rendu possible à l'intérieur d'un seul et même créneau. Exemple : avec un million de validateurs votant chacun deux fois dans chaque créneau, et des créneaux horaires calibrés à 16 secondes, les nœuds seraient poussés à vérifier les signatures lors d'un rythme minimum de 125 000 agrégations par seconde, afin de traiter l'ensemble du million d'attestations à l'intérieur dudit créneau. En réalité, il faut environ 500 nanosecondes à un ordinateur normal pour vérifier une signature, entendant le fait que 125 000 signatures peuvent être vérifiées en environ 62,5 ms, soit bien en deçà du seuil d'une seconde.
 
-Des gains d'efficacité supplémentaires pourraient être accomplis en créant des super-comités composés, par exemple, de 125 000 validateurs par créneau sélectionnés de manière aléatoire. Seuls ces validateurs pourraient voter sur un bloc et, par conséquent, uniquement ce sous-ensemble de validateurs déciderait, ou non, de la finalisation d'un bloc. Que ce soit une bonne idée ou non dépend du coût que la communauté préférerait pour une attaque réussie contre Ethereum. En effet, au lieu d'exiger 2/3 du total de l'ether mis en jeu, un attaquant pourrait finaliser un bloc illégitime avec 2/3 des Ethers (ETH) mis en jeu _parmi ce super-comité_. À l'heure actuelle, il s'agit encore d'un domaine de recherche actif, mais il semble plausible au premier abord, que pour un ensemble de validateurs suffisamment important pour nécessiter des super-comités, le coût de l'attaque d'un de ces sous-comités soit extrêmement élevé (p. ex. le coût de l'attaque exprimée en ETH serait de `2/3 * 125 000 * 32 = 2,6 millions d'ETH`). Le coût de l'attaque peut être ajusté en augmentant la taille de l'ensemble des validateurs (par exemple, ajuster la taille du validateur pour que le coût de l'attaque soit égal à 1 million d'éther, 4 millions d'éther, 10 millions d'éther, etc.). [Les sondages préliminaires](https://youtu.be/ojBgyFl6-v4?t=755) de la communauté semblent indiquer qu'un coût d'attaque de 1 à 2 millions d'éthers s'avère acceptable, ce qui implique entre 65 536 et 97 152 validateurs par super-comité.
+D'autres gains d'efficacité pourraient être réalisés en créant des super-comités de, par exemple, 125 000 validateurs par créneau, sélectionnés de manière aléatoire. Seuls ces validateurs pourraient voter sur un bloc et, par conséquent, uniquement ce sous-ensemble de validateurs déciderait, ou non, de la finalisation d'un bloc. Que ce soit une bonne idée ou non dépend du coût que la communauté préférerait pour une attaque réussie contre Ethereum. En effet, au lieu d'exiger 2/3 de la totalité des ethers mis en jeu, un attaquant pourrait finaliser un bloc malhonnête avec 2/3 des ethers mis en jeu _au sein de ce super-comité_. Il s'agit encore d'un domaine de recherche actif, mais il semble plausible que pour un ensemble de validateurs suffisamment grand pour nécessiter des super-comités, le coût d'une attaque sur l'un de ces sous-comités soit extrêmement élevé (p. ex., le coût d'attaque libellé en ETH serait de `2/3 * 125 000 * 32 = ~2,6 millions d'ETH`). Le coût de l'attaque peut être ajusté en augmentant la taille de l'ensemble des validateurs (par exemple, en ajustant la taille de l'ensemble de validateurs pour que le coût de l'attaque soit égal à 1 million d'ethers, 4 millions d'ethers, 10 millions d'ethers, etc.). [Les sondages préliminaires](https://youtu.be/ojBgyFl6-v4?t=755) de la communauté semblent indiquer qu'un coût d'attaque de 1 à 2 millions d'éthers s'avère acceptable, ce qui implique ~65 536 - 97 152 validateurs par super-comité.
 
 Toutefois, la vérification n'est pas le véritable point d'engorgement - c'est bien l'agrégation des signatures qui constitue un véritable défi pour les nœuds de validation. Pour faire évoluer l'agrégation des signatures, il faudra probablement augmenter le nombre de validateurs à l'intérieur de chaque sous-réseau, accroître le nombre de sous-réseaux ou encore ajouter des couches supplémentaires d'agrégation (c'est-à-dire mettre en place des comités de comités). Une partie de la solution consisterait à autoriser des agrégateurs experts - similaire à la manière dont la construction de blocs et la génération d'engagements pour les données rollup seront sous-traitées à des constructeurs de blocs spécialisés dans le cadre de la séparation entre le proposant et le constructeur de bloc (PBS), ainsi que de la méthode Danksharding (technique qui permet de partitioner un ensemble de données venant d'une même base de données).
 
 ## Quel est le rôle de la règle de choix de fourche dans le cadre SSF (Finalité à créneau unique) ? {#role-of-the-fork-choice-rule}
 
-Le mécanisme de consensus actuel repose sur un couplage étroit entre le dispositif de finalité (l'algorithme qui détermine si 2/3 des validateurs ont attesté d'une certaine chaîne) et la règle du choix de fourche (l'algorithme qui décide quelle chaîne est la plus appropriée lorsque plusieurs options sont possibles). L'algorithme de choix de fourche ne prend en compte que les blocs _depuis_ le dernier bloc finalisé. À l'intérieur du cadre de la Finalité à créneau unique (SSF), il n'y aurait aucun bloc à prendre en compte pour la règle de choix de fourche, car la finalité se produit dans le même créneau que celui où le bloc est proposé. Cela signifie qu'en vertu de la SSF, _soit_ l'algorithme de choix de fourche _soit_ le dispositif de finalité serait opérationnel à tout moment. Le dispositif de finalité finaliserait les blocs pour lesquels les deux tiers des validateurs étaient en ligne et attestaient honnêtement. Si un bloc n'est pas en mesure de surpasser le seuil des deux tiers, la règle du choix de fourche intervient pour déterminer la chaîne à suivre. Cela crée également une opportunité de maintenir le mécanisme de brèche d'inactivité qui rétablit une chaîne où >1/3 des validateurs sont hors-ligne, nonobstant quelques nuances supplémentaires.
+Le mécanisme de consensus actuel repose sur un couplage étroit entre le dispositif de finalité (l'algorithme qui détermine si 2/3 des validateurs ont attesté d'une certaine chaîne) et la règle du choix de fourche (l'algorithme qui décide quelle chaîne est la plus appropriée lorsque plusieurs options sont possibles). L'algorithme de choix de fourche ne prend en compte que les blocs _depuis_ le dernier bloc finalisé. À l'intérieur du cadre de la Finalité à créneau unique (SSF), il n'y aurait aucun bloc à prendre en compte pour la règle de choix de fourche, car la finalité se produit dans le même créneau que celui où le bloc est proposé. Cela signifie que sous SSF, _soit_ l'algorithme de choix de fourche, _soit_ le gadget de finalité serait actif à tout moment. Le dispositif de finalité finaliserait les blocs pour lesquels les deux tiers des validateurs étaient en ligne et attestaient honnêtement. Si un bloc n'est pas en mesure de surpasser le seuil des deux tiers, la règle du choix de fourche intervient pour déterminer la chaîne à suivre. Cela crée également une occasion de maintenir le mécanisme de fuite d'inactivité qui récupère une chaîne où plus de 1/3 des validateurs sont hors ligne, bien qu'avec quelques nuances supplémentaires.
 
-## Questions non résolues {#outstanding-issues}
+## Problèmes en suspens {#outstanding-issues}
 
 Le problème avec l'évolutivité de l'agrégation en augmentant le nombre de validateurs par sous-réseau, c'est que cette dernière induit une charge beaucoup plus conséquente sur le réseau peer-to-peer. Le problème avec l'ajout de couches d'agrégations est qu'il est assez complexe à concevoir et ajoute de la latence (c'est-à-dire que cela pourrait prendre plus de temps avant que le proposant de bloc ne reçoive les informations de tous les agrégateurs de sous-réseaux). Aussi, la façon d'aborder le cas n'est pas encore très claire lorsqu'il y a bien plus de validateurs actifs sur le réseau, qu'il n'est possible d'en traiter dans chaque créneau, et ce, même avec l'agrégation des signatures BLS. Une solution envisageable : étant donné que tous les validateurs attestent dans chaque créneau et qu'il n'y a pas de comités sous le régime de Finalité à créneau unique (SSF), le plafond de 32 ETH du solde effectif pourrait être entièrement supprimé, signifiant ainsi que les opérateurs gérant de nombreux validateurs, pourraient consolider leurs enjeux et en exploiter une quantité moindre, réduisant de facto le volume de messages que les nœuds de validation doivent traiter pour tenir compte de l'ensemble des validateurs. Cela repose sur l’acceptation par les grands stakers de consolider leurs validateurs. Il est également possible d'imposer à tout moment un seuil fixe au nombre de validateurs ou au montant d'ETH mis en jeu. Cependant, cela requiert un certain mécanisme pour décider quels validateurs sont autorisés à participer et ceux déboutés de cette possibilité, ce qui est susceptible d'engendrer des effets secondaires indésirables.
 
 ## Progrès actuels {#current-progress}
 
-La Finalité à créneau unique (SSF) est en phase d'études. Celle-ci ne devrait pas être opérationnelle avant plusieurs années, probablement après que d'autres avancées substantielles aient été réalisées, telles que [l'Arbre de Verkle](/roadmap/verkle-trees/) et la [solution Danksharding](/roadmap/danksharding/).
+La Finalité à créneau unique (SSF) est en phase d'études. Sa livraison n'est pas prévue avant plusieurs années, probablement après d'autres mises à niveau substantielles telles que [Verkle trees](/roadmap/verkle-trees/) et [Danksharding](/roadmap/danksharding/).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Vitalik sur la Finalité à créneau unique (SSF) au EDCON 2022](https://www.youtube.com/watch?v=nPgUKNPWXNI)
-- [Notes de Vitalik : Chemins menant à la Finalité à créneau unique (SSF)](https://notes.ethereum.org/@vbuterin/single_slot_finality)
+- [Vitalik à propos de la SSF à l'EDCON 2022](https://www.youtube.com/watch?v=nPgUKNPWXNI)
+- [Notes de Vitalik : Voies vers la finalité à créneau unique](https://notes.ethereum.org/@vbuterin/single_slot_finality)
diff --git a/public/content/translations/fr/roadmap/statelessness/index.md b/public/content/translations/fr/roadmap/statelessness/index.md
index 4fe040ffee1..1d1f6e7d2bd 100644
--- a/public/content/translations/fr/roadmap/statelessness/index.md
+++ b/public/content/translations/fr/roadmap/statelessness/index.md
@@ -1,10 +1,10 @@
 ---
-title: Absence d'état, expiration d'état et expiration de l'historique
-description: Explication de l'expiration d'historique et d'Ethereum sans état
+title: "Absence d'état, expiration d'état et expiration de l'historique"
+description: "Explication de l'expiration d'historique et d'Ethereum sans état"
 lang: fr
 ---
 
-# Absence d'état, expiration d'état et expiration de l'historique {#statelessness}
+# Absence d'état, expiration de l'état et expiration de l'historique {#statelessness}
 
 La possibilité d'exécuter des nœuds Ethereum sur du matériel modeste est critique pour une véritable décentralisation. En effet, l'exécution d'un nœud donne aux utilisateurs la possibilité de vérifier les informations en effectuant des vérifications cryptographiques de manière indépendante plutôt que de faire confiance à un tiers pour leur fournir les données. Le fait d'exécuter un nœud permet aux utilisateurs de soumettre des transactions directement au réseau pair-à-pair Ethereum plutôt que de devoir faire confiance à un intermédiaire. La décentralisation n'est pas possible si ces avantages ne sont disponibles qu'aux utilisateurs possesseurs de matériel coûteux. Au contraire, les nœuds devraient pouvoir s'exécuter avec des exigences de calcul et de mémoire très modestes, afin qu'ils puissent fonctionner sur des téléphones portables, de petits ordinateurs, ou sans effet notable sur un ordinateur personnel.
 
@@ -16,10 +16,10 @@ Des disques durs moins coûteux peuvent être utilisés pour stocker les donnée
 
 Il y a plusieurs façons de réduire la quantité de données que chaque nœud doit stocker, chacune nécessitant que le protocole au cœur d'Ethereum soit mis à jour à des degrés différents :
 
-- **Expiration de l'historique** : permet aux noeuds de se débarrasser des données d'état plus anciennes que X blocs, mais ne change pas la manière dont les clients Ethereum gèrent les données d'état.
-- **Expiration d'état** : permet aux données d'état qui ne sont pas utilisées fréquemment de devenir inactives. Les données inactives peuvent être ignorées par les clients jusqu'à ce qu'elles soient ressuscitées.
-- **Absence d'état faible** : seuls les producteurs de blocs ont besoin d'accéder aux données d'état complètes, les autres noeuds peuvent vérifier les blocs sans base de données locale.
-- **Absence d'état forte** : aucun noeud n'a besoin d'accéder aux données d'état complètes.
+- **Expiration de l'historique** : permet aux nœuds de se débarrasser des données d'état plus anciennes que X blocs, mais ne change pas la manière dont les clients Ethereum gèrent les données d'état.
+- **Expiration de l'état** : permet aux données d'état qui ne sont pas utilisées fréquemment de devenir inactives. Les données inactives peuvent être ignorées par les clients jusqu'à ce qu'elles soient ressuscitées.
+- **Absence d'état faible** : seuls les producteurs de blocs ont besoin d'accéder aux données d'état complètes, les autres nœuds peuvent vérifier les blocs sans base de données d'état locale.
+- **Absence d'état forte** : aucun nœud n'a besoin d'accéder aux données d'état complètes.
 
 ## Expiration des données {#data-expiry}
 
@@ -39,24 +39,24 @@ Cette mise à niveau ne modifie pas fondamentalement comment les noeuds Ethereum
 
 L'expiration de l'état fait référence à la suppression de l'état sur les nœuds individuels si cet état n'a pas été accédé récemment. Ceci pourrait être implémenté de plusieurs manières, notamment :
 
-- **Expiration par le loyer** : faire payer un « loyer » aux comptes et les laisser expirer quand leur loyer atteint zéro
-- **Expiration par le temps** : rendre les comptes inactifs s'il n'y a pas de lecture/écriture sur ce compte pendant un certain temps
+- **Expiration par le loyer** : faire payer un « loyer » aux comptes et les laisser expirer quand leur loyer atteint zéro.
+- **Expiration par le temps** : rendre les comptes inactifs s'il n'y a pas de lecture/écriture sur ce compte pendant un certain temps.
 
-L'expiration par le loyer pourrait être un loyer direct facturé aux comptes pour les garder dans la base de données des états actifs. L'expiration par le temps pourrait être un compte à rebours depuis la dernière interaction sur le compte, ou elle pourrait être une expiration périodique de tous les comptes. Il pourrait également y avoir des mécanismes qui combinent des éléments des deux modèles basés sur le temps et sur le loyer, par exemple que les comptes individuels persistent dans l'état actif s'ils paient des frais minimes avant l'expiration basée sur le temps. Avec l'expiration d'état, il est important de noter que les états inactifs ne sont **pas effacés**, ils sont simplement stockés séparément des états actifs. Les états inactifs peuvent être ressuscités vers les états actifs.
+L'expiration par le loyer pourrait être un loyer direct facturé aux comptes pour les garder dans la base de données des états actifs. L'expiration par le temps pourrait être un compte à rebours depuis la dernière interaction sur le compte, ou elle pourrait être une expiration périodique de tous les comptes. Il pourrait également y avoir des mécanismes qui combinent des éléments des deux modèles basés sur le temps et sur le loyer, par exemple que les comptes individuels persistent dans l'état actif s'ils paient des frais minimes avant l'expiration basée sur le temps. Avec l'expiration de l'état, il est important de noter que l'état inactif n'est **pas supprimé**, il est simplement stocké séparément de l'état actif. Les états inactifs peuvent être ressuscités vers les états actifs.
 
-La façon dont cela fonctionnerait serait probablement d'avoir un arbre d'état pour des périodes de temps spécifiques (peut-être ~1 an). À chaque fois qu'une nouvelle période commence, un arbre d'état entièrement neuf voit le jour. Seul l'arbre d'état actuel peut être modifié, tous les autres sont immuables. Les nœuds Ethereum ne seraient obligés de contenir que l'arbre d'état actuel et le suivant le plus récent. Cela nécessiterait un moyen d'associer une adresse avec la période de temps dans laquelle elle existe. Il y a [plusieurs façons possibles](https://ethereum-magicians.org/t/types-of-resurrection-metadata-in-state-expiry/6607) de le faire, mais la favorite nécessite que [les adresses soient allongées](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485) pour accommoder les informations supplémentaires, avec l'avantage additionnel que les adresses plus longues sont plus sûres. La feuille de route qui fait cela est appelée [extension de l'espace d'adressage](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485).
+La façon dont cela fonctionnerait serait probablement d'avoir un arbre d'état pour des périodes de temps spécifiques (peut-être ~1 an). À chaque fois qu'une nouvelle période commence, un arbre d'état entièrement neuf voit le jour. Seul l'arbre d'état actuel peut être modifié, tous les autres sont immuables. Les nœuds Ethereum ne seraient obligés de contenir que l'arbre d'état actuel et le suivant le plus récent. Cela nécessiterait un moyen d'associer une adresse avec la période de temps dans laquelle elle existe. Il existe [plusieurs manières possibles](https://ethereum-magicians.org/t/types-of-resurrection-metadata-in-state-expiry/6607) de le faire, mais la principale option requiert de [rallonger les adresses](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485) pour accueillir les informations supplémentaires, avec pour avantage supplémentaire que des adresses plus longues sont beaucoup plus sécurisées. L'élément de la feuille de route qui permet cela est appelé [extension de l'espace d'adressage](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485).
 
 De même que pour l'expiration de l'historique, sous l'expiration de l'état, la responsabilité du stockage des anciennes données d'état est retirée des utilisateurs individuels et transférée à d'autres entités telles que des fournisseurs centralisés, des membres altruistes de la communauté ou des solutions décentralisées plus futuristes telles que le Réseau du Portail.
 
 L'expiration de l'état est encore en phase de recherche et n'est pas encore prête à être expédiée. L'expiration de l'état pourrait bien se produire après les clients sans état et l'expiration de l'historique, car ces mises à niveau rendent les grandes tailles d'état facilement gérables pour la majorité des validateurs.
 
-## Le principe de non-vérification de l'état de la blockchain {#statelessness}
+## Absence d'état {#statelessness}
 
 L'absence d'état est un peu un abus de langage car cela ne signifie pas que le concept d'« état » est éliminé, mais cela implique des changements dans la façon dont les nœuds Ethereum traitent les données d'état. L'absence d'état elle-même se présente sous deux formes : l'absence d'état faible et l'absence d'état forte. L'absence d'état faible permet à la plupart des nœuds de devenir sans état en plaçant la responsabilité du stockage de l'état sur quelques-uns. L'absence d'état forte retire entièrement le besoin pour tous les nœuds de stocker les données d'état complètes. Les absences d'état faibles et fortes offrent toutes les deux les avantages suivants aux validateurs normaux :
 
 - synchronisation presque instantanée
 - possibilité de valider les blocs dans le désordre
-- les nœuds sont capables de s'exécuter avec des exigences sur le matériel très faibles (par exemple sur des téléphones portables)
+- nœuds capables de fonctionner avec des exigences matérielles très faibles (par exemple, sur des téléphones)
 - les nœuds peuvent s'exécuter sur des disques durs bon marché parce qu'aucune lecture/écriture sur le disque n'est nécessaire
 - compatibles avec les mises à niveau futures de la cryptographie d'Ethereum
 
@@ -66,9 +66,9 @@ L'absence d'était faible implique des changements dans la façon dont les nœud
 
 **Avec l'absence d'état faible, proposer des blocs requiert l'accès à l'intégralité des données d'état, mais vérifier les blocs ne requiert aucune donnée d'état**
 
-Pour que cela soit possible, les [arbres de Verkle](/roadmap/verkle-trees/) doivent déjà avoir été implémentés dans les clients Ethereum. Les arbres de Verkle sont une structure de données de remplacement pour stocker les données d'état d'Ethereum qui permettent à de petits « témoins des données » de taille fixe d'être transmis entre pairs et d'être utilisés pour vérifier les blocs au lieu de vérifier les blocs par rapport aux bases de données locales. La [séparation proposant-constructeur](/roadmap/pbs/) est également requise car elle permet aux constructeurs de blocs d'être des nœuds spécialisés avec un matériel plus puissant, et ce sont eux qui ont besoin d'un accès aux données d'état complètes.
+Pour que cela soit possible, les [arbres de Verkle](/roadmap/verkle-trees/) doivent déjà avoir été implémentés dans les clients Ethereum. Les arbres de Verkle sont une structure de données de remplacement pour stocker les données d'état d'Ethereum qui permettent à de petits « témoins des données » de taille fixe d'être transmis entre pairs et d'être utilisés pour vérifier les blocs au lieu de vérifier les blocs par rapport aux bases de données locales. La [séparation proposant-constructeur](/roadmap/pbs/) est également requise, car elle permet aux constructeurs de blocs d'être des nœuds spécialisés avec un matériel plus puissant, et ce sont eux qui ont besoin d'un accès aux données d'état complètes.
 
-<ExpandableCard title="Pourquoi est-il acceptable de s'appuyer sur un nombre réduit de proposeurs de blocs ?" eventCategory="/roadmap/statelessness" eventName="clicked why is it OK to rely on fewer block proposers?">
+<ExpandableCard title="Pourquoi n'est-il pas problématique de compter sur moins de proposants de blocs ?" eventCategory="/roadmap/statelessness" eventName="clicked why is it OK to rely on fewer block proposers?">
 
 L'absence d'état requiert que les constructeurs de blocs conservent une copie des données d'état complètes afin qu'ils puissent générer des témoins pouvant être utilisés pour vérifier le bloc. Les autres nœuds n'ont pas besoin d'accéder aux données d'état, toute l'information requise pour vérifier le bloc est disponible dans le témoin. Cela crée une situation où proposer un bloc est coûteux, mais vérifier le bloc est bon marché, ce qui implique que moins d'opérateurs vont faire fonctionner un bloc proposant des noeuds. Cependant, la décentralisation des proposants de blocs n'est pas critique tant qu'autant de participants que possible peuvent vérifier que les blocs qu'ils proposent sont valides.
 
@@ -87,17 +87,19 @@ L'absence d'état forte a été étudiée par les chercheurs mais on ne s'attend
 
 ## Progrès actuels {#current-progress}
 
-Absence d'état faible, l'expiration de l'historique et l'expiration de l'état sont tous en phase de recherche et devraient être prêts dans plusieurs années. Il n'y a aucune garantie que toutes ces propositions seront mises en œuvre, par exemple, si l'expiration de l'état est mise en œuvre en premier, il se peut qu'il ne soit pas nécessaire de mettre en œuvre également l'expiration de l'historique. Il existe également d'autres éléments de la feuille de route, tels que les [Arbres de Verkle](/roadmap/verkle-trees) et la [Séparation proposeur-constructeur](/roadmap/pbs) qui doivent être achevés en premier.
+Absence d'état faible, l'expiration de l'historique et l'expiration de l'état sont tous en phase de recherche et devraient être prêts dans plusieurs années. Il n'y a aucune garantie que toutes ces propositions seront mises en œuvre, par exemple, si l'expiration de l'état est mise en œuvre en premier, il se peut qu'il ne soit pas nécessaire de mettre en œuvre également l'expiration de l'historique. Il existe également d'autres éléments de la feuille de route, tels que les [arbres de Verkle](/roadmap/verkle-trees) et la [séparation proposant-constructeur](/roadmap/pbs) qui doivent d'abord être achevés.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
+- [Qu'est-ce que l'Ethereum sans état ?](https://stateless.fyi/)
 - [AMA de Vitalik sur l'absence d'état](https://www.reddit.com/r/ethereum/comments/o9s15i/impromptu_technical_ama_on_statelessness_and/)
-- [Une théorie de la gestion de la taille de l'état](https://hackmd.io/@vbuterin/state_size_management)
-- [Limiter la taille de l'état en minimisant les conflits de résurrection](https://ethresear.ch/t/resurrection-conflict-minimized-state-bounding-take-2/8739)
-- [Vers l'absence d'état et l'expiration de l'état](https://hackmd.io/@vbuterin/state_expiry_paths)
+- [Une théorie sur la gestion de la taille de l'état](https://hackmd.io/@vbuterin/state_size_management)
+- [Délimitation de l'état à conflit de résurrection minimisé](https://ethresear.ch/t/resurrection-conflict-minimized-state-bounding-take-2/8739)
+- [Pistes vers l'absence d'état et l'expiration de l'état](https://hackmd.io/@vbuterin/state_expiry_paths)
 - [Spécification de l'EIP-4444](https://eips.ethereum.org/EIPS/eip-4444)
 - [Alex Stokes à propos de l'EIP-4444](https://youtu.be/SfDC_qUZaos)
-- [Pourquoi il est si important de devenir sans état](https://dankradfeist.de/ethereum/2021/02/14/why-stateless.html)
-- [Les notes conceptuelles originales du client sans état](https://ethresear.ch/t/the-stateless-client-concept/172)
-- [Plus d'informations sur l'expiration de l'état](https://hackmd.io/@vbuterin/state_size_management#A-more-moderate-solution-state-expiry)
-- [Encore plus sur l'expiration de l'état](https://hackmd.io/@vbuterin/state_expiry_paths#Option-2-per-epoch-state-expiry)
+- [Pourquoi il est si important de passer à l'absence d'état](https://dankradfeist.de/ethereum/2021/02/14/why-stateless.html)
+- [Notes sur le concept original de client sans état](https://ethresear.ch/t/the-stateless-client-concept/172)
+- [En savoir plus sur l'expiration de l'état](https://hackmd.io/@vbuterin/state_size_management#A-more-moderate-solution-state-expiry)
+- [Plus d'informations sur l'expiration de l'état](https://hackmd.io/@vbuterin/state_expiry_paths#Option-2-per-epoch-state-expiry)
+- [Page d'information sur l'Ethereum sans état](https://stateless.fyi)
diff --git a/public/content/translations/fr/roadmap/user-experience/index.md b/public/content/translations/fr/roadmap/user-experience/index.md
index f030b60f123..3befd61967b 100644
--- a/public/content/translations/fr/roadmap/user-experience/index.md
+++ b/public/content/translations/fr/roadmap/user-experience/index.md
@@ -1,27 +1,27 @@
 ---
-title: Amélioration de l'expérience utilisateur
-description: Utiliser Ethereum reste encore trop compliqué pour la plupart des gens. Pour encourager l'adoption massive, Ethereum doit réduire considérablement les obstacles initiaux - les utilisateurs doivent bénéficier d'un accès décentralisé, sans autorisation et résistant à la censure à Ethereum, mais cela doit rester aussi fluide que l'utilisation d'une application Web2 traditionnelle.
+title: "Amélioration de l'expérience utilisateur"
+description: "Utiliser Ethereum reste encore trop compliqué pour la plupart des gens. Pour encourager l'adoption massive, Ethereum doit réduire considérablement les obstacles initiaux - les utilisateurs doivent bénéficier d'un accès décentralisé, sans autorisation et résistant à la censure à Ethereum, mais cela doit rester aussi fluide que l'utilisation d'une application Web2 traditionnelle."
 lang: fr
 image: /images/roadmap/roadmap-ux.png
 alt: "Feuille de route d'Ethereum"
 template: roadmap
 ---
 
-**L'utilisation d'Ethereum doit être simplifiée**, de la gestion des [clés](/glossary/#key) et des [portefeuilles](/glossary/#wallet) à la réalisation des transactions. Pour faciliter l'adoption de masse, Ethereum doit considérablement augmenter la facilité d'utilisation, permettant aux utilisateurs de profiter d'un accès sans autorisation et résistant à la censure à Ethereum avec l'expérience sans friction de l'utilisation des applications [Web2](/glossary/#web2).
+**L'utilisation d'Ethereum doit être simplifiée** ; de la gestion des [clés](/glossary/#key) et des [portefeuilles](/glossary/#wallet) à l'initiation des transactions. Pour faciliter l'adoption de masse, Ethereum doit considérablement augmenter la facilité d'utilisation, permettant aux utilisateurs de profiter d'un accès sans autorisation et résistant à la censure à Ethereum avec l'expérience sans friction de l'utilisation des applications [Web2](/glossary/#web2).
 
-## En finir avec les phrases de récupération {#no-more-seed-phrases}
+## Au-delà des phrases de récupération {#no-more-seed-phrases}
 
 Les comptes sur Ethereum sont protégés par une paire de clés utilisées pour identifier ces comptes (clé publique) et signer les messages (clé privée). Une clé privée est comme un mot de passe principal ; elle permet un accès total à un compte Ethereum. Il s'agit d'une manière différente de fonctionner pour les personnes plus familières avec les banques et les applications Web2 qui gèrent les comptes au nom de l'utilisateur. Pour qu'Ethereum atteigne une l'adoption de masse sans dépendre de tiers centralisés, il doit exister un moyen simple et sans complication pour qu'un utilisateur prenne en charge ses actifs et garde le contrôle de ses données sans avoir à comprendre la cryptographie à clé publique/privée et la gestion de ces clés.
 
-La solution à cela consiste à utiliser des portefeuilles [de contrats intelligents](/glossary/#smart-contract) pour interagir avec Ethereum. Les portefeuilles de contrats intelligents permettent de protéger les comptes si les clés sont perdues ou volées, offrent une meilleure détection et défense contre les fraudes, et permettent aux portefeuilles de fournir de nouvelles fonctionnalités. Bien que les portefeuilles de contrats intelligents existent déjà aujourd'hui, ils sont difficiles à implémenter car le protocole Ethereum doit mieux les prendre en charge. Ce support supplémentaire est ce que l'on appelle l'abstraction de compte.
+La solution consiste à utiliser des portefeuilles de [contrats intelligents](/glossary/#smart-contract) pour interagir avec Ethereum. Les portefeuilles de contrats intelligents permettent de protéger les comptes si les clés sont perdues ou volées, offrent une meilleure détection et défense contre les fraudes, et permettent aux portefeuilles de fournir de nouvelles fonctionnalités. Bien que les portefeuilles de contrats intelligents existent déjà aujourd'hui, ils sont difficiles à implémenter car le protocole Ethereum doit mieux les prendre en charge. Ce support supplémentaire est ce que l'on appelle l'abstraction de compte.
 
 <ButtonLink variant="outline-color" href="/roadmap/account-abstraction/">En savoir plus sur l'abstraction de compte</ButtonLink>
 
 ## Des nœuds pour tous
 
-Les utilisateurs qui possèdent des [nœuds](/glossary/#node) n'ont pas besoin de faire confiance à des tiers pour leur fournir des informations, et ils peuvent interagir rapidement, en toute confidentialité et sans autorisation avec la [blockchain](/glossary/#blockchain) Ethereum. Cependant, exécuter un nœud nécessite actuellement des connaissances techniques et un espace disque important, ce qui signifie que de nombreuses personnes doivent faire confiance à des intermédiaires.
+Les utilisateurs qui exécutent des [nœuds](/glossary/#node) n'ont pas à faire confiance à des tiers pour leur fournir des données, et ils peuvent interagir rapidement, en privé et sans autorisation avec la [blockchain](/glossary/#blockchain) Ethereum. Cependant, exécuter un nœud nécessite actuellement des connaissances techniques et un espace disque important, ce qui signifie que de nombreuses personnes doivent faire confiance à des intermédiaires.
 
-Plusieurs mises à jour faciliteront l'exécution des nœuds et réduiront considérablement les ressources nécessaires. La manière dont les données sont stockées sera modifiée pour utiliser une structure plus efficace en termes d'espace, appelée **arbre Verkle**. De plus, grâce au [principe de non-vérification de l'état](/roadmap/statelessness) ou à [l'expiration des données](/roadmap/statelessness/#data-expiry), les nœuds Ethereum n'auront pas besoin de stocker une copie de l'intégralité des données d'état de la blockchain, ce qui réduira considérablement les besoin d'espace sur le disque dur. [Les nœuds légers](/developers/docs/nodes-and-clients/light-clients/) offriront de nombreux avantages de l'exécution d'un nœud complet, mais pourront fonctionner facilement sur les téléphones mobiles ou à l'intérieur de simples applications de navigateur.
+Plusieurs mises à jour faciliteront l'exécution des nœuds et réduiront considérablement les ressources nécessaires. La manière dont les données sont stockées sera modifiée pour utiliser une structure plus efficace en termes d'espace, connue sous le nom d'**arbre Verkle**. De plus, avec le [fonctionnement sans état](/roadmap/statelessness) ou l'[expiration des données](/roadmap/statelessness/#data-expiry), les nœuds Ethereum n'auront pas besoin de stocker une copie de l'intégralité des données d'état d'Ethereum, ce qui réduira considérablement les besoins en espace disque. Les [nœuds légers](/developers/docs/nodes-and-clients/light-clients/) offriront de nombreux avantages de l'exécution d'un nœud complet, mais pourront fonctionner facilement sur des téléphones mobiles ou dans de simples applications de navigateur.
 
 <ButtonLink variant="outline-color" href="/roadmap/verkle-trees/">En savoir plus sur les arbres Verkle</ButtonLink>
 
@@ -29,8 +29,8 @@ Avec ces mises à jour, les freins à l'exécution d'un nœud sont réduites à
 
 ## Progrès actuels {#current-progress}
 
-Des portefeuilles de contrats intelligents sont déjà disponibles, mais d'autres améliorations sont nécessaires pour les rendre aussi décentralisés et sans autorisation que possible. L'EIP-4337 est une proposition finalisée qui ne nécessite aucune modification du protocole d'Ethereum. Le principal contrat intelligent requis pour l'EIP-4337 a été **déployé en mars 2023**.
+Des portefeuilles de contrats intelligents sont déjà disponibles, mais d'autres améliorations sont nécessaires pour les rendre aussi décentralisés et sans autorisation que possible. L'EIP-4337 est une proposition finalisée qui ne nécessite aucune modification du protocole d'Ethereum. Le contrat intelligent principal requis pour l'EIP-4337 a été **déployé en mars 2023**.
 
-**Le principe de non-vérification de l'état est toujours en phase de recherche** et il faudra probablement encore plusieurs années avant qu'il ne soit mis en œuvre. Il existe plusieurs étapes clés sur la voie du principe de non-vérification de l'état, notamment l'expiration des données, qui pourraient être mises en œuvre plus rapidement. D'autres éléments de la feuille de route, tels que les [arbres Verkle](/roadmap/verkle-trees/) et [la séparation des constructeurs de bloc et les validateurs](/roadmap/pbs/), doivent être achevés en premier.
+**L'absence totale d'état est encore en phase de recherche** et sa mise en œuvre ne se fera probablement pas avant plusieurs années. Il existe plusieurs étapes clés sur la voie du principe de non-vérification de l'état, notamment l'expiration des données, qui pourraient être mises en œuvre plus rapidement. D'autres éléments de la feuille de route, tels que les [arbres Verkle](/roadmap/verkle-trees/) et la [séparation Proposeur-Constructeur](/roadmap/pbs/), doivent d'abord être finalisés.
 
 Les réseaux de test des arbres Verkle sont déjà opérationnels, et la prochaine étape consiste à exécuter des clients compatibles avec les arbres Verkle sur des réseaux de test privés, puis publics. Vous pouvez contribuer à accélérer les progrès en déployant des contrats sur les réseaux de test ou en exécutant des clients de réseau de test.
diff --git a/public/content/translations/fr/roadmap/verkle-trees/index.md b/public/content/translations/fr/roadmap/verkle-trees/index.md
index e96444f4732..3a31225017e 100644
--- a/public/content/translations/fr/roadmap/verkle-trees/index.md
+++ b/public/content/translations/fr/roadmap/verkle-trees/index.md
@@ -1,31 +1,30 @@
 ---
-title: Les arbres de Verkle
-description: Une description précise des arbres de Verkle et de la manière dont ceux-ci seront utilisés pour mettre à niveau Ethereum.
+title: Arbres de Verkle
+description: "Une description précise des arbres de Verkle et de la manière dont ceux-ci seront utilisés pour mettre à niveau Ethereum."
 lang: fr
 summaryPoints:
   - Découvrir ce que sont les arbres de Verkle
   - Prenez connaissance de l'amélioration utile que sont les arbres de Verkle pour Ethereum
 ---
 
-# Les arbres de Verkle {#verkle-trees}
+# Arbres de Verkle {#verkle-trees}
 
 Les arbres de Verkle (porte-manteau de « Vector commitment » et « Merkle Trees ») sont une structure de données qui peut être utilisée pour mettre à niveau les nœuds d'Ethereum, afin qu'ils puissent cesser de stocker de grandes quantités de données d'état, sans perdre la capacité à valider les blocs.
 
-## Le principe de non-vérification de l'état de la blockchain {#statelessness}
+## Absence d'état {#statelessness}
 
 Les arbres de Verkle constituent une étape cruciale sur la voie des clients Ethereum sans état. Les clients sans état sont ceux qui n'ont nul besoin de stocker l'ensemble de la base de données d'état, afin de valider les blocs entrants. Au lieu d'utiliser leur propre copie locale de l'état d'Ethereum pour vérifier les blocs, les clients sans état ont recours à un « témoin » pour les données d'état qui arrivent avec le bloc. Un témoin est un ensemble d'éléments individuels des données d'état, nécessaires à l'exécution d'un groupe particulier de transactions, accompagné d'une preuve cryptographique que le témoin fait réellement partie de la totalité des données. Le témoin est utilisé _au lieu_ de la base de données d'état. Pour que cela fonctionne, les témoins doivent être très petits, de sorte qu'ils puissent être diffusés en toute sécurité dans le temps imparti sur le réseau, et que les validateurs puissent les traiter dans un créneau de 12 secondes. La structure actuelle des données d'état n'est pas adaptée car les témoins sont bien trop volumineux. Les arbres de Verkle résolvent ce problème en permettant l'utilisation de petits témoins, éliminant ainsi l'un des principaux obstacles à l'utilisation de clients sans état.
 
-<ExpandableCard title="Pourquoi voulons-nous des clients sans état ?" eventCategory="/roadmap/verkle-trees" eventName="clicked why do we want stateless clients?">
-
-Actuellement, les clients Ethereum utilisent une structure de données connue sous le nom de "*Patricia Merkle Trie**" ou "Arbre de Merkle Patricia" pour stocker leurs données d'état.
-*Un « Patricia Merkle Trie » ou Arbre de Merkle Patricia produit une structure des données cryptographiquement authentifiée pouvant être utilisée pour sauvegarder toutes les paires (clé, valeur).
-**Le terme « trie » est une abréviation de « retrieval » (récupération en anglais). Il est utilisé pour désigner spécifiquement une structure de données arborescente dans laquelle les éléments sont indexés par une séquence de caractères. Les informations concernant les comptes individuels sont conservées sous forme de feuilles sur le « trie », et les paires de feuilles sont hachées en séquence répétée jusqu'à ce qu'il ne reste qu'un seul hachage. Cet ultime hachage est connu sous le nom de « racine ». Quant à la vérification des blocs, les clients d'Ethereum exécutent l'ensemble des transactions présentes dans un bloc et mettent à jour leur arbre d'état local. Le bloc est considéré comme valide si la racine de l'arbre local est identique à celle délivrée par le proposant de bloc, car toute différence dans le calcul orchestrée par le proposant de bloc et le nœud de validation, entraînerait une divergence totale dans le hachage de la racine. Le problème de ce principe, c'est que la vérification de la blockchain requiert que chaque client stocke l'ensemble de l'arbre d'état pour le bloc principal et divers blocs historiques (par défaut, Geth conserve les données d'état pour 128 blocs situés à l'arrière du bloc principal). Cela nécessite que les clients aient accès à une grande quantité d'espace disque, ce qui constitue un obstacle à l'exécution de nœuds complets sur du matériel bon marché et à faible consommation. Une solution consiste à mettre à jour l'arbre d'état (trie) vers une structure plus efficace (l'arbre de Verkle), qui peut être synthétisée via l'utilisation d'un petit « témoin » aux données ; celui-ci pouvant être partagé en lieu et place de l'ensemble des données d'état. Le reformatage des données d'état au sein d'un arbre de Verkle est un tremplin pour passer aux clients sans état.
+<ExpandableCard title="Pourquoi vouloir des clients sans état ?" eventCategory="/roadmap/verkle-trees" eventName="clicked why do we want stateless clients?">
 
+Actuellement, les clients Ethereum utilisent une structure de données connue sous le nom de "_Patricia Merkle Trie_\*" ou "Arbre de Merkle Patricia" pour stocker leurs données d'état.
+\*Un « Patricia Merkle Trie » ou Arbre de Merkle Patricia produit une structure des données cryptographiquement authentifiée pouvant être utilisée pour sauvegarder toutes les paires (clé, valeur).
+\*\*Le terme « trie » est une abréviation de « retrieval » (récupération en anglais). Il est utilisé pour désigner spécifiquement une structure de données arborescente dans laquelle les éléments sont indexés par une séquence de caractères. Les informations concernant les comptes individuels sont conservées sous forme de feuilles sur le « trie », et les paires de feuilles sont hachées en séquence répétée jusqu'à ce qu'il ne reste qu'un seul hachage. Cet ultime hachage est connu sous le nom de « racine ». Quant à la vérification des blocs, les clients d'Ethereum exécutent l'ensemble des transactions présentes dans un bloc et mettent à jour leur arbre d'état local. Le bloc est considéré comme valide si la racine de l'arbre local est identique à celle délivrée par le proposant de bloc, car toute différence dans le calcul orchestrée par le proposant de bloc et le nœud de validation, entraînerait une divergence totale dans le hachage de la racine. Le problème de ce principe, c'est que la vérification de la blockchain requiert que chaque client stocke l'ensemble de l'arbre d'état pour le bloc principal et divers blocs historiques (par défaut, Geth conserve les données d'état pour 128 blocs situés à l'arrière du bloc principal). Cela nécessite que les clients aient accès à une grande quantité d'espace disque, ce qui constitue un obstacle à l'exécution de nœuds complets sur du matériel bon marché et à faible consommation. Une solution consiste à mettre à jour l'arbre d'état (trie) vers une structure plus efficace (l'arbre de Verkle), qui peut être synthétisée via l'utilisation d'un petit « témoin » aux données ; celui-ci pouvant être partagé en lieu et place de l'ensemble des données d'état. Le reformatage des données d'état au sein d'un arbre de Verkle est un tremplin pour passer aux clients sans état.
 </ExpandableCard>
 
 ## Qu'est-ce qu'un témoin et pourquoi en avons-nous besoin ? {#what-is-a-witness}
 
-Vérifier un bloc signifie ré-exécuter les transactions contenues dans le bloc, appliquer les modifications à l'arbre d'état (trie) d'Ethereum et calculer le nouveau hachage racine. Un bloc vérifié est un bloc dont le hachage racine d'état calculé est identique à celui fourni avec le bloc (signifiant que le proposant du bloc a vraiment effectué le calcul qu'il prétend avoir fait). Parmi les clients Ethereum actuels, mettre à jour l'état nécessite l'accès à l'intégralité de l'arbre d'état (Trie), qui est une vaste structure de données devant être stockée localement. Un témoin ne contient que les fragments des données d'état, nécessaires à l'exécution des transactions dans le bloc. Un validateur ne peut alors utiliser ces fragments que pour vérifier que le proposant du bloc a exécuté les transactions de bloc et mis à jour l'état de manière adéquate. Cependant, ceci veut dire que le témoin doit être transféré assez rapidement entre les pairs du réseau Ethereum, pour être réceptionné et traité en toute sécurité par chaque nœud, lors d'un créneau de 12 secondes. Si le témoin est trop volumineux, certains nœuds prendront bien trop de temps à télécharger celui-ci et être raccord avec la chaîne. Il s'agit d'une force centralisatrice, ce qui signifie qu'uniquement les nœuds dotés de connexions Internet haut débit peuvent participer à la validation des blocs. Avec les arbres de Verkle, nulle nécessité d'avoir l'état stocké sur votre disque dur ; _tout_ ce dont vous avez besoin pour vérifier un bloc est inclus dans le bloc lui-même. Malheureusement, les témoins qui peuvent être produits à partir des arbres de Merkle sont trop volumineux pour prendre en charge les clients sans état.
+Vérifier un bloc signifie ré-exécuter les transactions contenues dans le bloc, appliquer les modifications à l'arbre d'état (trie) d'Ethereum et calculer le nouveau hachage racine. Un bloc vérifié est un bloc dont le hachage racine d'état calculé est identique à celui fourni avec le bloc (signifiant que le proposant du bloc a vraiment effectué le calcul qu'il prétend avoir fait). Parmi les clients Ethereum actuels, mettre à jour l'état nécessite l'accès à l'intégralité de l'arbre d'état (Trie), qui est une vaste structure de données devant être stockée localement. Un témoin ne contient que les fragments des données d'état, nécessaires à l'exécution des transactions dans le bloc. Un validateur ne peut alors utiliser ces fragments que pour vérifier que le proposant du bloc a exécuté les transactions de bloc et mis à jour l'état de manière adéquate. Cependant, ceci veut dire que le témoin doit être transféré assez rapidement entre les pairs du réseau Ethereum, pour être réceptionné et traité en toute sécurité par chaque nœud, lors d'un créneau de 12 secondes. Si le témoin est trop volumineux, certains nœuds prendront bien trop de temps à télécharger celui-ci et être raccord avec la chaîne. Il s'agit d'une force centralisatrice, ce qui signifie qu'uniquement les nœuds dotés de connexions Internet haut débit peuvent participer à la validation des blocs. Avec les arbres de Verkle, il n'est pas nécessaire d'avoir l'état stocké sur votre disque dur ; _tout_ ce dont vous avez besoin pour vérifier un bloc est contenu dans le bloc lui-même. Malheureusement, les témoins qui peuvent être produits à partir des arbres de Merkle sont trop volumineux pour prendre en charge les clients sans état.
 
 ## Pourquoi les arbres de Verkle permettent-ils des témoins plus petits ? {#why-do-verkle-trees-enable-smaller-witnesses}
 
@@ -33,19 +32,19 @@ La structure d'un arbre de Merkle rend la taille des témoins très grande - tro
 
 Dans le cadre du schéma d'engagement polynomial, les témoins ont des tailles gérables qui peuvent être facilement transférées sur le réseau pair à pair (P2P). Cela permet aux clients de vérifier les changements d'état à l'intérieur de chaque bloc, avec une quantité minimale de données.
 
-<ExpandableCard title="Dans quelle mesure exacte les arbres de Verkle peuvent-ils réduire la taille des témoins ?" eventCategory="/roadmap/verkle-trees" eventName="clicked exactly how much can Verkle trees reduce witness size?">
+<ExpandableCard title="De combien exactement les arbres de Verkle peuvent-ils réduire la taille des témoins ?" eventCategory="/roadmap/verkle-trees" eventName="clicked exactly how much can Verkle trees reduce witness size?">
 
 La taille du témoin varie en fonction du nombre de feuilles qu'il comprend. Supposant que le témoin couvre 1000 feuilles, un témoin pour un arbre de Merkle (trie) serait d'environ 3,5 MB (en supposant 7 niveaux dudit arbre de Merkle) Un témoin pour le même genre de données au sein d'un arbre de Verkle (en supposant 4 niveaux dans l'arborescence) ferait environ 150 Ko - **environ 23 fois plus petit**. Cette diminution dans la taille des témoins permettra aux témoins clients sans état d'être d'une petite taille suffisamment acceptable. Les témoins polynomiaux font entre 0,128 et 1 ko, en fonction de l'engagement polynomial spécifique utilisé.
-
 </ExpandableCard>
 
 ## Quelle est la structure d'un arbre de Verkle ? {#what-is-the-structure-of-a-verkle-tree}
 
-Les arbres de Verkle sont des paires `(clé, valeur)` où les clés sont des éléments de 32 octets, composés d'une _tige_ de 31 octets et d'un seul octet _suffix_. Ces clés sont organisées en nœuds _d'extension_ et en nœuds _internes_. Les nœuds d'extension représentent une seule tige pour 256 *enfants aux suffixes différents. *un « enfant » fait référence à un nœud ou une feuille située sous un nœud parent donné.  Les nœuds internes ont également 256 enfants, mais ils peuvent être d'autres nœuds d'extension. La principale différence entre la structure de l'arbre de Verkle et celle de l'arbre de Merkle réside dans le fait que Verkle est beaucoup plus plat, signifiant qu'il y a moins de nœuds intermédiaires reliant une feuille à la racine, et donc, moins de données requises pour générer une preuve.
+Les arbres de Verkle sont des paires `(clé,valeur)` où les clés sont des éléments de 32 octets composés d'une _tige_ de 31 octets et d'un _suffixe_ d'un seul octet. Ces clés sont organisées en _nœuds d'extension_ et en _nœuds internes_. Les nœuds d'extension représentent une seule tige pour 256 \*enfants aux suffixes différents.
+\*un « enfant » fait référence à un nœud ou une feuille située sous un nœud parent donné.  Les nœuds internes ont également 256 enfants, mais ils peuvent être d'autres nœuds d'extension. La principale différence entre la structure de l'arbre de Verkle et celle de l'arbre de Merkle réside dans le fait que Verkle est beaucoup plus plat, signifiant qu'il y a moins de nœuds intermédiaires reliant une feuille à la racine, et donc, moins de données requises pour générer une preuve.
 
 ![](./verkle.png)
 
-[En savoir plus sur la structure des arbres de Merkle](https://blog.ethereum.org/2021/12/02/verkle-tree-structure)
+[En savoir plus sur la structure des arbres de Verkle](https://blog.ethereum.org/2021/12/02/verkle-tree-structure)
 
 ## Progrès actuels {#current-progress}
 
@@ -53,14 +52,16 @@ Les réseaux de test des arbres Verkle sont déjà opérationnels, mais il reste
 
 [Regardez Guillaume Ballet expliquer le réseau de test Condrieu Verkle](https://www.youtube.com/watch?v=cPLHFBeC0Vg) (notez que le réseau de test Condrieu était une preuve de travail et a maintenant été remplacé par le réseau de test Verkle Gen Devnet 6).
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Verkle Trees for Statelessness](https://verkle.info/)
-- [Dankrad Feist décrypte les arbres de Verkle sur PEEPanEIP](https://www.youtube.com/watch?v=RGJOQHzg3UQ)
-- [Guillaume Ballet présente les arbres de Verkle à l'ETHGlobal](https://www.youtube.com/watch?v=f7bEtX3Z57o)
-- [« Comment les arbres de Verkle rendent Ethereum léger et agressif » par Guillaume Ballet à Devcon 6](https://www.youtube.com/watch?v=Q7rStTKwuYs)
-- [Piper Merriam sur les clients sans état depuis l'ETHDenver 2020](https://www.youtube.com/watch?v=0yiZJNciIJ4)
-- [Dankrad Fiest nous parle des arbres de Verkle et du « Statelessness » dans le podcast Zero Knowledge](https://zeroknowledge.fm/podcast/202/)
+- [Arbres de Verkle pour le « Statelessness »](https://verkle.info/)
+- [Dankrad Feist explique les arbres de Verkle sur PEEPanEIP](https://www.youtube.com/watch?v=RGJOQHzg3UQ)
+- [Les arbres de Verkle à la portée de tous](https://web.archive.org/web/20250124132255/https://research.2077.xyz/verkle-trees)
+- [Anatomie d'une preuve Verkle](https://ihagopian.com/posts/anatomy-of-a-verkle-proof)
+- [Guillaume Ballet explique les arbres de Verkle à ETHGlobal](https://www.youtube.com/watch?v=f7bEtX3Z57o)
+- [« Comment les arbres de Verkle rendent Ethereum léger et puissant » par Guillaume Ballet à la Devcon 6](https://www.youtube.com/watch?v=Q7rStTKwuYs)
+- [Piper Merriam sur les clients sans état à l'ETHDenver 2020](https://www.youtube.com/watch?v=0yiZJNciIJ4)
+- [Dankrad Fiest explique les arbres de Verkle et le « statelessness » dans le podcast Zero Knowledge](https://zeroknowledge.fm/podcast/202/)
 - [Vitalik Buterin sur les arbres de Verkle](https://vitalik.eth.limo/general/2021/06/18/verkle.html)
 - [Dankrad Feist sur les arbres de Verkle](https://dankradfeist.de/ethereum/2021/06/18/verkle-trie-for-eth1.html)
-- [Documentation EIP sur l'Arbre de Verkle](https://notes.ethereum.org/@vbuterin/verkle_tree_eip#Illustration)
+- [Documentation de l'EIP sur les arbres de Verkle](https://notes.ethereum.org/@vbuterin/verkle_tree_eip#Illustration)
diff --git a/public/content/translations/fr/security/index.md b/public/content/translations/fr/security/index.md
index eaa8d4e1f91..173c50d0576 100644
--- a/public/content/translations/fr/security/index.md
+++ b/public/content/translations/fr/security/index.md
@@ -1,10 +1,10 @@
 ---
-title: Sécurité d'Ethereum et prévention des arnaques
-description: Rester en toute sécurité sur Ethereum
+title: "Sécurité d'Ethereum et prévention des arnaques"
+description: "Rester en toute sécurité sur Ethereum"
 lang: fr
 ---
 
-# Sécurité d'Ethereum et prévention des arnaques {#introduction}
+# Sécurité Ethereum et prévention des arnaques {#introduction}
 
 L'intérêt grandissant pour la cryptomonnaie amène avec lui un risque croissant venant des escrocs et des pirates informatiques. Cet article expose de bonnes pratiques pour atténuer ces risques.
 
@@ -12,18 +12,18 @@ L'intérêt grandissant pour la cryptomonnaie amène avec lui un risque croissan
 
 <Divider />
 
-## Le b.a.-ba de la sécurité de votre cryptomonnaie {#crypto-security}
+## Les bases de la sécurité des cryptos {#crypto-security}
 
-### Approfondir vos connaissances {#level-up-your-knowledge}
+### Améliorez vos connaissances {#level-up-your-knowledge}
 
 Une mauvaise compréhension de la façon dont fonctionnent les cryptomonnaies peut amener à des erreurs coûteuses. Par exemple, si quelqu'un prétend être un agent d'un service client qui peut vous rendre vos ETH perdus en échange de vos clés privées, ils s'attaquent aux personnes ne comprenant pas qu'Ethereum est un réseau décentralisé manquant de ce genre de fonctionnalité. S'informer sur le fonctionnement d'Ethereum est un investissement qui en vaut la peine.
 
 <DocLink href="/what-is-ethereum/">
-  Qu'est-ce qu'Ethereum ?
+  Qu'est-ce qu'Ethereum ?
 </DocLink>
 
 <DocLink href="/eth/">
-  Qu'est-ce-que l'ether ?
+  Qu'est-ce que l'ether ?
 </DocLink>
 <Divider />
 
@@ -31,46 +31,47 @@ Une mauvaise compréhension de la façon dont fonctionnent les cryptomonnaies pe
 
 ### Ne divulguez pas vos clés privées {#protect-private-keys}
 
-**Ne partagez jamais vos clés privées, pour quelque raison que ce soit !**
+**Ne partagez jamais vos clés privées, pour quelque raison que ce soit !**
 
 La clé privée de votre portefeuille fait office de mot de passe pour votre portefeuille Ethereum. Il s'agit de la seule chose qui empêche quelqu'un qui connaît l'adresse de votre portefeuille de vider votre compte de ses actifs !
 
 <DocLink href="/wallets/">
-  Qu'est-ce qu'un portefeuille Ethereum ?
+  Qu'est-ce qu'un portefeuille Ethereum ?
 </DocLink>
 
-#### Ne faites pas de captures d'écran de vos phrases secrètes/clés privées {#screenshot-private-keys}
+#### Ne faites pas de captures d'écran de vos phrases de récupération/clés privées {#screenshot-private-keys}
 
 Faire une capture d'écran de vos phrases de récupération ou vos clés privées pourrait les synchroniser sur un fournisseur de données cloud, ce qui pourrait les rendre accessibles aux pirates informatiques. Récupérer les clés privées du cloud est un vecteur d'attaque prisé des pirates.
 
-### Utiliser un portefeuille matériel {#use-hardware-wallet}
+### Utilisez un portefeuille matériel {#use-hardware-wallet}
 
 Les portefeuilles matériels permettent le stockage hors-ligne de vos clés privées. Ils sont considérés comme l'option de portefeuille la plus sûre pour le stockage de vos clés privées : votre clé privée n'entre jamais en contact avec l'internet et reste entièrement locale sur votre appareil.
 
 Garder vos clés privées hors-ligne réduit significativement le risque qu'elles soient compromises, même si un pirate venait à prendre le contrôle de votre ordinateur.
 
-#### Essayez un portefeuille matériel : {#try-hardware-wallet}
+#### Essayez un portefeuille matériel : {#try-hardware-wallet}
 
 - [Ledger](https://www.ledger.com/)
 - [Trezor](https://trezor.io/)
 
-### Vérifier deux fois vos transactions avant l'envoi {#double-check-transactions}
+### Vérifiez deux fois les transactions avant de les envoyer {#double-check-transactions}
 
-Envoyer de la cryptomonnaie par accident à la mauvaise adresse de portefeuille est une erreur courante. **Une transaction effectuée sur Ethereum est irréversible**. À moins que vous ne connaissiez le propriétaire de l'adresse bénéficiaire et que vous puissiez le convaincre de vous retourner les fonds, vous ne serez pas capable de récupérer vos fonds.
+Envoyer de la cryptomonnaie par accident à la mauvaise adresse de portefeuille est une erreur courante. **Une transaction envoyée sur Ethereum est irréversible.** Sauf si vous connaissez le propriétaire de l'adresse et que vous pouvez le convaincre de vous renvoyer vos fonds, vous ne pourrez pas les récupérer.
 
-Assurez-vous toujours que l'adresse spécifiée correspond exactement à l'adresse destinataire souhaitée avant d'envoyer une transaction. C'est une bonne pratique, quand on interagit avec un contrat intelligent, de lire le message de transaction avant de signer.
+Assurez-vous toujours que l'adresse spécifiée correspond exactement à l'adresse destinataire souhaitée avant d'envoyer une transaction.
+C'est une bonne pratique, quand on interagit avec un contrat intelligent, de lire le message de transaction avant de signer.
 
-### Fixer des limites de dépenses pour les contrats intelligents {#spend-limits}
+### Définir des limites de dépenses pour les contrats intelligents {#spend-limits}
 
 Lorsque vous interagissez avec des contrats intelligents, n'autorisez pas des plafonds de dépenses illimités. Une autorisation de dépenses illimitées peut permettre au contrat intelligent de vider votre portefeuille. Au lieu de cela, fixez plutôt des limites de dépenses correspondant uniquement au montant nécessaire à la transaction.
 
 De nombreux portefeuilles Ethereum offrent des limites de sécurité pour éviter que vos comptes ne soient vidés.
 
-[Comment révoquer l'accès des contrats intelligents à vos fonds crypto](/guides/how-to-revoke-token-access/)
+[Comment révoquer l'accès des contrats intelligents à vos fonds en cryptomonnaies](/guides/how-to-revoke-token-access/)
 
 <Divider />
 
-## Escroqueries courantes {#common-scams}
+## Arnaques courantes {#common-scams}
 
 Il est impossible d'arrêter les escrocs complétement, mais nous pouvons les rendre moins efficaces en étant conscient des techniques d'arnaque les plus utilisées. Il existe de nombreuses variantes de ces escroqueries, mais elles suivent généralement les mêmes schémas de base. Quoi qu'il en soit, n'oubliez pas :
 
@@ -78,45 +79,45 @@ Il est impossible d'arrêter les escrocs complétement, mais nous pouvons les re
 - Personne ne vous offrira des ETH gratuits ou en "promotion"
 - Personne n'a besoin d'accéder à vos clés privées ni à vos informations personnelles
 
-### Hameçonnage par les publicités Twitter {#ad-phishing}
+### Hameçonnage via les publicités Twitter {#ad-phishing}
 
-![Hameçonnage par les liens Twitter](./twitterPhishingScam.png)
+![Hameçonnage par lien sur Twitter](./twitterPhishingScam.png)
 
-Il existe une méthode pour usurper la fonctionnalité d'aperçu des liens Twitter (également connu sous le nom de X) pour potentiellement tromper les utilisateurs afin que ceux-ci pensent visiter un site web légitime. Cette technique exploite les mécanismes utilisés par Twitter pour générer des aperçus des URL partagés dans les tweets, et montre par exemple _from ethereum.org_ (comme montré ci-dessus), alors qu'ils redirigent en fait vers un site malveillant.
+Il existe une méthode pour usurper la fonctionnalité d'aperçu des liens Twitter (également connu sous le nom de X) pour potentiellement tromper les utilisateurs afin que ceux-ci pensent visiter un site web légitime. Cette technique exploite le mécanisme de Twitter pour générer des aperçus des URL partagées dans les tweets, et affiche _d'ethereum.org_ par exemple (illustré ci-dessus), alors qu'en fait, les utilisateurs sont redirigés vers un site malveillant.
 
 Vérifiez toujours que vous êtes sur le bon domaine, surtout après avoir cliqué sur un lien.
 
 [Plus d'informations ici](https://harrydenley.com/faking-twitter-unfurling).
 
-### Arnaques à la distribution de cadeaux {#giveaway}
+### Arnaque à la distribution gratuite {#giveaway}
 
-L'une des escroqueries les plus répandues dans les cryptomonnaies est celle de la distribution de cadeaux. L'arnaque à la distribution de cadeaux peut prendre plusieurs formes, mais l'idée générale est que vous envoyez des ETH à l'adresse portefeuille fournie, et vous recevrez vos ETH en retour mais doublés. *Pour cette raison, cette escroquerie est aussi connue sous le nom d'arnaque du 2 pour 1.*
+L'une des escroqueries les plus répandues dans les cryptomonnaies est celle de la distribution de cadeaux. L'arnaque à la distribution de cadeaux peut prendre plusieurs formes, mais l'idée générale est que vous envoyez des ETH à l'adresse portefeuille fournie, et vous recevrez vos ETH en retour mais doublés._Pour cette raison, cette escroquerie est aussi connue sous le nom d'arnaque du 2 pour 1._
 
 Ces arnaques prévoient généralement un délai limité pour recevoir les cadeaux afin de créer un faux sentiment d'urgence.
 
-### Piratage sur les réseaux sociaux {#social-media-hacks}
+### Piratage de comptes de médias sociaux {#social-media-hacks}
 
 C'est ce qu'il s'est passé en juillet 2020, lorsque les comptes Twitter de célébrités et d'importantes sociétés ont été piratés. Le pirate a simultanément posté une offre de distribution de Bitcoin sur les comptes piratés. Bien que les tweets trompeurs aient été rapidement signalés et supprimés, les pirates ont quand même réussi à disparaître avec 11 bitcoins (soit 500 000 $ en septembre 2021).
 
 ![Une arnaque sur Twitter](./appleTwitterScam.png)
 
-### Distribution de cadeaux par une célébrité {#celebrity-giveaway}
+### Distribution gratuite par une célébrité {#celebrity-giveaway}
 
-La distribution de cadeaux par une célébrité est une variante courante de l'arnaque à la distribution de cadeaux. Les escrocs récupèrent une interview vidéo ou une conférence donnée par une célébrité et la diffusent en direct sur YouTube - en faisant croire que la célébrité en question donnait une interview vidéo en direct pour faire la promotion d'une offre de distribution de cryptomonnaies.
+La distribution de cadeaux par une célébrité est une variante courante de l'escroquerie à l'offre cadeaux. Les escrocs prennent une interview vidéo enregistrée ou une conférence donnée par une célébrité et la diffusent en direct sur YouTube, donnant ainsi l'impression que la célébrité donne une interview vidéo en direct pour promouvoir une distribution gratuite de cryptomonnaies.
 
-Vitalik Buterin est la personnalité la plus souvent utilisée dans cette arnaque, mais de nombreuses autres personnes impliquées dans l'univers des cryptomonnaies le sont aussi (ex : Elon Musk et Charles Hoskinson). Le fait de montrer une personne connue donne à la diffusion en direct un semblant de légitimité (c'est un peu louche, mais Vitalik est de la partie, alors ça doit être bon !).
+Vitalik Buterin est le plus souvent utilisé dans cette arnaque, mais de nombreuses autres personnalités du monde des cryptos sont également utilisées (par ex., Elon Musk ou Charles Hoskinson). Le fait de montrer une personne connue donne à la diffusion en direct un semblant de légitimité (c'est un peu louche, mais Vitalik est de la partie, alors ça doit être bon !).
 
-**Les distributions de cadeaux sont toujours des arnaques. Si vous envoyez des fonds sur ces comptes, vous les perdrez pour toujours.**
+**Les offres cadeaux sont toujours des arnaques. Si vous envoyez des fonds sur ces comptes, vous les perdrez pour toujours.**
 
 ![Une arnaque sur YouTube](./youtubeScam.png)
 
-### Arnaques à l'assistance {#support-scams}
+### Arnaques au support technique {#support-scams}
 
 Les cryptomonnaies sont une technologie relativement jeune et mal comprise. Une escroquerie courante qui tire parti de cette situation est l'arnaque à la fausse assistance, dans laquelle les escrocs vont se faire passer pour un agent d'assistance de portefeuilles, de plateformes d'échange ou de blockchains.
 
 La majorité des discussions autour d'Ethereum ont lieu sur Discord. Les escrocs à la fausse assistance trouveront généralement leur cible en cherchant des demandes d'assistance dans les canaux Discord publics, pour ensuite envoyer une proposition d'assistance à leur proie par message privé. En instaurant un climat de confiance, les escrocs vont tenter de vous pousser à divulguer vos clés privées ou à envoyer votre argent vers leurs portefeuilles.
 
-![Une arnaque à la fausse assistance sur Discord](./discordScam.png)
+![Une arnaque au support technique sur Discord](./discordScam.png)
 
 En principe, l'équipe d'Ethereum ne communiquera jamais avec vous par le biais de canaux privés non officiels. Quelques éléments simples à garder en tête lorsque vous obtenez de l'aide :
 
@@ -128,18 +129,18 @@ En principe, l'équipe d'Ethereum ne communiquera jamais avec vous par le biais
 <AlertEmoji text=":lock:"/>
 <AlertContent>
 <AlertDescription>
-    Attention : bien que les arnaques à l'assistance se produisent généralement sur Discord, elles peuvent aussi vous arriver sur toutes les plateformes où des discussions autour de la cryptomonnaie ont lieu, y compris par e-mail.
+    Attention : bien que les arnaques de type support technique se produisent fréquemment sur Discord, elles peuvent également être répandues sur n'importe quelle application de chat où ont lieu des discussions sur les cryptos, y compris par e-mail.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
-### Arnaque au jeton « Eth2 » {#eth2-token-scam}
+### Arnaque au jeton « Eth2 » {#eth2-token-scam}
 
-Dans la période précédant [La Fusion](/roadmap/merge/), les fraudeurs ont profité de la confusion autour du terme « Eth2 » pour essayer d'obtenir que les utilisateurs rachètent leur ETH pour un jeton « ETH2 ». Il n'existe pas d'« ETH2 » et aucun autre jeton légitime n'a été introduit avec La Fusion. L'ETH que vous possédiez avant La Fusion est le même ETH aujourd'hui. Il est **inutile de prendre des mesures liées à votre ETH pour tenir compte du passage de la preuve de travail à la preuve d'enjeu**.
+À l'approche de [La Fusion](/roadmap/merge/), des escrocs ont profité de la confusion autour du terme « Eth2 » pour tenter d'amener les utilisateurs à échanger leurs ETH contre un jeton « ETH2 ». Il n'existe pas d'« ETH2 » et aucun autre jeton légitime n'a été introduit avec La Fusion. L'ETH que vous possédiez avant La Fusion est le même ETH aujourd'hui. **Il n'est pas nécessaire d'effectuer une action quelconque concernant vos ETH pour tenir compte du passage de la preuve de travail à la preuve d'enjeu.**
 
-Les escrocs peuvent apparaître sous la forme d'un agent d'« assistance » vous indiquant que si vous déposez votre ETH, vous recevrez en retour « ETH2 ». Il n'existe pas de [support Ethereum officiel](/community/support/), et il n'y a pas de nouveau jeton. Ne partagez jamais la phrase de récupération de votre portefeuille avec qui que ce soit.
+Les escrocs peuvent apparaître sous la forme d'un agent d'« assistance » vous indiquant que si vous déposez votre ETH, vous recevrez en retour « ETH2 ». Il n'y a pas de [support officiel pour Ethereum](/community/support/), et il n'y a pas de nouveau jeton. Ne partagez jamais la phrase de récupération de votre portefeuille avec qui que ce soit.
 
-_Remarque : il existe des jetons/téléscripteurs dérivés qui peuvent représenter une mise en jeu ETH (ex. rETH de Rocket Pool, stETH de Lido, ETH2 de Coinbase), mais ce ne sont pas des éléments vers lesquels vous devriez « migrer. »_
+_Remarque : il existe des jetons/tickers dérivés qui peuvent représenter des ETH mis en jeu (c.-à-d. rETH de Rocket Pool, stETH de Lido, ETH2 de Coinbase), mais vous n'avez pas besoin de « migrer » vers eux._
 
 ### Arnaques par hameçonnage {#phishing-scams}
 
@@ -153,11 +154,11 @@ Si vous recevez un e-mail de la part d'un expéditeur inconnu, rappelez-vous :
 - Ne partagez vos informations personnelles ou vos mots de passe avec personne
 - Supprimez les e-mails qui viennent d'expéditeurs inconnus
 
-[En savoir plus sur les moyens d'éviter les arnaques par hameçonnage](https://support.mycrypto.com/staying-safe/mycrypto-protips-how-not-to-get-scammed-during-ico)
+[En savoir plus sur la façon d'éviter les arnaques par hameçonnage](https://support.mycrypto.com/staying-safe/mycrypto-protips-how-not-to-get-scammed-during-ico)
 
-### Arnaques au faux courtier en cryptomonnaie {#broker-scams}
+### Arnaques aux faux courtiers en cryptomonnaies {#broker-scams}
 
-Les faux courtiers d'échange de cryptomonnaies prétendent être des spécialistes en courtage de cryptomonnaies qui vont vous offrir de prendre votre argent et de l'investir en votre nom. Une fois que l'escroc aura reçu vos fonds, il pourra vous inciter à en envoyer d'autres, afin que vous ne manquiez pas d'autres gains d'investissement, ou il pourra disparaître complètement.
+Les faux courtiers d'échange de cryptomonnaies prétendent être des spécialistes en courtage de cryptomonnaies qui vont vous offrir de prendre votre argent et de l'investir en votre nom. Une fois que l'escroc aura reçu vos fonds, il pourra vous inciter à en envoyer d'autres, afin que vous ne manquiez pas d'autres gains d'investissement, ou bien disparaître complètement.
 
 Ces fraudeurs trouvent souvent des cibles en utilisant de faux comptes sur Youtube pour engager une conversation apparemment normale sur le « courtier ». Ces discussions reçoivent souvent un nombre important de votes positifs pour en accroître la légitimité, mais ces votes proviennent tous de robots.
 
@@ -165,11 +166,11 @@ Ces fraudeurs trouvent souvent des cibles en utilisant de faux comptes sur Youtu
 
 ![Une arnaque au faux courtier sur YouTube](./brokerScam.png)
 
-### Arnaques au pool de minage de cryptomonnaies {#mining-pool-scams}
+### Arnaques aux pools de minage de cryptomonnaies {#mining-pool-scams}
 
 Depuis septembre 2022, le minage sur Ethereum n'est plus possible. Cependant, on trouve toujours des escroqueries dans les pools de minage. Dans le cas des arnaques liées aux pools de minage, des personnes vous contactent sans que vous les ayez sollicitées et vous disent que vous pouvez gagner beaucoup d'argent en faisant partie d'un pool de minage Ethereum. L'escroc vous fera des promesses et restera en contact avec vous le temps qu'il faudra. Concrètement, l'escroc va essayer de vous convaincre que lorsque vous rejoignez un ensemble de minage Ethereum, vos cryptomonnaies vont être utilisées pour créer de l'ETH et que vous allez être payé avec des dividendes en ETH. Vous allez alors voir que vos cryptomonnaies vous rapportent de petits montants. Il s'agit simplement d'un piège pour vous inciter à investir davantage. Au bout du compte, tous vos fonds investis seront envoyés à une adresse inconnue et l'escroc disparaîtra ou, dans certains cas, restera en contact avec vous, comme cela s'est produit dans une affaire récente.
 
-Pour résumer, méfiez-vous des personnes qui vous contactent sur les réseaux sociaux pour vous proposer de rejoindre un ensemble de minage. Une fois que vous avez perdu votre cryptomonnaie, il est trop tard.
+Pour résumer, méfiez-vous des personnes qui vous contactent sur les réseaux sociaux pour vous proposer de rejoindre un ensemble de minage. Une fois votre cryptomonnai perdue, il est trop tard.
 
 Quelques points à retenir :
 
@@ -177,44 +178,44 @@ Quelques points à retenir :
 - Faites des recherches sur la mise en jeu, les pools de liquidités et autres moyens d'investir votre cryptomonnaie
 - De telles démarches sont rarement, voire jamais légitimes. Si elles l'étaient, elles seraient probablement grand public et vous en auriez entendu parler.
 
-[Une personne perd 200 000 dollars dans une arnaque au groupe de minage](https://www.reddit.com/r/CoinBase/comments/r0qe0e/scam_or_possible_incredible_payout/)
+[Un homme perd 200 000 $ dans une arnaque au pool de minage](https://www.reddit.com/r/CoinBase/comments/r0qe0e/scam_or_possible_incredible_payout/)
 
-### Arnaques par Airdrop {#airdrop-scams}
+### Arnaques à l'airdrop {#airdrop-scams}
 
-Les arnaques au airdrop : il s'agit d'un projet factice de distribution d'actif (NFT, jeton) dans votre portefeuille (wallet). Ce type d'escroquerie vous renvoie vers un faux site pour réclamer l'actif en question. Vous serez invité à vous connecter avec votre portefeuille Ethereum et à « autoriser » une transaction lors d'une tentative de réclamation. Cette transaction compromet votre compte en envoyant vos clés publiques et privées à l'escroc. Une forme alternative de cette arnaque peut consister à vous demander de confirmer une transaction qui envoie des fonds sur le compte de l'escroc.
+Les arnaques au airdrop : il s'agit d'un projet factice de distribution d'actif (NFT, jeton) dans votre portefeuille (wallet). Ce type d'escroquerie vous renvoie vers un faux site pour réclamer l'actif en question. Vous serez invité à vous connecter avec votre portefeuille Ethereum et à « autoriser » une transaction lors d'une tentative de réclamation. Cette transaction compromet votre compte en envoyant vos clés publiques et privées à l'escroc. Une autre forme de cette escroquerie consiste à vous faire confirmer une transaction qui envoie des fonds sur le compte de l'escroc.
 
-[En savoir plus sur les arnaques par Airdrop](https://www.youtube.com/watch?v=LLL_nQp1lGk)
+[En savoir plus sur les arnaques à l'airdrop](https://www.youtube.com/watch?v=LLL_nQp1lGk)
 
 <Divider />
 
-## Le b.a.-ba de la sécurité sur le Web {#web-security}
+## Les bases de la sécurité Web {#web-security}
 
-### Utilisez des mots de passe forts {#use-strong-passwords}
+### Utiliser des mots de passe forts {#use-strong-passwords}
 
-[Plus de 80 % des piratages de comptes sont le résultat de mots de passe faibles ou volés](https://cloudnine.com/ediscoverydaily/electronic-discovery/80-percent-hacking-related-breaches-related-password-issues-cybersecurity-trends/). Une combinaison longue de caractères, de nombres et de symboles va vous aider à garder vos comptes sécurisés.
+[Plus de 80 % des piratages de comptes sont le résultat de mots de passe faibles ou volés](https://cloudnine.com/ediscoverydaily/electronic-discovery/80-percent-hacking-related-breaches-related-password-issues-cybersecurity-trends/). Une combinaison longue de caractères, de nombres et de symboles va vous aider à garder vos comptes sécurisés.
 
 Une erreur commune est d'utiliser une combinaison de quelques mots communs et liés. Les mots de passe de ce type sont peu sécurisés car ils sont sujets à une attaque de piratage appelée attaque par dictionnaire.
 
 ```md
-Exemple de mot de passe faible : CuteFluffyKittens!
+Exemple de mot de passe faible : CuteFluffyKittens!
 
-Exemple de mot de passe fort : ymv\*azu.EAC8eyp8umf
+Exemple de mot de passe fort : ymv\*azu.EAC8eyp8umf
 ```
 
-Une autre erreur commune est d'utiliser des mots de passe qui peuvent être facilement devinés ou découverts grâce à [l'ingénierie sociale](https://wikipedia.org/wiki/Social_engineering_(security)). Inclure le nom de jeune fille de votre mère, les noms de vos enfants ou de vos animaux de compagnie, ou bien des dates d'anniversaire dans vos mots de passe va augmenter les risques que vos mots de passe soit compromis, et donc le risque de piratage.
+Une autre erreur courante consiste à utiliser des mots de passe qui peuvent être facilement devinés ou découverts grâce à [l'ingénierie sociale](https://wikipedia.org/wiki/Social_engineering_\(security\)). Inclure le nom de jeune fille de votre mère, les noms de vos enfants ou de vos animaux de compagnie, ou bien des dates d'anniversaire dans vos mots de passe va augmenter les risques que vos mots de passe soit compromis, et donc le risque de piratage.
 
-#### Bonnes pratiques pour des mots de passe forts : {#good-password-practices}
+#### Bonnes pratiques en matière de mots de passe : {#good-password-practices}
 
 - Rendre les mots de passe aussi long que autorisé par votre générateur de mot de passe ou par le formulaire que vous remplissez
 - Utiliser un mélange de majuscules, minuscules, chiffres et symboles
 - Ne pas inclure d'informations personnelles, telles que les noms de famille, dans votre mot de passe
 - Évitez les mots communs
 
-[Plus d'informations sur la création de mots de passe forts](https://terranovasecurity.com/how-to-create-a-strong-password-in-7-easy-steps/)
+[En savoir plus sur la création de mots de passe forts](https://terranovasecurity.com/how-to-create-a-strong-password-in-7-easy-steps/)
 
-### Utiliser un mot de passe unique pour chaque compte {#use-unique-passwords}
+### Utiliser des mots de passe uniques pour tous vos comptes {#use-unique-passwords}
 
-Un mot de passe qui a été révélé par une faille de sécurité n'est plus un mot de passe fort et sécurisé. Le site web [Have I Been Pwned](https://haveibeenpwned.com) vous permet de vérifier si vos comptes ont été impliqués dans une fuite de données connue. Si tel est le cas, **changez ces mots de passe immédiatement**. Utiliser des mots de passe uniques pour chaque compte réduit le risque que des pirates informatiques aient accès à tous vos comptes si l'un de vos mots de passe est compromis.
+Un mot de passe qui a été révélé par une faille de sécurité n'est plus un mot de passe fort et sécurisé. Le site web [Have I Been Pwned](https://haveibeenpwned.com) vous permet de vérifier si vos comptes ont été impliqués dans des fuites de données publiques. Si c'est le cas, **changez immédiatement ces mots de passe**. Utiliser des mots de passe uniques pour chaque compte réduit le risque que des pirates informatiques aient accès à tous vos comptes si l'un de vos mots de passe est compromis.
 
 ### Utiliser un gestionnaire de mots de passe {#use-password-manager}
 
@@ -222,7 +223,7 @@ Un mot de passe qui a été révélé par une faille de sécurité n'est plus un
 <AlertEmoji text=":bulb:"/>
 <AlertContent>
 <AlertDescription>
-    Un gestionnaire de mots de passe prend soin de créer des mots de passe forts et uniques et de les retenir ! Nous <strong>recommandons fortement</strong> d'en utiliser un, et la plupart d'entre eux sont gratuits !
+    L'utilisation d'un gestionnaire de mots de passe se charge de créer des mots de passe forts et uniques, et de s'en souvenir pour vous ! Nous vous recommandons <strong>fortement</strong> d'en utiliser un, et la plupart d'entre eux sont gratuits !
 </AlertDescription>
 </AlertContent>
 </Alert>
@@ -231,74 +232,74 @@ Se souvenir de mots de passe forts et uniques pour chaque compte que vous avez n
 
 ![Exemple d'utilisation d'un gestionnaire de mots de passe](./passwordManager.png)
 
-#### Essayez un gestionnaire de mots de passe : {#try-password-manager}
+#### Essayez un gestionnaire de mots de passe : {#try-password-manager}
 
 - [Bitwarden](https://bitwarden.com/)
 - [KeePass](https://keepass.info/)
 - [1Password](https://1password.com/)
-- Ou consultez les autres [gestionnaires de mots de passe recommandés](https://www.privacytools.io/secure-password-manager)
+- Ou consultez d'autres [gestionnaires de mots de passe recommandés](https://www.privacytools.io/secure-password-manager)
 
 ### Utiliser l'authentification à deux facteurs {#two-factor-authentication}
 
-Il vous sera peut-être quelques fois demandé d'authentifier votre identité aux moyens de preuves uniques. Celles-ci sont connues sous le nom de **facteurs**. Les trois principaux facteurs sont :
+Il vous sera peut-être quelques fois demandé d'authentifier votre identité aux moyens de preuves uniques. Ceux-ci sont appelés des **facteurs**. Les trois principaux facteurs sont :
 
 - Quelque chose que vous connaissez (comme un mot de passe ou une question de sécurité)
 - Quelque chose que vous êtes (comme une empreinte digitale ou un scanner iris/facial)
 - Quelque chose que vous possédez (une clé de sécurité ou une application d'authentification sur votre téléphone)
 
-Utilisez **l'authentification à deux facteurs (2FA)** fournit un *facteur de sécurité* supplémentaire pour vos comptes en ligne. Une 2FA assure qu'avoir simplement votre mot de passe n'est pas suffisant pour accéder à un compte. Le plus souvent, le second facteur est un code temporaire aléatoire à 6 chiffres, appelé **mot de passe à usage unique basé sur le temps (TOTP ou time-based one-time password)**, auquel vous accédez par une application d'authentification comme Google Authentifactor ou Authy. Cette méthode est un facteur « Que vous possédez », car la clé racine qui génére les code temporaires est stocké sur votre appareil.
+L'utilisation de l'**authentification à deux facteurs (A2F)** offre un _facteur de sécurité_ supplémentaire pour vos comptes en ligne. Une 2FA assure qu'avoir simplement votre mot de passe n'est pas suffisant pour accéder à un compte. Le plus souvent, le deuxième facteur est un code aléatoire à 6 chiffres, connu sous le nom de **mot de passe à usage unique basé sur le temps (TOTP)**, auquel vous pouvez accéder via une application d'authentification telle que Google Authenticator ou Authy. Cette méthode est un facteur « Que vous possédez », car la clé racine qui génére les code temporaires est stocké sur votre appareil.
 
 <Alert variant="update">
 <AlertEmoji text=":lock:"/>
 <AlertContent>
 <AlertDescription>
-    Note : Utiliser l'envoi d'un code SMS comme 2FA n'est pas une méthode sûre à cause des possibilités de <a href="https://www.vice.com/en/article/3kx4ej/sim-jacking-mobile-phone-fraud">piratage de la SIM </a>. Pour une sécurité maximale, utilisez un service comme <a href="https://mashable.com/article/how-to-set-up-google-authenticator"> Google Authenticator</a> ou <a href="https://authy.com/">Authy</a>.
+    Remarque : l'utilisation de l'A2F par SMS est vulnérable au <a href="https://www.vice.com/en/article/3kx4ej/sim-jacking-mobile-phone-fraud">piratage de la carte SIM (SIM jacking)</a> et n'est pas sécurisée. Pour une sécurité optimale, utilisez un service comme <a href="https://mashable.com/article/how-to-set-up-google-authenticator">Google Authenticator</a> ou <a href="https://authy.com/">Authy</a>.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
 #### Clés de sécurité {#security-keys}
 
-Une clé de sécurité est une 2FA plus avancée et plus sécurisée. Les clés de sécurité sont des systèmes d'authentification matériels physiques, qui fonctionnent comme les solutions d'authentification logicielles. Utiliser une clé de sécurité est la solution 2FA la plus sécurisée. Beaucoup de ces clés utilisent la norme universelle d'authentification à deux facteurs (U2F), FIDO. [ A propos de FIDO U2F](https://www.yubico.com/authentication-standards/fido-u2f/).
+Une clé de sécurité est une 2FA plus avancée et plus sécurisée. Les clés de sécurité sont des systèmes d'authentification matériels physiques, qui fonctionnent comme les solutions d'authentification logicielles. Utiliser une clé de sécurité est la solution 2FA la plus sécurisée. Beaucoup de ces clés utilisent la norme universelle d'authentification à deux facteurs (U2F), FIDO. [En savoir plus sur FIDO U2F](https://www.yubico.com/resources/glossary/fido-u2f/).
 
 En savoir plus sur la 2FA :
 
 <YouTube id="m8jlnZuV1i4" start="3479" />
 
-### Désinstaller les extensions du navigateur {#uninstall-browser-extensions}
+### Désinstaller les extensions de navigateur {#uninstall-browser-extensions}
 
 Les extensions de navigateur, comme les extensions de Chrome ou les modules complémentaires de Firefox, peuvent améliorer les fonctionnalités du navigateur, mais comportent également certains risques. Par défaut, la plupart des extensions des navigateurs demandent un accès avec des droits de « lecture et écriture », leur permettant de faire presque tout de vos données. Les extensions Chrome se mettent à jours automatiquement, ainsi les mises à jours peuvent introduire un code malicieux sur une extension auparavant sûre. La plupart des extensions des navigateurs ne cherchent pas à voler vos données, mais c'est un risque à prendre en compte.
 
-#### Bonnes pratiques : {#browser-extension-safety}
+#### Restez en sécurité en : {#browser-extension-safety}
 
 - N'installer que des extensions d'éditeurs de confiance
 - Désinstaller les extensions de navigateur non-utilisées
 - Installez les extensions Chrome localement pour arrêter la mise à jour automatique (Avancé)
 
-[En savoir plus sur les risques liés aux extensions des navigateurs](https://www.kaspersky.co.uk/blog/browser-extensions-security/12750/)
+[En savoir plus sur les risques liés aux extensions de navigateur](https://www.kaspersky.co.uk/blog/browser-extensions-security/12750/)
 
 <Divider />
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-### Sécurité sur le Web {#reading-web-security}
+### Sécurité Web {#reading-web-security}
 
-- [Up to 3 million devices infected by malware-laced Chrome and Edge add-ons](https://arstechnica.com/information-technology/2020/12/up-to-3-million-devices-infected-by-malware-laced-chrome-and-edge-add-ons/) - _Dan Goodin_
-- [How to Create a Strong Password — That You Won’t Forget](https://www.avg.com/en/signal/how-to-create-a-strong-password-that-you-wont-forget) - _AVG_
-- [What is a security key?](https://help.coinbase.com/en/coinbase/getting-started/verify-my-account/security-keys-faq) - _Coinbase_
+- [Jusqu'à 3 millions d'appareils infectés par des logiciels malveillants via des modules complémentaires pour Chrome et Edge](https://arstechnica.com/information-technology/2020/12/up-to-3-million-devices-infected-by-malware-laced-chrome-and-edge-add-ons/) - _Dan Goodin_
+- [Comment créer un mot de passe fort — que vous n’oublierez pas](https://www.avg.com/en/signal/how-to-create-a-strong-password-that-you-wont-forget) - _AVG_
+- [Qu'est-ce qu'une clé de sécurité ?](https://help.coinbase.com/en/coinbase/getting-started/verify-my-account/security-keys-faq) - _Coinbase_
 
-### Sécurité des cryptomonnaies {#reading-crypto-security}
+### Sécurité des cryptos {#reading-crypto-security}
 
-- [Protecting Yourself and Your Funds](https://support.mycrypto.com/staying-safe/protecting-yourself-and-your-funds) - _MyCrypto_
-- [Security issues in common crypto communication software](https://docs.salusec.io/untitled/web3-penetration-test/risks-in-social-media) - _Salus_
-- [Security Guide For Dummies And Smart People Too](https://medium.com/mycrypto/mycryptos-security-guide-for-dummies-and-smart-people-too-ab178299c82e) - _MyCrypto_
-- [Crypto Security: Passwords and Authentication](https://www.youtube.com/watch?v=m8jlnZuV1i4) - _Andreas M. Antonopoulos_
+- [Se protéger et protéger ses fonds](https://support.mycrypto.com/staying-safe/protecting-yourself-and-your-funds) - _MyCrypto_
+- [Problèmes de sécurité dans les logiciels de communication crypto courants](https://docs.salusec.io/untitled/web3-penetration-test/risks-in-social-media) - _Salus_
+- [Guide de sécurité pour les nuls et les personnes intelligentes aussi](https://medium.com/mycrypto/mycryptos-security-guide-for-dummies-and-smart-people-too-ab178299c82e) - _MyCrypto_
+- [Sécurité crypto : Mots de passe et authentification](https://www.youtube.com/watch?v=m8jlnZuV1i4) - _Andreas M. Antonopoulos_
 
-### Prévention des arnaques {#reading-scam-education}
+### Sensibilisation aux arnaques {#reading-scam-education}
 
 - [Guide : Comment identifier les jetons frauduleux](/guides/how-to-id-scam-tokens/)
-- [Staying Safe: Common Scams](https://support.mycrypto.com/staying-safe/common-scams) - _MyCrypto_
-- [Avoiding Scams](https://bitcoin.org/en/scams) - _Bitcoin.org_
-- [Fil Twitter sur les courriels et messages communs de phishing en cryptomonnaies](https://twitter.com/tayvano_/status/1516225457640787969) - _Taylor Monahan_
+- [Rester en sécurité : arnaques courantes](https://support.mycrypto.com/staying-safe/common-scams) - _MyCrypto_
+- [Éviter les arnaques](https://bitcoin.org/en/scams) - _Bitcoin.org_
+- [Fil de discussion Twitter sur les e-mails et messages d'hameçonnage crypto courants](https://twitter.com/tayvano_/status/1516225457640787969) - _Taylor Monahan_
 
 <QuizWidget quizKey="security" />
diff --git a/public/content/translations/fr/smart-contracts/index.md b/public/content/translations/fr/smart-contracts/index.md
index 0179ee794c6..6d76122d9b9 100644
--- a/public/content/translations/fr/smart-contracts/index.md
+++ b/public/content/translations/fr/smart-contracts/index.md
@@ -1,6 +1,6 @@
 ---
 title: Contrats intelligents
-metaTitle: "Contrats intelligents : quels sont les avantages"
+metaTitle: "Contrats intelligents : Que sont-ils et quels sont leurs avantages"
 description: Une introduction non technique aux contrats intelligents
 lang: fr
 ---
@@ -11,9 +11,9 @@ lang: fr
 <ListenToPlayer slug="/smart-contracts/" />
 </div>
 
-Les contrats intelligents sont les éléments fondamentaux de la couche applicative d'Ethereum. Il s'agit de programmes informatiques stockés sur la [blockchain](/glossary/#blockchain) qui suivent la logique « si ceci alors cela » et sont garantis de s'exécuter selon les règles définies par leur code, qui ne peut être modifié une fois créé.
+Les contrats intelligents sont les éléments fondamentaux de la couche applicative d'Ethereum. Ce sont des programmes informatiques stockés sur la [blockchain](/glossary/#blockchain) qui suivent la logique « si ceci alors cela » et sont garantis de s'exécuter selon les règles définies par leur code, qui ne peut être modifié une fois créé.
 
-L'expression « contrat intelligent » a été utilisée en premier par Nick Szabo. En 1994, il a écrit [une introduction au concept](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart.contracts.html), et en 1996 il a écrit [une exploration de ce que les contrats intelligents pourraient faire](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart_contracts_2.html).
+L'expression « contrat intelligent » a été utilisée en premier par Nick Szabo. En 1994, il a rédigé [une introduction au concept](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart.contracts.html) et en 1996, il a écrit [une exploration de ce que les contrats intelligents pouvaient faire](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart_contracts_2.html).
 
 Szabo a imaginé un marché numérique où des processus automatiques et [cryptographiquement sécurisés](/glossary/#cryptography) permettent aux transactions et aux fonctions commerciales de se dérouler sans intermédiaires de confiance. Les contrats intelligents Ethereum concrétisent cette vision.
 
@@ -29,9 +29,9 @@ En voici un exemple :
 
 Alice et Bob font une course de vélo. Imaginons qu'Alice parie 10 € avec Bob qu'elle gagnera la course. Bob est sûr de gagner et accepte le pari. Finalement, Alice devance largement Bob et gagne de façon incontestable la course. Mais Bob refuse de payer le pari, prétendant qu'Alice a dû tricher.
 
-Cet exemple ridicule illustre le problème de tout accord non intelligent. Même si les conditions de l'accord sont remplies (ex. vous avez gagné la course), vous devez toujours faire confiance à une autre personne pour qu'elle respecte l'accord (ex. payer le pari).
+Cet exemple ridicule illustre le problème de tout accord non intelligent. Même si les conditions de l'accord sont remplies (p. ex., vous êtes le vainqueur de la course), vous devez toujours faire confiance à une autre personne pour honorer l'accord (p. ex., payer le pari).
 
-## Distributeur automatique numérique {#vending-machine}
+## Un distributeur automatique numérique {#vending-machine}
 
 Nous pouvons comparer simplement un contrat intelligent à un distributeur automatique, qui fonctionne de manière assez similaire à un contrat intelligent ; des intrants spécifiques qui garantissent des résultats prédéterminés.
 
@@ -53,7 +53,7 @@ Par exemple, vous pouvez rédiger un contrat intelligent qui détient des fonds
 
 Les contrats traditionnels sont ambigus parce qu'ils dépendent de l'homme pour leur interprétation et leur mise en œuvre. Par exemple, deux juges peuvent interpréter un contrat différemment, ce qui peut conduire à des décisions incohérentes et à des résultats inégaux. Les contrats intelligents éliminent cette possibilité. En effet, les contrats intelligents s'exécutent précisément en fonction des conditions écrites dans le code du contrat. Cette précision signifie que, dans les mêmes circonstances, le contrat intelligent produit le même résultat.
 
-## Enregistrement public {#public-record}
+## Registre public {#public-record}
 
 Les contrats intelligents sont utiles pour les audits et le suivi. Comme les contrats intelligents Ethereum sont sur une blockchain publique, tout le monde peut suivre instantanément les transferts d'actifs ainsi que toute autre information connexe. Vous pouvez par exemple vérifier si quelqu'un a envoyé de l'argent à votre adresse.
 
@@ -61,7 +61,7 @@ Les contrats intelligents sont utiles pour les audits et le suivi. Comme les con
 
 Les contrats intelligents protègent également votre vie privée. Ethereum étant un réseau pseudonyme (vos transactions sont liées publiquement à une adresse cryptographique unique, et non à votre identité), vous pouvez protéger votre vie privée.
 
-## Transparence des conditions {#visible-terms}
+## Conditions visibles {#visible-terms}
 
 Enfin, comme pour les contrats traditionnels, vous pouvez vérifier le contenu d'un contrat intelligent avant de le signer (ou d'interagir avec). La transparence d'un contrat intelligent garantit que tout le monde peut l'examiner.
 
@@ -69,18 +69,22 @@ Enfin, comme pour les contrats traditionnels, vous pouvez vérifier le contenu d
 
 Les contrats intelligents peuvent faire essentiellement tout ce que les programmes informatiques peuvent faire.
 
-Ils peuvent effectuer des calculs, produire de la monnaie, stocker des données, générer des [NFT](/glossary/#nft), envoyer des messages et même produire des visuels. Voici quelques exemples courants et concrets :
+Ils peuvent effectuer des calculs, créer de la monnaie, stocker des données, frapper des [NFTs](/glossary/#nft), envoyer des communications et même générer des graphiques. Voici quelques exemples courants et concrets :
 
 - [Stablecoins](/stablecoins/)
 - [Création et distribution d'actifs numériques uniques](/nft/)
-- [Plateforme d'échange ouverte et automatisée](/get-eth/#dex)
-- [Jeu décentralisé](/apps/categories/gaming)
-- [Police d'assurance qui paie automatiquement](https://etherisc.com/)
-- [Norme qui permet aux gens de créer des devises personnalisées et interopérables](/developers/docs/standards/tokens/)
+- [Un échange de devises automatique et ouvert](/get-eth/#dex)
+- [Jeux décentralisés](/apps/categories/gaming)
+- [Une police d'assurance qui paie automatiquement](https://etherisc.com/)
+- [Une norme qui permet aux gens de créer des devises personnalisées et interopérables](/developers/docs/standards/tokens/)
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
 - [Comment les contrats intelligents vont changer le monde](https://www.youtube.com/watch?v=pA6CGuXEKtQ)
 - [Les contrats intelligents pour les développeurs](/developers/docs/smart-contracts/)
-- [Apprenez à rédiger des contrats intelligents](/developers/learning-tools/)
-- [Maîtriser Ethereum - Qu'est-ce qu'un contrat intelligent ?](https://github.com/ethereumbook/ethereumbook/blob/openedition/07smart-contracts-solidity.asciidoc#what-is-a-smart-contract)
+- [Apprendre à écrire des contrats intelligents](/developers/learning-tools/)
+- [Mastering Ethereum – Qu'est-ce qu'un contrat intelligent ?](https://github.com/ethereumbook/ethereumbook/blob/openedition/07smart-contracts-solidity.asciidoc#what-is-a-smart-contract)
+
+<Divider />
+
+<QuizWidget quizKey="smart-contracts" />
diff --git a/public/content/translations/fr/social-networks/index.md b/public/content/translations/fr/social-networks/index.md
index fa1605ac6f9..5e04f67dfcd 100644
--- a/public/content/translations/fr/social-networks/index.md
+++ b/public/content/translations/fr/social-networks/index.md
@@ -1,21 +1,21 @@
 ---
-title: Les réseaux sociaux décentralisés
-description: Un aperçu des réseaux sociaux décentralisés sur Ethereum
+title: "Les réseaux sociaux décentralisés"
+description: "Un aperçu des réseaux sociaux décentralisés sur Ethereum"
 lang: fr
 template: use-cases
 emoji: ":mega:"
 sidebarDepth: 2
 image: /images/ethereum-learn.png
-summaryPoint1: Plateformes basées sur la blockchain pour les interactions sociales, la création et la distribution de contenu.
-summaryPoint2: Les médias décentralisés protègent la confidentialité des utilisateurs et améliorent la sécurité des données.
-summaryPoint3: Les jetons et les NFT créent de nouvelles façons de monétiser le contenu.
+summaryPoint1: "Plateformes basées sur la blockchain pour les interactions sociales, la création et la distribution de contenu."
+summaryPoint2: "Les médias décentralisés protègent la confidentialité des utilisateurs et améliorent la sécurité des données."
+summaryPoint3: "Les jetons et les NFT créent de nouvelles façons de monétiser le contenu."
 ---
 
 Les réseaux sociaux jouent un rôle considérable dans nos communications et interactions quotidiennes. Cependant, le contrôle centralisé de ces plates-formes a créé de nombreux problèmes : fuites de données, pannes de serveur, censure et violations de la vie privée sont souvent des compromis que les réseaux sociaux font. Pour lutter contre ces problèmes, les développeurs construisent des réseaux sociaux sur Ethereum. Les réseaux sociaux décentralisés peuvent résoudre bon nombre des problèmes des plates-formes traditionnelles et améliorer l'expérience globale des utilisateurs.
 
 ## Qu'est-ce qu'un réseau social décentralisé ? {#what-are-decentralized-social-networks}
 
-Les réseaux sociaux décentralisés sont des plateformes basées sur la [blockchain](/glossary/#blockchain) qui permettent aux utilisateurs d'échanger des informations ainsi que de publier et de distribuer du contenu au public. Parce que ces applications s'exécutent sur la blockchain, elles sont capables d'être décentralisées et résistantes à la censure et au contrôle excessif.
+Les réseaux sociaux décentralisés sont des plateformes [basées sur la blockchain](/glossary/#blockchain) qui permettent aux utilisateurs d'échanger des informations ainsi que de publier et de distribuer du contenu au public. Parce que ces applications s'exécutent sur la blockchain, elles sont capables d'être décentralisées et résistantes à la censure et au contrôle excessif.
 
 De nombreux réseaux sociaux décentralisés existent comme alternatives aux services de médias sociaux établis, tels que Facebook, LinkedIn, Twitter et Medium. Les réseaux sociaux basés sur la blockchain ont un certain nombre de caractéristiques qui les placent devant les plates-formes traditionnelles.
 
@@ -23,29 +23,29 @@ De nombreux réseaux sociaux décentralisés existent comme alternatives aux ser
 
 ### Comment fonctionnent les réseaux sociaux décentralisés ? {#decentralized-social-networks-overview}
 
-Les réseaux sociaux décentralisés sont une classe d'applications [décentralisées (DApps)](/apps/)— des applications gérées par des [contrats intelligents](/glossary/#smart-contract) déployés sur la blockchain. Le code du contrat sert de backend pour ces applications et définit leur logique commerciale.
+Les réseaux sociaux décentralisés sont une catégorie d'[applications décentralisées (dapps)](/apps/) — des applications alimentées par des [contrats intelligents](/glossary/#smart-contract) déployés sur la blockchain. Le code du contrat sert de backend pour ces applications et définit leur logique commerciale.
 
-Les plateformes de réseaux sociaux traditionnels se fondent sur des bases de données pour stocker des informations sur l’utilisateur, le code du programme et d’autres formes de données. Mais cela crée des points de vulnérabilité et comporte des risques significatifs. Par exemple, les serveurs de Facebook sont tristement célèbres pour [être devenus inaccessibles pendant des heures](https://www.npr.org/2021/10/05/1043211171/facebook-instagram-whatsapp-outage-business-impact) en octobre 2021, coupant les utilisateurs de la plateforme.
+Les plateformes de réseaux sociaux traditionnels se fondent sur des bases de données pour stocker des informations sur l’utilisateur, le code du programme et d’autres formes de données. Mais cela crée des points de vulnérabilité et comporte des risques significatifs. Par exemple, les serveurs de Facebook ont été notoirement [hors ligne pendant des heures](https://www.npr.org/2021/10/05/1043211171/facebook-instagram-whatsapp-outage-business-impact) en octobre 2021, coupant l'accès des utilisateurs à la plateforme.
 
-Les réseaux sociaux décentralisés existent sur un [réseau pair à pair](/glossary/#peer-to-peer-network) regroupant des milliers de nœuds à travers le monde. Même si certains nœuds se coupent, le réseau fonctionnera sans interruption, rendant les applications résistantes aux pannes et aux défaillances.
+Les réseaux sociaux décentralisés existent sur un [réseau pair à pair](/glossary/#peer-to-peer-network) comprenant des milliers de nœuds dans le monde entier. Même si certains nœuds se coupent, le réseau fonctionnera sans interruption, rendant les applications résistantes aux pannes et aux défaillances.
 
-En utilisant des systèmes de stockage décentralisés comme [le système de fichiers interplanétaires (IPFS)](https://ipfs.io/), les réseaux sociaux basés sur Ethereum peuvent protéger les informations des utilisateurs contre l'exploitation et l'utilisation malveillante de leurs données. Personne ne vendra vos informations personnelles à des annonceurs, et les pirates informatiques ne pourront pas non plus voler vos informations confidentielles.
+En utilisant des systèmes de stockage décentralisés comme [l'InterPlanetary File System (IPFS)](https://ipfs.io/), les réseaux sociaux basés sur Ethereum peuvent protéger les informations des utilisateurs contre l'exploitation et l'utilisation malveillante. Personne ne vendra vos informations personnelles à des annonceurs, et les pirates informatiques ne pourront pas non plus voler vos informations confidentielles.
 
 De nombreuses plateformes de réseaux sociaux basées sur la blockchain ont des tokens natifs qui alimentent la monétisation en l'absence de revenus publicitaires. Les utilisateurs peuvent acheter ces tokens pour accéder à certaines fonctionnalités, effectuer des achats dans l'application ou donner des conseils à leurs créateurs de contenu préférés.
 
-## Les avantages des réseaux sociaux décentralisés {#benefits}
+## Avantages des réseaux sociaux décentralisés {#benefits}
 
-1. Les réseaux sociaux décentralisés sont résistants à la censure et ouverts à tous. Cela signifie que **les utilisateurs ne peuvent pas** être bannis, restreints ou censurés de manière arbitraire.
+1. Les réseaux sociaux décentralisés sont résistants à la censure et ouverts à tous. Cela signifie que **les utilisateurs ne peuvent pas être bannis**, déplateformés ou restreints de manière arbitraire.
 
-2. Les réseaux sociaux décentralisés sont **construits en open-source** et rendent le code source des applications visible afin de le vérifier. En éliminant l'implémentation d'algorithmes opaques communs aux réseaux sociaux traditionnels, les réseaux sociaux basés sur la blockchain peuvent aligner les intérêts des utilisateurs et des créateurs de plateformes.
+2. Les réseaux sociaux décentralisés sont **construits sur les idéaux de l'open-source** et rendent le code source des applications disponible pour une inspection publique. En éliminant l'implémentation d'algorithmes opaques communs aux réseaux sociaux traditionnels, les réseaux sociaux basés sur la blockchain peuvent aligner les intérêts des utilisateurs et des créateurs de plateformes.
 
-3. Les réseaux sociaux décentralisés éliminent les « intermédiaires ». Les **créateurs de contenu ont une propriété directe sur leur contenu**, et s'engage directement auprès des abonnés, des fans, des acheteurs, et d'autres parties, avec rien d'autre qu'un contrat intelligent entre eux.
+3. Les réseaux sociaux décentralisés éliminent les « intermédiaires ». Les **créateurs de contenu ont la propriété directe de leur contenu**, et ils interagissent directement avec leurs abonnés, fans, acheteurs et autres parties, avec rien d'autre qu'un contrat intelligent entre eux.
 
-4. En tant que DApps fonctionnant sur le réseau Ethereum, qui est soutenu par un réseau mondial pair à pair de nœuds, les réseaux sociaux décentralisés sont **moins sensibles aux arrêts de serveur** et aux interruptions.
+4. En tant que dapps fonctionnant sur le réseau Ethereum, qui est soutenu par un réseau mondial de nœuds pair à pair, les réseaux sociaux décentralisés sont **moins sujets aux temps d'arrêt des serveurs** et aux pannes.
 
-5. Les plateformes sociales décentralisées offrent un cadre de **monétisation amélioré** pour les créateurs de contenu par le biais de [jetons non-fongibles (NFT)](/glossary/#nft), des paiements en crypto-monnaies dans l'application et bien davantage.
+5. Les plateformes sociales décentralisées offrent un cadre de **monétisation améliorée** pour les créateurs de contenu via des [jetons non fongibles (NFT)](/glossary/#nft), des paiements en cryptomonnaies dans l'application, et plus encore.
 
-6. Les réseaux sociaux décentralisés offrent aux utilisateurs **un niveau élevé de respect de la vie privée et d'anonymat**. Par exemple, une personne peut se connecter à un réseau social basé sur Ethereum à l'aide d'un profil [d'ENS](/glossary/#ens) ou [d'un portefeuille](/glossary/#wallet) - sans avoir à partager des informations personnelles identifiables (PII), comme les noms, les adresses e-mail, etc.
+6. Les réseaux sociaux décentralisés offrent aux utilisateurs **un niveau élevé de confidentialité et d'anonymat**. Par exemple, un individu peut se connecter à un réseau social basé sur Ethereum en utilisant un profil [ENS](/glossary/#ens) ou un [portefeuille](/glossary/#wallet) — sans avoir à partager d'informations personnelles identifiables (PII), telles que des noms, des adresses e-mail, etc.
 
 7. Les réseaux sociaux décentralisés reposent sur un stockage décentralisé, et non sur des bases de données centralisées, ce qui est nettement mieux pour protéger les données des utilisateurs.
 
@@ -55,52 +55,86 @@ Le réseau Ethereum est devenu l'outil de prédilection des développeurs qui cr
 
 ### Mirror {#mirror}
 
-[Mirror](https://mirror.xyz/) est une plateforme de rédaction d'article compatible avec le Web3 qui vise à être décentralisée et détenue par les utilisateurs. Les utilisateurs peuvent lire et écrire gratuitement sur Mirror en connectant simplement leurs portefeuilles. Les utilisateurs peuvent également collecter des articles et s'abonner à leurs auteurs préférés.
+[Mirror](https://mirror.xyz/) est une plateforme d'écriture compatible Web3 qui vise à être décentralisée et détenue par les utilisateurs. Les utilisateurs peuvent lire et écrire gratuitement sur Mirror en connectant simplement leurs portefeuilles. Les utilisateurs peuvent également collecter des articles et s'abonner à leurs auteurs préférés.
 
-Les articles publiés sur Mirror sont stockés en permanence sur Arweave, une plate-forme de stockage décentralisée, et peuvent être frappés en tant que [jetons non fongibles (NFT) collectionnable](/nft/) connus sous le nom de Writing NFTs. La création des Writing NFTs est entièrement gratuite pour les auteurs, et la collection est stockée sur une [couche 2](/glossary/#layer-2) d'Ethereum — rendant les transactions peu coûteuses, rapides et écologiques.
+Les publications sur Mirror sont stockées en permanence sur Arweave, une plateforme de stockage décentralisée, et peuvent être frappées en tant que [jetons non fongibles (NFT)](/nft/) à collectionner, connus sous le nom de Writing NFTs. La création de Writing NFTs est entièrement gratuite pour les auteurs, et la collection se fait sur une [couche 2 (L2)](/glossary/#layer-2) d'Ethereum — ce qui rend les transactions peu coûteuses, rapides et respectueuses de l'environnement.
 
 ### MINDS {#minds}
 
 [MINDS](https://www.minds.com/) est l'un des réseaux sociaux décentralisés les plus utilisés. Il fonctionne comme Facebook et a déjà rassemblé des millions d’utilisateurs.
 
-Les utilisateurs utilisent le jeton [ERC-20](/glossary/#erc-20) natif de la plateforme $MIND pour payer des items. Les utilisateurs peuvent également gagner des jetons $MIND en publiant du contenu populaire, en contribuant à l'écosystème et en amenant d'autres personnes sur la plateforme.
+Les utilisateurs utilisent le jeton natif [ERC-20](/glossary/#erc-20) de la plateforme, $MIND, pour payer des articles. Les utilisateurs peuvent également gagner des jetons $MIND en publiant du contenu populaire, en contribuant à l'écosystème et en amenant d'autres personnes sur la plateforme.
+
+### Farcaster {#farcaster}
+
+[Farcaster](https://farcaster.xyz/) est un réseau social "suffisamment décentralisé" similaire à X et Reddit qui permet aux utilisateurs de partager et de découvrir des "casts". Il est construit sur le réseau L2 Optimism pour que les transactions restent relativement peu coûteuses.
 
 ## Utiliser les réseaux sociaux décentralisés {#use-decentralized-social-networks}
 
-- **[Status](https://status.im/)** - _Status est une application de messagerie sécurisée qui utilise un code open source, un protocole peer-to-peer et un chiffrement de bout en bout pour protéger vos messages contre des tiers._
-- **[Mirror.xyz](https://mirror.xyz/)** - _Mirror est une plateforme de publication, détenue par les utilisateurs, décentralisée et basée sur Ethereum pour permettre aux utilisateurs de financer des projets, de monétiser du contenu et de construire des communautés de grande valeur._
-- **[Lens Protocol](https://lens.xyz/)** - _Lens Protocol est un graphe social décentralisé et modulaire qui aide les créateurs à prendre en main leur contenu où qu'ils aillent dans le jardin numérique de l'internet décentralisé._
-- **[Farcaster](https://farcaster.xyz/)** - _Farcaster est un réseau social suffisamment décentralisé. C'est un protocole ouvert qui peut supporter de nombreux clients, tout comme l'e-mail._
+- **[Status.app](https://status.app/)** - _Status est une application de messagerie sécurisée qui utilise un protocole open-source pair à pair et un chiffrement de bout en bout pour protéger vos messages des tiers._
+- **[Mirror.xyz](https://mirror.xyz/)** - _Mirror est une plateforme de publication décentralisée, détenue par les utilisateurs et basée sur Ethereum pour que les utilisateurs puissent financer des idées par le financement participatif, monétiser du contenu et créer des communautés de grande valeur._
+- **[Lens Protocol](https://lens.xyz/)** - _Lens Protocol est un graphe social composable et décentralisé qui aide les créateurs à s'approprier leur contenu où qu'ils aillent dans le jardin numérique de l'Internet décentralisé._
+- **[Farcaster](https://farcaster.xyz/)** - _Farcaster est un réseau social suffisamment décentralisé._ C'est un protocole ouvert qui peut supporter de nombreux clients, tout comme l'e-mail._
+- **[Ethereum Follow Protocol](https://efp.app/)** - _L'Ethereum Follow Protocol est un graphe social en chaîne entièrement décentralisé pour les comptes Ethereum, qui fait progresser la vision d'une pile d'identité Ethereum modulaire, en complément de l'ENS et de SIWE._
+- **[Ethereum Comments Protocol](https://www.ethcomments.xyz/)** - _Une nouvelle primitive de contenu social programmable sur Ethereum pour mettre vos pensées en chaîne._
+
+## Réseaux sociaux Web2 sur Ethereum {#web2-social-networks-and-ethereum}
+
+Les plateformes sociales natives [Web3](/glossary/#web3) ne sont pas les seules à essayer d'intégrer la technologie blockchain dans les médias sociaux. De nombreuses plateformes centralisées explorent ou ont déjà expérimenté l’intégration d’Ethereum dans leur infrastructure :
+
+### Navigateur Brave {#brave}
+
+- Brave a intégré le **[Basic Attention Token (BAT)](https://basicattentiontoken.org/)**, un jeton ERC-20 basé sur Ethereum, dans l'écosystème de son navigateur pour révolutionner la publicité numérique et le soutien aux créateurs de contenu.
+
+- Le programme **[Brave Rewards](https://brave.com/brave-rewards/)** permet aux utilisateurs de gagner des BAT en visionnant des publicités respectueuses de la vie privée, puis de contribuer automatiquement aux sites Web et aux créateurs de contenu sur diverses plateformes comme YouTube, Twitter et GitHub, en fonction du temps d'attention.
+
+- Les créateurs de contenu peuvent s'inscrire en tant que **[créateurs vérifiés Brave](https://creators.brave.com/)** pour recevoir ces contributions directement dans leurs portefeuilles Ethereum, créant un pont entre les plateformes Web traditionnelles et la monétisation basée sur la blockchain.
+
+- Les jetons BAT existent indépendamment sur la blockchain Ethereum, ce qui permet aux utilisateurs de les transférer sur des portefeuilles personnels ou des plateformes d'échange une fois gagnés.
+
+### Plateforme de musique Audius {#audius}
+
+- **[Audius](https://audius.co/)** est une plateforme de streaming musical qui utilise la technologie de la blockchain Ethereum pour connecter directement les artistes avec leurs fans.
+
+- La plateforme présente une architecture décentralisée hybride où le contenu est stocké sur IPFS, tout en utilisant la blockchain pour les droits de propriété et le **[jeton AUDIO](https://eth.blockscout.com/token/0x18aaa7115705e8be94bffebde57af9bfc265b998)**.
+
+- Audius a établi un **[partenariat avec TikTok](https://audius.co/tiktok)**, apportant la fonctionnalité Web3 au grand public et permettant aux artistes de monétiser leur contenu grâce à la technologie blockchain.
+
+- Les détails techniques de la plateforme sont disponibles dans son **[livre blanc](https://whitepaper.audius.co/)**, qui montre comment elle s'est construite sur l'infrastructure d'Ethereum.
+
+### Sports de fantaisie Sorare {#sorare}
+
+- **[Sorare](https://sorare.com/)** est une **[plateforme de sports de fantaisie construite sur Ethereum](https://sorare.com/help/a/4402888626577/what-is-a-sorare-wallet)** qui permet aux utilisateurs de collectionner, d'échanger et de jouer avec des cartes de joueur NFT officielles.
 
-## Les réseaux sociaux Web2 sur Ethereum {#web2-social-networks-and-ethereum}
+- Les cartes de joueur sont des NFT vérifiables sur la blockchain Ethereum, et les contrats intelligents de la plateforme peuvent être consultés sur **[Etherscan](https://eth.blockscout.com/address/0x629a673a8242c2ac4b7b8c5d8735fbeac21a6205?tab=contract)**.
 
-Les plateformes sociales Web natives [Web3](/glossary/#web3) ne sont pas les seules à essayer d'intégrer la technologie blockchain dans leurs réseaux sociaux. De nombreuses plates-formes centralisées prévoient également d'intégrer Ethereum dans leur infrastructure :
+- Sorare combine le gameplay traditionnel des sports de fantaisie avec la propriété sur la blockchain d'actifs numériques, apportant la fonctionnalité de **[financement par Ethereum](https://sorare.com/help/a/10969733392797/what-network-should-i-use-to-fund-my-eth-wallet)** aux fans de sport grand public.
 
-### Reddit {#reddit}
+### Twitter/X (pourboires en cryptomonnaies) {#twitter}
 
-Reddit a [utilisé les Points Communautaires](https://cointelegraph.com/news/reddit-to-reportedly-tokenize-karma-points-and-onboard-500m-new-users), qui sont des jetons ERC-20 que les utilisateurs peuvent gagner en publiant du contenu de qualité et en apportant des contributions dans les communautés en ligne (subreddits). Vous pouvez échanger ces jetons dans un subreddit pour obtenir des privilèges et des avantages exclusifs. Pour ce projet, Reddit travaille avec Arbitrum, un réseau [layer 2](/glossary/#layer-2) conçu pour mettre à l'échelle les transactions Ethereum.
+**[Twitter](https://x.com)** (maintenant X) a intégré la technologie blockchain de multiples façons pour améliorer la monétisation des créateurs et la vérification de l'identité numérique :
 
-Le programme est déjà en ligne, avec le subreddit r/CryptoCurrency [exécutant sa version de Points Communautaires appelée « Moons »](https://www.reddit.com/r/CryptoCurrency/wiki/moons_wiki). Par description officielle, Moons « récompensent les affichages, les commentaires, et les modérateurs pour leurs contributions au subreddit ». Parce que ces jetons sont sur la blockchain (les utilisateurs les reçoivent dans des portefeuilles), ils sont indépendants de Reddit et ne peuvent pas être retirés.
+- **Pourboires en cryptomonnaies** : la plateforme a intégré les **[pourboires en Ethereum](https://help.x.com/en/using-x/tips)**, permettant aux utilisateurs d'envoyer des paiements via des portefeuilles basés sur Ethereum comme Strike.
 
-En plus d'utiliser des Points Communautaires pour débloquer des fonctionnalités spéciales, les utilisateurs peuvent également les échanger contre des monnaies officielles. De plus, le nombre de Points Communautaires qu'un utilisateur possède détermine son influence sur le processus décisionnel au sein de la communauté.
+En intégrant les fonctionnalités de la blockchain, X comble le fossé entre les expériences sociales du Web2 et la propriété numérique décentralisée.
 
-## Lectures additionnelles {#further-reading}
+## En savoir plus {#further-reading}
 
 ### Articles {#articles}
 
-- [Décentralisation des réseaux sociaux : guide relatif à la pile sociale du web3](https://www.coinbase.com/blog/decentralizing-social-media-a-guide-to-the-web3-social-stack) - _Coinbase Ventures_
-- [Social Networks Are the Next Big Decentralization Opportunity](https://www.coindesk.com/tech/2021/01/22/social-networks-are-the-next-big-decentralization-opportunity/) — _Ben Goertzel_
-- [Web3 holds the promise of decentralized, community-powered social networks](https://venturebeat.com/2022/02/26/web3-holds-the-promise-of-decentralized-community-powered-social-networks/) — _Sumit Ghosh_
-- [An Overview of the Blockchain Social Media Landscape](https://www.gemini.com/cryptopedia/blockchain-social-media-decentralized-social-media) — _Gemini Cryptopedia_
-- [How Blockchain Can Solve Social Media Privacy](https://www.investopedia.com/news/ethereum-blockchain-social-media-privacy-problem-linkedin-indorse/) — _Prableen Bajpai_
-- [Décentralisation suffisante pour les réseaux sociaux](https://www.varunsrinivasan.com/2022/01/11/sufficient-decentralization-for-social-networks) — _Varun Srinivasan_
+- [Décentraliser les médias sociaux : un guide de la pile sociale web3](https://www.coinbase.com/blog/decentralizing-social-media-a-guide-to-the-web3-social-stack) - _Coinbase Ventures_
+- [Les réseaux sociaux sont la prochaine grande opportunité de décentralisation](https://www.coindesk.com/tech/2021/01/22/social-networks-are-the-next-big-decentralization-opportunity/) — _Ben Goertzel_
+- [Le Web3 est la promesse de réseaux sociaux décentralisés et communautaires](https://venturebeat.com/2022/02/26/web3-holds-the-promise-of-decentralized-community-powered-social-networks/) — _Sumit Ghosh_
+- [Un aperçu du paysage des médias sociaux sur la blockchain](https://www.gemini.com/cryptopedia/blockchain-social-media-decentralized-social-media) — _Gemini Cryptopedia_
+- [Comment la blockchain peut résoudre le problème de la confidentialité sur les médias sociaux](https://www.investopedia.com/news/ethereum-blockchain-social-media-privacy-problem-linkedin-indorse/) — _Prableen Bajpai_
+- [Une décentralisation suffisante pour les réseaux sociaux](https://www.varunsrinivasan.com/2022/01/11/sufficient-decentralization-for-social-networks) — _Varun Srinivasan_
 
 ### Vidéos {#videos}
 
-- [Decentralized Social Media Explained](https://www.youtube.com/watch?v=UdT2lpcGvcQ) — _Coinmarketcap_
-- [DeSo Blockchain Wants to Decentralize Social Media](https://www.youtube.com/watch?v=SG2HUiVp0rE) — _Bloomberg Technology_
-- [The Future of Decentralized Social Media w/ Balaji Srinivasan, Vitalik Buterin, Juan Benet](https://www.youtube.com/watch?v=DTxE9KV3YrE) — _ETHGlobal_
+- [Explication des médias sociaux décentralisés](https://www.youtube.com/watch?v=UdT2lpcGvcQ) — _Coinmarketcap_
+- [La blockchain DeSo veut décentraliser les médias sociaux](https://www.youtube.com/watch?v=SG2HUiVp0rE) — _Bloomberg Technology_
+- [L'avenir des médias sociaux décentralisés avec Balaji Srinivasan, Vitalik Buterin et Juan Benet](https://www.youtube.com/watch?v=DTxE9KV3YrE) — _ETHGlobal_
 
 ### Communautés {#communities}
 
-- [r/CryptoMonnaie subreddit](https://www.reddit.com/r/CryptoCurrency/)
+- [Subreddit r/CryptoCurrency](https://www.reddit.com/r/CryptoCurrency/)
diff --git a/public/content/translations/fr/staking/dvt/index.md b/public/content/translations/fr/staking/dvt/index.md
index fc3d4488eca..05a8058d563 100644
--- a/public/content/translations/fr/staking/dvt/index.md
+++ b/public/content/translations/fr/staking/dvt/index.md
@@ -1,16 +1,16 @@
 ---
-title: Technologie de Validation Distribuée (DVT)
-description: La technologie de validation distribuée (DVT) ou Distributed validator technology, permet le fonctionnement distribué d'un validateur Ethereum par plusieurs entités.
+title: "Technologie de Validation Distribuée (DVT)"
+description: "La technologie de validation distribuée (DVT) ou Distributed validator technology, permet le fonctionnement distribué d'un validateur Ethereum par plusieurs entités."
 lang: fr
 ---
 
-# Technologie de Validation Distribuée (DVT) {#distributed-validator-technology}
+# Technologie de validateur distribué {#distributed-validator-technology}
 
 La Technologie de validation distribuée (DVT) est une approche à la sécurité des validateurs répartissant la gestion des clés et les responsabilités de signature multipartites, dans le but de réduire les points de défaillance uniques et d'augmenter la résilience des validateurs.
 
-La DVT l'accomplit** en divisant la clé privée** utilisée pour sécuriser un validateur** parmi de nombreux ordinateurs** organisés en "cluster". Ce qui présente l'avantage de rendre très compliqué pour les commanditaires d'attaques de pouvoir accéder à la clé, celle-ci n'étant pas stockée intégralement sur une seule et même machine. Ça permet aussi à certains nœuds de se déconnecter, car la nécessité de signature peut être effectuée par un sous-ensemble des machines dans chaque cluster. Ce qui réduit également les points de défaillance uniques provenant du réseau et rend l'ensemble du groupe de validateurs bien plus robuste.
+Pour ce faire, elle **divise la clé privée** utilisée pour sécuriser un validateur **entre plusieurs ordinateurs** organisés en un "cluster". Ce qui présente l'avantage de rendre très compliqué pour les commanditaires d'attaques de pouvoir accéder à la clé, celle-ci n'étant pas stockée intégralement sur une seule et même machine. Ça permet aussi à certains nœuds de se déconnecter, car la nécessité de signature peut être effectuée par un sous-ensemble des machines dans chaque cluster. Ce qui réduit également les points de défaillance uniques provenant du réseau et rend l'ensemble du groupe de validateurs bien plus robuste.
 
-![Un schéma illustrant la façon dont une clé de validateur unique est divisée en fragments, puis distribuée à plusieurs nœuds ayant des composants variables.](./dvt-cluster.png)
+![Un schéma montrant comment une clé de validateur unique est divisée en partages de clé et distribuée à plusieurs nœuds avec des composants variables.](./dvt-cluster.png)
 
 ## Pourquoi avons-nous besoin de la Technologie de validation distribuée (DVT) ? {#why-do-we-need-dvt}
 
@@ -20,9 +20,10 @@ Les validateurs génèrent deux paires de clés publique-privée : les clés du
 
 En utilisant la Technologie DVT, les validateurs peuvent participer au jalonnement tout en conservant la clé-privée-validateur dans un stockage à froid. Ce processus est établi en encryptant la clé originale complète d'un validateur puis divise cette dernière en parts de clé. Les fragments de clé demeurent en ligne et distribués par de multiples nœuds, ce qui permet le fonctionnement distribué du validateur. C'est possible car les validateurs Ethereum utilisent des signatures BLS qui sont additives, ce qui signifie que la clé entière peut être reconstituée en additionnant leurs composants. Ça permet au participant de maintenir hors-ligne et en toute sécurité, la clé de validation du master original.
 
-### Zéro point de défaillance unique {#no-single-point-of-failure}
+### Aucun point de défaillance unique {#no-single-point-of-failure}
 
-Lorsqu'un validateur est réparti parmi de multiples opérateurs et machines, il peut résister aux défaillances individuelles du matériel (hardware et logiciels) sans se déconnecter. Le risque de défaillances peut aussi être réduit en utilisant des configurations matérielles et logicielles diverses sur les nœuds d'un cluster. Cette résilience est indisponible aux configurations de validateurs à nœud simple - qui découle de la couche DVT.
+Lorsqu'un validateur est réparti parmi de multiples opérateurs et machines, il peut résister aux défaillances individuelles du matériel (hardware et logiciels) sans se déconnecter.
+Le risque de défaillances peut aussi être réduit en utilisant des configurations matérielles et logicielles diverses sur les nœuds d'un cluster. Cette résilience est indisponible aux configurations de validateurs à nœud simple - qui découle de la couche DVT.
 
 Si l'un des composants d'une machine au sein d'un cluster tombe en panne (exemple : s'il y a quatre opérateurs dans un cluster de validateurs et que l'un d'eux utilise un client spécifique qui présente un bug), les autres veillent à ce que le validateur continue de fonctionner normalement.
 
@@ -32,33 +33,33 @@ Le scénario idéal pour Ethereum est de posséder le plus grand nombre de valid
 
 Sans la Technologie DVT, il est plus facile pour les fournisseurs d'actifs de ne prendre en charge qu'une ou deux configurations client pour l'ensemble de leurs validateurs, accroissant ainsi l'impact d'un bug client. La technologie (DVT) peut être utilisée pour répandre le risque autour de multiples configurations client et différentes machines (hardware), créant une certaine résilience à travers le biais de la diversité.
 
-**La technologie DVT offre à Ethereum les avantages suivants : **
+**La DVT offre les avantages suivants à Ethereum :**
 
-1. **Décentralisation** du consensus à Preuve d'enjeu d'Ethereum
-2. Assurer la** disponibilité continue** du réseau
-3. Établir une tolérance aux défaillances validateur
-4. **Confiance minime**de l'opération validateur
-5. **Minimiser les risques** de sanctions et d'interruptions
-6. **Améliorer la diversité**(client, centre de données, lieu, régulation, etc.)
-7. **Renforcer la sécurité** du management des clés-validateur
+1. **Décentralisation** du consensus de preuve d'enjeu d'Ethereum
+2. Assure la **vivacité** du réseau
+3. Crée une **tolérance aux pannes** pour le validateur
+4. **Fonctionnement du validateur** à **confiance minimisée**
+5. **Risques de délestage** et de temps d'arrêt **minimisés**
+6. **Améliore la diversité** (client, centre de données, emplacement, réglementation, etc.)
+7. **Sécurité renforcée** de la gestion des clés de validateur
 
 ## Comment fonctionne la Technologie de validation distribuée (DVT) ? {#how-does-dvt-work}
 
 Une solution DVT contient les éléments suivants :
 
-- **[Le partage secret de Shamir](https://medium.com/@keylesstech/a-beginners-guide-to-shamir-s-secret-sharing-e864efbf3648)** - Validateurs utilisant [des clés BLS](https://en.wikipedia.org/wiki/BLS_digital_signature). Les partages individuels de clés BLS (key shares) peuvent être combinés en une seule clé agrégée (signature). Dans la Technologie de validation distribuée (DVT), la clé privée d'un validateur est la combinaison de signatures BLS de chaque opérateur à l'intérieur du cluster.
-- **Seuil du schéma de signature** - Détermine le nombre de partages de clés individuelles requis au sujet des droits de signature. Exemple : 3 sur 4.
-- **Génération de clés distribuées (DKG)** - Processus cryptographique qui génère les partages de clé, puis utilisé à distribuer les partages d'une clé de validateur nouvelle ou déjà existante à l'endroit des nœuds d'un cluster.
-- **[Calcul multipartite (MPC)](https://messari.io/report/applying-multiparty-computation-to-the-world-of-blockchains)** - L'intégralité de la clé du validateur est générée de manière confidentielle via l'apport d'un calcul multipartite sécurisé. L'intégralité de la clé n'est jamais connue par aucun opérateur individuel : chaque opérateur n'a connaissance que de son propre fragment de clé (leur "part").
-- **Protocole de consensus** - Le protocole de consensus sélectionne un nœud qui deviendra le proposant de bloc. Ils partagent ledit bloc avec les autres nœuds du cluster, qui ajoutent leurs fragments de clé à la signature agrégée. Lorsque suffisamment de fragments de clé ont été agrégés, le bloc est proposé sur Ethereum.
+- **[Partage de secret de Shamir](https://medium.com/@keylesstech/a-beginners-guide-to-shamir-s-secret-sharing-e864efbf3648)** - Les validateurs utilisent des [clés BLS](https://en.wikipedia.org/wiki/BLS_digital_signature). Les partages individuels de clés BLS (key shares) peuvent être combinés en une seule clé agrégée (signature). Dans la Technologie de validation distribuée (DVT), la clé privée d'un validateur est la combinaison de signatures BLS de chaque opérateur à l'intérieur du cluster.
+- **[Schéma de signature à seuil](https://medium.com/nethermind-eth/threshold-signature-schemes-36f40bc42aca)** - Détermine le nombre de partages de clés individuels requis pour les tâches de signature, p. ex. 3 sur 4.
+- **[Génération de clés distribuées (DKG)](https://medium.com/toruslabs/what-distributed-key-generation-is-866adc79620)** - Processus cryptographique qui génère les partages de clé et est utilisé pour distribuer les partages d'une clé de validateur existante ou nouvelle aux nœuds d'un cluster.
+- **[Calcul multipartite (MPC)](https://messari.io/report/applying-multiparty-computation-to-the-world-of-blockchains)** - La clé de validateur complète est générée en secret à l'aide du calcul multipartite. L'intégralité de la clé n'est jamais connue par aucun opérateur individuel : chaque opérateur n'a connaissance que de son propre fragment de clé (leur "part").
+- **Protocole de consensus** - Le protocole de consensus sélectionne un nœud qui sera le proposant de bloc. Ils partagent ledit bloc avec les autres nœuds du cluster, qui ajoutent leurs fragments de clé à la signature agrégée. Lorsque suffisamment de fragments de clé ont été agrégés, le bloc est proposé sur Ethereum.
 
 Les validateurs distribués bénéficient d'une tolérance aux défaillances intégrées et peuvent continuer à fonctionner, et ce même, si certains des nœuds individuels demeurent hors-ligne. Il faut interpréter que le cluster est résistant, même si certains de ses nœuds s'avèrent être malveillants ou très peu actifs.
 
-## Cas d'utilisation de la Technologie de Validation Distribuée (DVT) {#dvt-use-cases}
+## Cas d'utilisation de la DVT {#dvt-use-cases}
 
 La DVT a des implications significatives pour l'ensemble de l'industrie du "staking" (verrouillage d'ETH dans le but de sécuriser la blockchain Ethereum) :
 
-### Mise en enjeu individuelle {#solo-stakers}
+### Validateurs solo {#solo-stakers}
 
 La technologie DVT permet également une participation non-custodienne (staking), en vous autorisant à distribuer votre clé de validateur à travers des nœuds distants, tout en conservant l'intégralité de la clé de manière totalement hors-ligne. Ce qui signifie que les participants individuels n'ont pas nécessairement besoin d'investir dans du matériel (hardware), tandis que la distribution des fragments de clé, peut aider à les renforcer contre d'éventuelles attaques (hack).
 
@@ -68,24 +69,24 @@ Les opérateurs comme les pools de staking (verrouillage d'actifs - ETH) ainsi q
 
 La technologie DVT partage la responsabilité de la gestion des clés entre plusieurs nœuds, entendant le fait que certains coûts opérationnels peuvent également être répartis. La technologie DVT peut aussi réduire les coûts opérationnels et d'assurance pour les fournisseurs d'actifs.
 
-### Les pools de mise en jeu {#staking-pools}
+### Pools de mise en jeu {#staking-pools}
 
 En raison des configurations standard des validateurs, les pools de staking et les fournisseurs de staking liquide, sont contraints à différents niveaux de confiance en un seul opérateur, depuis que gains et pertes sont partagés par l'ensemble du pool. Ils dépendent également des opérateurs afin de protéger les clés de signature, car jusqu'à présent, aucune autre option ne s'offrait à eux.
 
 Même si des efforts constants sont déployés pour diluer le risque en distribuant des participations entre plusieurs opérateurs, chaque opérateur gère toujours une part de verrouillage d'actifs (ETH) significative de façon indépendante. S'appuyer sur un seul opérateur présente des risques considérables, si celui-ci sous-performe, qu'il rencontre des périodes d'inactivité, qu'il est compromis, ou encore s'il agit par des actes malveillants.
 
-En optimisant la Technologie de validation distribuée (DVT), le niveau de confiance requis de la part des opérateurs s'en retrouve nettement réduit. **Les pools permettent entres autres aux opérateurs, de détenir des participations sans nécessiter la conservation des clés de validation** (seuls des fragments de clé sont utilisés). Ce qui permet de répartir les participations gérées entre plusieurs opérateurs (ex : au lieu d'avoir un opérateur unique administrant quelque 1000 validateurs, la technologie DVT permet auxdits validateurs d'être collectivement régentés par plusieurs opérateurs). Aussi, des configurations diverses d'opérateurs (validateurs) garantiront que si l'un des opérateurs rencontraient une faille technique, les autres garants du réseau pourraient toujours garantir l'attestation (processus de signature d'un bloc). Ce qui engendre une redondance et une diversification conduisant à de meilleures performances ajoutée à une plus grande résilience, tout en maximisant les récompenses.
+En optimisant la Technologie de validation distribuée (DVT), le niveau de confiance requis de la part des opérateurs s'en retrouve nettement réduit. **Les pools peuvent permettre aux opérateurs de détenir des mises sans avoir besoin de la garde des clés de validateur** (car seuls des partages de clés sont utilisés). Ce qui permet de répartir les participations gérées entre plusieurs opérateurs (ex : au lieu d'avoir un opérateur unique administrant quelque 1000 validateurs, la technologie DVT permet auxdits validateurs d'être collectivement régentés par plusieurs opérateurs). Aussi, des configurations diverses d'opérateurs (validateurs) garantiront que si l'un des opérateurs rencontraient une faille technique, les autres garants du réseau pourraient toujours garantir l'attestation (processus de signature d'un bloc). Ce qui engendre une redondance et une diversification conduisant à de meilleures performances ajoutée à une plus grande résilience, tout en maximisant les récompenses.
 
 L'autre avantage de minimiser la confiance en un seul opérateur, c'est que les pools de staking permettent une participation plus ouverte sans le consentement des autres opérateurs. En procédant ainsi, les acteurs peuvent réduire leur risque et soutenir la décentralisation d'Ethereum, en utilisant tout à la fois des ensembles d'opérateurs supervisés et ouverts, par exemple, en associant des fournisseurs d'actifs (Staking) individuels ou de moindre envergure à des acteurs plus importants.
 
-## Inconvénients possibles à l'utilisation de la Technologie de validation distribuée (DVT) {#potential-drawbacks-of-using-dvt}
+## Inconvénients potentiels de l'utilisation de la DVT {#potential-drawbacks-of-using-dvt}
 
-- **Composant additionnel** - L' introduction d'un nœud DVT ajoute une partie supplémentaire potentiellement défectueuse ou vulnérable. Une manière d'atténuer cette situation est de forcer plusieurs mises en œuvre d'un nœud DVT, c'est-à-dire plusieurs clients DVT (tout comme il existe plusieurs clients pour le consensus en lui-même et les couches d'exécution).
-- **Coûts opérationnels** - comme la technologie DVT distribue la validation de façon multipartite, davantage de nœuds sont requis pour le fonctionnement au lieu d'un nœud seul, ce qui génère des coûts liés à ce processus bien plus élevés.
-- **Possibilité d'une latence accrue** - étant donné que la technologie DVT utilise un protocole de consensus pour finaliser ledit consensus via les nœuds multiples exploitant un validateur ; ce qui peut entraîner une latence accrue possible.
+- **Composant supplémentaire** - L'introduction d'un nœud DVT ajoute une autre partie qui peut potentiellement être défectueuse ou vulnérable. Une manière d'atténuer cette situation est de forcer plusieurs mises en œuvre d'un nœud DVT, c'est-à-dire plusieurs clients DVT (tout comme il existe plusieurs clients pour le consensus en lui-même et les couches d'exécution).
+- **Coûts opérationnels** - comme la DVT distribue le validateur entre plusieurs parties, davantage de nœuds sont nécessaires pour le fonctionnement au lieu d'un seul, ce qui entraîne une augmentation des coûts d'exploitation.
+- **Latence potentiellement accrue** - puisque la DVT utilise un protocole de consensus pour parvenir à un consensus entre les multiples nœuds exploitant un validateur, elle peut potentiellement introduire une latence accrue.
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Spécificités des validateurs distribués d'Ethereum (niveau élevé)](https://github.com/ethereum/distributed-validator-specs)
-- [Spécificités techniques des validateurs distribués d'Ethereum](https://github.com/ethereum/distributed-validator-specs/tree/dev/src/dvspec)
-- [Application démo de partage de secret Shamir](https://iancoleman.io/shamir/)
+- [Spécifications du validateur distribué d'Ethereum (de haut niveau)](https://github.com/ethereum/distributed-validator-specs)
+- [Spécifications techniques du validateur distribué d'Ethereum](https://github.com/ethereum/distributed-validator-specs/tree/dev/src/dvspec)
+- [Application de démonstration du partage de secret de Shamir](https://iancoleman.io/shamir/)
diff --git a/public/content/translations/fr/staking/pools/index.md b/public/content/translations/fr/staking/pools/index.md
index 263b4a599cd..285ba97bd20 100644
--- a/public/content/translations/fr/staking/pools/index.md
+++ b/public/content/translations/fr/staking/pools/index.md
@@ -1,11 +1,11 @@
 ---
-title: Mise en jeu mutualisée
-description: Un aperçu de la façon de débuter avec la mise en jeu d'ETH mutualisée
+title: "Mise en jeu mutualisée"
+description: En savoir plus sur les pools de mise en jeu
 lang: fr
 template: staking
 emoji: ":money_with_wings:"
 image: /images/staking/leslie-pool.png
-alt: Leslie le rhinocéros nage dans la piscine.
+alt: "Leslie le rhinocéros nage dans la piscine."
 sidebarDepth: 2
 summaryPoints:
   - Misez et gagnez des récompenses avec n'importe quel montant d'ETH en joignant vos forces à celles des autres
@@ -17,21 +17,21 @@ summaryPoints:
 
 Les groupes d'enjeux offrent une approche collaborative permettant à de nombreuses personnes ayant de petites quantités d'ETH de rassembler les 32 ETH nécessaires pour activer un jeu de clés de validateur. Le concept de groupes d'enjeux n'est pas pris en charge de manière native par le protocole. Des solutions ont donc été élaborées séparément pour répondre à ce besoin.
 
-Certains pools fonctionnent à l'aide de contrats intelligents, dans lesquels les fonds peuvent être déposés. Ceux-ci gèrent et suivent votre mise en jeu sans intermédiaire de confiance, et vous remettent un jeton représentant la valeur de votre mise. D'autres pools n'utilisent pas de contrats intelligents et sont, au contraire, gérés hors chaîne.
+Certains pools fonctionnent à l'aide de contrats intelligents, dans lesquels les fonds peuvent être déposés. Ceux-ci gèrent et suivent votre mise en jeu sans intermédiaire de confiance, et vous remettent un jeton représentant la valeur de votre mise. D'autres pools n'utilisent pas de contrats intelligents et sont, au contraire, gérés hors de la blockchain.
 
-## Pourquoi miser via un pool ? {#why-stake-with-a-pool}
+## Pourquoi miser via un pool ? Pourquoi miser via un pool ? {#why-stake-with-a-pool}
 
-En plus des avantages que nous avons décrits dans notre [introduction à la mise en jeu](/staking/), la mise en jeu mutualisée offre un certain nombres d'avantages spécifiques.
+En plus des avantages que nous avons décrits dans notre [introduction à la mise en jeu](/staking/), la mise en jeu mutualisée offre un certain nombre d'avantages distincts.
 
 <CardGrid>
-  <Card title="Barrière faible à l’entrée" emoji="🐟" description="Not a whale? No problem. Most staking pools let you stake virtually any amount of ETH by joining forces with other stakers, unlike staking solo which requires 32 ETH." />
-  <Card title="La mise en jeu aujourd'hui" emoji=":stopwatch:" description="Staking with a pool is as easy as a token swap. No need to worry about hardware setup and node maintenance. Pools allow you to deposit your ETH which enables node operators to run validators. Rewards are then distributed to contributors minus a fee for node operations." />
-  <Card title="Jetons de staking" emoji=":droplet:" description="Many staking pools provide a token that represents a claim on your staked ETH and the rewards it generates. This allows you to make use of your staked ETH, e.g., as collateral in DeFi applications." />
+  <Card title="Facile d'accès" emoji="🐟" description="Pas une baleine ? Aucun problème. La plupart des pools de staking vous permettent de staker quasiment n'importe quel montant d'ETH en vous associant à d'autres stakers, contrairement au staking en solo qui nécessite 32 ETH." />
+  <Card title="Stakez dès aujourd'hui" emoji=":stopwatch:" description="Staker avec un pool est aussi simple qu'un échange de jetons. Pas besoin de vous soucier de la configuration matérielle et de la maintenance des nœuds. Les pools vous permettent de déposer vos ETH, ce qui permet aux opérateurs de nœuds de faire fonctionner des validateurs. Les récompenses sont ensuite distribuées aux contributeurs, moins des frais pour les opérations de nœuds." />
+  <Card title="Jetons de staking" emoji=":droplet:" description="De nombreux pools de staking fournissent un jeton qui représente un droit sur vos ETH stakés et les récompenses qu'ils génèrent. Cela vous permet d'utiliser vos ETH stakés, par exemple, comme garantie dans les applications DeFi." />
 </CardGrid>
 
 <StakingComparison page="pools" />
 
-## Éléments importants {#what-to-consider}
+## Points à considérer {#what-to-consider}
 
 La mise en jeu mutualisée ou déléguée n'est pas prise en charge nativement par le protocole Ethereum, mais compte tenu de la demande des utilisateurs de miser moins de 32 ETH, un nombre croissant de solutions ont été construites pour répondre à cette demande.
 
@@ -45,33 +45,33 @@ Les indicateurs d'attributs sont utilisés ci-dessous pour signaler des forces o
 
 <StakingConsiderations page="pools" />
 
-## Explorez les pools de mise en jeu {#explore-staking-pools}
+## Explorer les pools de mise en jeu {#explore-staking-pools}
 
-De nombreuses options sont disponible pour vous aider dans votre configuration. Utilisez les indicateurs ci-dessus pour vous guider à travers les outils ci-dessous.
+Il existe une variété d'options disponibles pour vous aider dans votre configuration. Utilisez les indicateurs ci-dessus pour vous guider à travers les outils ci-dessous.
 
 <ProductDisclaimer />
 
 <StakingProductsCardGrid category="pools" />
 
-Veuillez noter l'importance de choisir un service qui prend au sérieux [la diversité des clients](/developers/docs/nodes-and-clients/client-diversity/) , car elle améliore la sécurité du réseau et limite vos risques. Les services prouvant que l'utilisation d'un client majoritaire est limitée sont indiqués avec <em style={{ textTransform: "uppercase" }}>"diversité des clients d'exécution"</em> et <em style={{ textTransform: "uppercase" }}>"diversité des clients de consensus."</em>
+Veuillez noter l'importance de choisir un service qui prend au sérieux la [diversité des clients](/developers/docs/nodes-and-clients/client-diversity/), car elle améliore la sécurité du réseau et limite vos risques. Les services limitent l'émergence d'un client majoritaire sont indiqués avec <em style={{ textTransform: "uppercase" }}>"diversité des clients d'exécution"</em> et <em style={{ textTransform: "uppercase" }}>"diversité des clients de consensus"</em>.
 
-Vous souhaitez suggérer un outil de mise en jeu que nous avons manqué ? Consultez notre [politique de liste de produits](/contributing/adding-staking-products/) pour voir s'il conviendrait, et le soumettre à examen.
+Vous souhaitez suggérer un outil de mise en jeu que nous avons manqué ? Consultez notre [politique de référencement de produits](/contributing/adding-staking-products/) pour voir si cela convient, et pour le soumettre à un examen.
 
-## Questions fréquemment posées {#faq}
+## Foire aux questions {#faq}
 
-<ExpandableCard title="Comment puis-je gagner des récompenses ?">
-Généralement, des jetons de mise en jeu RC-20 sont émis à destination des participants et représentent la valeur de leur ETH mis en jeu et, en sus, les récompenses. Gardez en mémoire que les différents pools distribueront des récompenses de mise en jeu à leurs utilisateurs selon des règles différentes, mais c'est un sujet général.
+<ExpandableCard title="Comment gagner des récompenses ?">
+Généralement, des jetons de mise en jeu ERC-20 sont émis à destination des participants et représentent la valeur de leur ETH mis en jeu et, en sus, les récompenses. Gardez en mémoire que les différents pools distribueront des récompenses de mise en jeu à leurs utilisateurs selon des règles différentes, mais c'est un sujet général.
 </ExpandableCard>
 
-<ExpandableCard title="Quand puis-je retirer ma mise?">
+<ExpandableCard title="Quand puis-je retirer ma mise ?">
 Et c'est déjà le cas ! La mise à niveau du réseau Shanghai/Capella a eu lieu en avril 2023 et a introduit des retraits de staking. Après cette mise à niveau, les comptes de validateur soutenant les pools de mise en jeu auront la possibilité de sortir et de retirer l'ETH à leur adresse de retrait désignée. Cela permet de racheter votre part de mise en jeu pour l'ETH. Vérifiez auprès de votre fournisseur de services pour savoir comment il supporte cette fonctionnalité.
 
 Alternativement, les pools qui utilisent les jetons de staking ERC-20 permettent à leurs utilisateurs d'échanger ce jeton sur le marché ouvert, vous permettant de vendre votre position de mise, en retirant sans pour autant supprimer l'ETH du contrat de staking.
 
-<ButtonLink href="/staking/withdrawals/">En savoir plus sur les retraits de mise en jeu.</ButtonLink>
+<ButtonLink href="/staking/withdrawals/">En savoir plus sur les retraits de mise en jeu</ButtonLink>
 </ExpandableCard>
 
-<ExpandableCard title="Est-ce différent de la mise en jeu via mon service d'échange ?">
+<ExpandableCard title="Est-ce différent du staking avec ma plateforme d'échange ?">
 Il existe de nombreuses similitudes entre ces options de mise en jeu mutualisée et les échanges centralisés, comme la capacité de mettre en jeu de petites quantités d'ETH et de les regrouper pour activer les validateurs.
 
 Contrairement aux plateformes d'échanges centralisés, beaucoup d'autres options de mise en jeu mutualisée utilisent des contrats intelligents et/ou des jetons de staking, qui sont habituellement des jetons ERC-20 pouvant être détenus dans votre propre portefeuille, et achetés ou vendus comme n'importe quel autre jeton. Cela vous offre une couche de souveraineté et de sécurité en vous donnant le contrôle de vos jetons, mais ne vous donne toujours pas de contrôle direct sur le client de validateur qui atteste en votre nom en arrière-plan.
@@ -79,8 +79,8 @@ Contrairement aux plateformes d'échanges centralisés, beaucoup d'autres option
 Certaines options de mise en commun sont plus décentralisées que d'autres concernant les nœuds qui les soutiennent. Pour promouvoir la santé et la décentralisation du réseau, les validateurs sont toujours encouragés à sélectionner un service de mutualisation offrant un ensemble décentralisé d'opérateurs de nœuds sans permission.
 </ExpandableCard>
 
-## Lectures complémentaires {#further-reading}
+## En savoir plus {#further-reading}
 
-- [L'Annuaire de la mise en jeu sur Ethereum.](https://www.staking.directory/) - _Eridian and Spacesider_
-- [Staking with Rocket Pool - Staking Overview](https://docs.rocketpool.net/guides/staking/overview.html) - _RocketPool docs_
-- [Staking Ethereum With Lido](https://help.lido.fi/en/collections/2947324-staking-ethereum-with-lido) - _Aide Lido docs_
+- [L'annuaire de la mise en jeu sur Ethereum](https://www.staking.directory/) - _Eridian et Spacesider_
+- [Mise en jeu avec Rocket Pool - Aperçu de la mise en jeu](https://docs.rocketpool.net/guides/staking/overview.html) - _Documentation de RocketPool_
+- [Mise en jeu d'Ethereum avec Lido](https://help.lido.fi/en/collections/2947324-staking-ethereum-with-lido) - _Documentation d'aide de Lido_
diff --git a/public/content/translations/fr/staking/saas/index.md b/public/content/translations/fr/staking/saas/index.md
index a96afdba3c6..23ec1beef65 100644
--- a/public/content/translations/fr/staking/saas/index.md
+++ b/public/content/translations/fr/staking/saas/index.md
@@ -1,11 +1,11 @@
 ---
 title: Mise en jeu en tant que service
-description: Un aperçu de la façon de débuter avec la mise en jeu ETH mutualisée
+description: En savoir plus sur le staking en tant que service
 lang: fr
 template: staking
 emoji: ":money_with_wings:"
 image: /images/staking/leslie-saas.png
-alt: Leslie le rhinocéros flottant dans les nuages.
+alt: "Leslie le rhinocéros flottant dans les nuages."
 sidebarDepth: 2
 summaryPoints:
   - Les opérateurs de nœuds tiers gèrent le fonctionnement de votre client de validateur
@@ -17,19 +17,19 @@ summaryPoints:
 
 Staking as a service ("la mise en jeu en tant que service, ou SaaS”) est une catégorie de services de mise en jeu au sein de laquelle vous déposez vos propres 32 ETH pour un validateur, mais déléguez les opérations de nœuds à un opérateur tiers. Ce processus implique généralement d'être guidé à travers la configuration initiale, y compris la génération de clés et le dépôt, puis de télécharger vos clés de signature à l'opérateur. Cela permet au service d'exploiter votre validateur en votre nom, généralement moyennant des frais mensuels.
 
-## Pourquoi miser via un service? {#why-stake-with-a-service}
+## Pourquoi miser via un service? Pourquoi miser via un service ? {#why-stake-with-a-service}
 
 Le protocole Ethereum ne soutient pas nativement la délégation de mise en jeu. Ces services ont donc été construits pour répondre à cette demande. Si vous avez 32 ETH à miser, mais que vous ne vous sentez pas à l'aise avec le matériel, les services SaaS vous permettent de déléguer la partie complexe pendant que vous gagnez des récompenses de bloc natif.
 
 <CardGrid>
-  <Card title="Votre propre validateur" emoji=":desktop_computer:" description="Deposit your own 32 ETH to activate your own set of signing keys that will participate in Ethereum consensus. Monitor your progress with dashboards to watch those ETH rewards accumulate." />
-  <Card title="Démarrage facile" emoji="🏁" description="Forget about hardware specs, setup, node maintenance and upgrades. SaaS providers let you outsource the hard part by uploading your own signing credentials, allowing them to run a validator on your behalf, for a small cost." />
-  <Card title="Limitez vos risques" emoji=":shield:" description="In many cases users do not have to give up access to the keys that enable withdrawing or transferring staked funds. These are different from the signing keys, and can be stored separately to limit (but not eliminate) your risk as a staker." />
+  <Card title="Votre propre validateur" emoji=":desktop_computer:" description="Déposez vos 32 ETH pour activer vos clés de signature qui participeront au consensus d'Ethereum. Suivez vos progrès sur des tableaux de bord pour voir vos récompenses en ETH s'accumuler." />
+  <Card title="Démarrage facile" emoji="🏁" description="Oubliez les spécifications matérielles, la configuration, la maintenance des nœuds et les mises à niveau. Les fournisseurs SaaS vous permettent d'externaliser la partie difficile en téléversant vos propres identifiants de signature, leur permettant d'exécuter un validateur en votre nom, pour un coût modique." />
+  <Card title="Limitez votre risque" emoji=":shield:" description="Dans de nombreux cas, les utilisateurs n'ont pas à renoncer à l'accès aux clés qui permettent de retirer ou de transférer les fonds mis en jeu. Celles-ci sont différentes des clés de signature et peuvent être stockées séparément pour limiter (mais pas éliminer) votre risque en tant que staker." />
 </CardGrid>
 
 <StakingComparison page="saas" />
 
-## Ce que vous devez prendre en compte {#what-to-consider}
+## Points à considérer {#what-to-consider}
 
 Il existe un nombre croissant de fournisseurs de services SaaS pour vous aider à miser votre ETH, mais chacun présente ses propres avantages et risques. Toutes les options SaaS requièrent des hypothèses de confiance supplémentaires par rapport à la mise en jeu individuelle depuis le domicile. Les options Saas peuvent contenir du code supplémentaire qui n'est ni ouvert ni auditable, pour les clients Ethereum. Le SaaS a également un effet préjudiciable sur la décentralisation du réseau. Selon la configuration, il se peut que vous ne contrôliez pas votre validateur - l'opérateur pourrait agir malhonnêtement en utilisant votre ETH.
 
@@ -47,49 +47,49 @@ Vous trouverez ci-dessous quelques fournisseurs SaaS disponibles. Utilisez les i
 
 <StakingProductsCardGrid category="saas" />
 
-Veuillez noter l'importance de choisir un service qui prend au sérieux [la diversité des clients](/developers/docs/nodes-and-clients/client-diversity/) , car elle améliore la sécurité du réseau et limite vos risques. Les services prouvant que l'utilisation d'un client majoritaire est limitée sont indiqués avec <em style={{ textTransform: "uppercase" }}>"diversité des clients d'exécution"</em> et <em style={{ textTransform: "uppercase" }}>"diversité des clients de consensus."</em>
+Veuillez noter l'importance de soutenir [la diversité des clients](/developers/docs/nodes-and-clients/client-diversity/), car cela améliore la sécurité du réseau et limite vos risques. Les services limitent l'émergence d'un client majoritaire sont indiqués avec <em style={{ textTransform: "uppercase" }}>"diversité des clients d'exécution"</em> et <em style={{ textTransform: "uppercase" }}>"diversité des clients de consensus"</em>.
 
 ### Générateurs de clés
 
 <StakingProductsCardGrid category="keyGen" />
 
-Avez-vous une suggestion concernant un fournisseur de mise en jeu en tant que service que nous avons manqué ? Consultez notre [politique de liste de produits](/contributing/adding-staking-products/) pour voir s'il conviendrait, et le soumettre à examen.
+Avez-vous une suggestion concernant un fournisseur de mise en jeu en tant que service que nous avons manqué ? Consultez notre [politique de référencement de produits](/contributing/adding-staking-products/) pour voir si cela convient, et pour le soumettre à un examen.
 
-## Questions fréquemment posées {#faq}
+## Foire aux questions {#faq}
 
-<ExpandableCard title="Qui détient mes clés?" eventCategory="SaasStaking" eventName="clicked who holds my keys">
+<ExpandableCard title="Qui détient mes clés ?" eventCategory="SaasStaking" eventName="clicked who holds my keys">
 Les dispositions varient d'un fournisseur à l'autre, mais en général, vous serez guidé à travers la configuration de toutes les clés de signature dont vous avez besoin (un par 32 ETH), afin de les télécharger à votre fournisseur et lui permettre de les valider en votre nom. Les clés de signature seules ne donnent aucune possibilité de retirer, de transférer ou de dépenser vos fonds. Cependant, elles donnent la possibilité de voter pour le consensus, ce qui, si ce n'est pas fait correctement, peut entraîner des pénalités de mise hors ligne ou de délestage.
 </ExpandableCard>
 
-<ExpandableCard title="Il y a donc deux jeux de clés ?" eventCategory="SaasStaking" eventName="clicked so there are two sets of keys">
+<ExpandableCard title="Alors, il y a deux jeux de clés ?" eventCategory="SaasStaking" eventName="clicked so there are two sets of keys">
 Oui. Chaque compte est composé à la fois de clés de <em>signature</em> BLS (Boneh-Lynn-Shachamet) et de clés de <em>retrait</em> BLS. Pour qu'un validateur puisse attester de l'état de la chaîne, participer à des comités de synchronisation et proposer des blocs, les clés de signature doivent être facilement accessibles par un client validateur. Celles-ci doivent être connectées à Internet sous une forme ou une autre, et sont donc par nature considérées comme des clés « chaudes ». Ceci est une exigence pour que votre validateur puisse attester. Par conséquent les clés utilisées pour transférer ou retirer des fonds sont séparées pour des raisons de sécurité.
 
 Les clés de retrait BLS sont utilisées pour signer un message unique qui indique à quel compte de couche d'exécution les récompenses de mise en jeu de compte et les fonds sortis doivent être envoyés. Une fois ce message diffusé, les clés de<em> retrait</em> BLS ne sont plus nécessaires. Au lieu de cela, le contrôle des fonds retirés est délégué de façon permanente à l'adresse que vous avez fournie. Cela vous permet de définir une adresse de retrait sécurisée via votre propre portefeuille de stockage à froid, minimisant le risque pour les fonds de votre validateur, même si quelqu'un d'autre contrôle les clés de signature de votre validateur.
 
 La mise à jour des identifiants de retrait est une étape nécessaire pour activer les retraits\*. Ce processus consiste à générer les clés de retrait en utilisant votre phrase de récupération mnémotechnique.
 
-<strong>Assurez-vous que vous que cette phrase de récupération soit sauvegardée en toute sécurité ou vous ne pourrez pas générer vos clés de retrait le moment venu.</strong>
+<strong>Assurez-vous de sauvegarder cette phrase de récupération en toute sécurité, ou vous ne pourrez pas générer vos clés de retrait le moment venu.</strong>
 
-Les stakers qui ont fourni une adresse de retrait avec le dépôt initial n'ont pas besoin de la définir. Consultez votre fournisseur SaaS pour obtenir une assistance sur la façon de préparer votre validateur.
+\*Les validateurs qui ont fourni une adresse de retrait lors du dépôt initial n'ont pas besoin de la définir. Consultez votre fournisseur SaaS pour obtenir une assistance sur la façon de préparer votre validateur.
 </ExpandableCard>
 
-<ExpandableCard title="Quand puis-je effectuer un retrait ?" eventCategory="SaasStaking" eventName="clicked when can I withdraw">
-Les retraits de prises ont été mis en œuvre lors de la mise à niveau de Shanghai/Capella en avril 2023. Après cela, les personnes qui misent doivent fournir une adresse de retrait (si elle n'est pas fournie avec le dépôt initial) et les paiements de récompense commenceront automatiquement à être distribués de façon périodique à intervalles de quelques jours.
+<ExpandableCard title="Quand puis-je retirer ?" eventCategory="SaasStaking" eventName="clicked when can I withdraw">
+Les validateurs doivent fournir une adresse de retrait (si elle n'a pas été fournie lors du dépôt initial), et les paiements de récompense commenceront à être distribués automatiquement tous les quelques jours.
 
 Les validateurs peuvent également se retirer entièrement en tant que validateur, ce qui débloquera leur solde ETH restant pour le retrait. Les comptes qui ont fourni une adresse de retrait d’exécution et terminé le processus de sortie recevront tout leur solde à l’adresse de retrait fournie lors du prochain balayage du validateur.
 
 <ButtonLink href="/staking/withdrawals/">En savoir plus sur les retraits de mise en jeu</ButtonLink>
 </ExpandableCard>
 
-<ExpandableCard title="Que se passe-t-il si je suis banni ?" eventCategory="SaasStaking" eventName="clicked what happens if I get slashed">
+<ExpandableCard title="Que se passe-t-il si je suis slashé ?" eventCategory="SaasStaking" eventName="clicked what happens if I get slashed">
 En utilisant un fournisseur SaaS, vous confiez l'exploitation de votre nœud à quelqu'un d'autre. Cela s'accompagne du risque de mauvaise performance du nœud, qui n'est pas sous votre contrôle. Dans le cas où votre validateur est banni, votre solde de validateur sera pénalisé et supprimé de force du groupe de validateurs.
 
 Une fois le processus de coupure ou de sortie terminé, ces fonds seront transférés à l'adresse de retrait assignée au validateur. Cela nécessite de fournir une adresse de retrait à activer. Il se peut que l'adresse de retrait ait été fournie sur dépôt initial. Sinon, les clés de retrait du validateur devront être utilisées pour signer un message indiquant une adresse de retrait. Si aucune adresse de retrait n'a été fournie, les fonds resteront verrouillés jusqu'à ce qu'ils soient fournis.
 
-Communiquez avec un fournisseur individuel de SaaS pour obtenir davantage de détails sur n'importe quelles garanties ou options d'assurance ainsi que des instructions sur la façon de fournir une adresse de retrait. Si vous préférez contrôler complètement la configuration de votre validateur, [apprenez-en plus sur la façon de miser votre ETH](/staking/solo/) de manière individuelle.
+Communiquez avec un fournisseur individuel de SaaS pour obtenir davantage de détails sur n'importe quelles garanties ou options d'assurance ainsi que des instructions sur la façon de fournir une adresse de retrait. Si vous préférez avoir le contrôle total de la configuration de votre validateur, [apprenez-en plus sur la façon de miser votre ETH en solo](/staking/solo/).
 </ExpandableCard>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [L'Annuaire de la mise en jeu sur Ethereum.](https://www.staking.directory/) - _Eridian and Spacesider_
-- [Helping Client Diversity](https://www.attestant.io/posts/evaluating-staking-services/) - _Jim McDonald 2020_
+- [L'annuaire de la mise en jeu sur Ethereum](https://www.staking.directory/) - _Eridian et Spacesider_
+- [Évaluation des services de mise en jeu](https://www.attestant.io/posts/evaluating-staking-services/) - _Jim McDonald 2020_
diff --git a/public/content/translations/fr/staking/solo/index.md b/public/content/translations/fr/staking/solo/index.md
index e01b663fadf..46d808dcd38 100644
--- a/public/content/translations/fr/staking/solo/index.md
+++ b/public/content/translations/fr/staking/solo/index.md
@@ -1,11 +1,11 @@
 ---
-title: Miser individuellement votre ETH à domicile
-description: Un aperçu de la façon de commencer à miser votre ETH à domicile
+title: "Miser individuellement votre ETH à domicile"
+description: "Un aperçu de la façon de commencer à miser votre ETH à domicile"
 lang: fr
 template: staking
 emoji: ":money_with_wings:"
 image: /images/staking/leslie-solo.png
-alt: Leslie le rhinocéros sur sa puce d'ordinateur.
+alt: "Leslie le rhinocéros sur sa puce d'ordinateur."
 sidebarDepth: 2
 summaryPoints:
   - Recevoir directement du protocole un maximum de récompenses pour le maintien de votre validateur en bon état de fonctionnement et en ligne
@@ -15,13 +15,13 @@ summaryPoints:
 
 ## Qu'est-ce que la mise en jeu à domicile ? {#what-is-solo-staking}
 
-La mise en jeu à domicile consiste à [faire fonctionner un nœud Ethereum](/run-a-node/) connecté à Internet et à déposer 32 ETH pour activer un [validateur](#faq), vous donnant la possibilité de participer directement au consensus du réseau.
+La mise en jeu à domicile consiste à [faire fonctionner un nœud Ethereum](/run-a-node/) connecté à Internet et à déposer 32 ETH pour activer un [validateur](#faq), ce qui vous donne la possibilité de participer directement au consensus du réseau.
 
-**La mise en jeu à domicile augmente la décentralisation du réseau Ethereum**, rendant Ethereum plus résistant à la censure et robuste contre les attaques. D'autres méthodes de mises en jeu peuvent ne pas aider le réseau de la même manière. La mise en jeu à domicile est la meilleure option de staking pour sécuriser Ethereum.
+**La mise en jeu à domicile augmente la décentralisation du réseau Ethereum**, ce qui rend Ethereum plus résistant à la censure et plus robuste contre les attaques. D'autres méthodes de mises en jeu peuvent ne pas aider le réseau de la même manière. La mise en jeu à domicile est la meilleure option de mise en jeu pour sécuriser Ethereum.
 
-Un nœud Ethereum est constitué à la fois d'un client de couche d'exécution (EL) et d'un client de consensus (CL). Ces clients sont des logiciels qui se coordonnent, avec un ensemble valide de clés de signature, pour vérifier les transactions et les blocs, attester de la tête de la chaîne, agréger les attestations et proposer des blocs.
+Un nœud Ethereum se compose à la fois d'un client de couche d’exécution (EL) et d'un client de couche de consensus (CL). Ces clients sont des logiciels qui fonctionnent ensemble, avec un ensemble valide de clés de signature, pour vérifier les transactions et les blocs, attester de la tête correcte de la chaîne, agréger les attestations et proposer des blocs.
 
-Les validateurs à domicile sont responsables du fonctionnement du matériel nécessaire à l'exécution de ces clients. Pour cela, il est fortement recommandé d'utiliser une machine dédiée que vous opérez depuis chez vous - c'est extrêmement bénéfique pour la santé du réseau.
+Les validateurs à domicile sont responsables du fonctionnement du matériel nécessaire à l'exécution de ces clients. Il est fortement recommandé d'utiliser une machine dédiée à cet effet que vous exploitez depuis votre domicile – c'est extrêmement bénéfique pour la santé du réseau.
 
 Un validateur à domicile reçoit des récompenses directement du protocole pour le maintien de son validateur en bon état de fonctionnement et en ligne.
 
@@ -30,64 +30,65 @@ Un validateur à domicile reçoit des récompenses directement du protocole pour
 La mise en jeu à domicile demande plus de responsabilités, mais vous donne un contrôle maximal sur vos fonds et votre configuration de mise en jeu.
 
 <CardGrid>
-  <Card title="Gagnez de l'ETH frais" emoji="💸" description="Earn ETH-denominated rewards directly from the protocol when your validator is online, without any middlemen taking a cut." />
-  <Card title="Contrôle total" emoji="🎛️" description="Keep your own keys. Choose the combination of clients and hardware that allows you to minimize your risk and best contribute to the health and security of the network. Third-party staking services make these decisions for you, and they don't always make the safest choices." />
-  <Card title="Sécurité du réseau" emoji="🔐" description="Home staking is the most impactful way to stake. By running a validator on your own hardware at home, you strengthen the robustness, decentralization, and security of the Ethereum protocol." />
+  <Card title="Gagnez de nouveaux ETH" emoji="💸" description="Gagnez des récompenses en ETH directement depuis le protocole lorsque votre validateur est en ligne, sans qu'aucun intermédiaire ne prenne de commission." />
+  <Card title="Plein contrôle" emoji="🎛️" description="Conservez vos propres clés. Choisissez la combinaison de clients et de matériel qui vous permet de minimiser vos risques et de contribuer au mieux à la santé et à la sécurité du réseau. Les services de staking tiers prennent ces décisions pour vous, et ils ne font pas toujours les choix les plus sûrs." />
+  <Card title="Sécurité du réseau" emoji="🔐" description="Le staking à domicile est la manière la plus percutante de staker. En exécutant un validateur sur votre propre matériel à la maison, vous renforcez la robustesse, la décentralisation et la sécurité du protocole Ethereum." />
 </CardGrid>
 
-## Considérations avant de miser à domicile {#considerations-before-staking-solo}
+## Éléments à prendre en compte avant la mise en jeu à domicile {#considerations-before-staking-solo}
 
-Bien que nous souhaitions que la mise en jeu à domicile soit accessible et sans risque pour tout le monde, la réalité est différente. Diverses considérations pratiques et sérieuses sont à garder à l'esprit avant de choisir de miser vos ETH à domicile.
+Bien que nous souhaitions que la mise en jeu à domicile soit accessible et sans risque pour tout le monde, la réalité est différente. Il y a quelques considérations pratiques et sérieuses à garder à l'esprit avant de choisir de mettre en jeu vos ETH à domicile.
 
 <InfoGrid>
-<ExpandableCard title="Lecture nécessaire" eventCategory="SoloStaking" eventName="clicked required reading">
-Lorsque vous opérerez votre propre nœud, vous devrez passer du temps à apprendre à utiliser le logiciel que vous avez choisi. Cela implique de lire la documentation adéquate et d'être connecté aux canaux de communication de ses équipes de développeurs.
+<ExpandableCard title="Lecture indispensable" eventCategory="SoloStaking" eventName="clicked required reading">
+Lorsque vous exploitez votre propre nœud, vous devriez consacrer du temps à apprendre à utiliser le logiciel que vous avez choisi. Cela implique de lire la documentation pertinente et d'être à l'écoute des canaux de communication de ces équipes de développeurs.
 
-Mieux vous comprendrez le logiciel que vous exécutez et comment la preuve d'enjeu fonctionne, moins ce sera risqué pour vous, et plus il vous sera facile de résoudre toute sorte de problèmes qui peuvent survenir en tant qu'opérateur de nœud.
+Mieux vous comprendrez le logiciel que vous exécutez et le fonctionnement de la preuve d'enjeu, moins l'opération sera risquée pour vous en tant que validateur, et plus il sera facile de résoudre les problèmes qui pourraient survenir en cours de route en tant qu'opérateur de nœud.
 </ExpandableCard>
 
-<ExpandableCard title="Aisance en informatique" eventCategory="SoloStaking" eventName="clicked comfortable with computers">
-La configuration des nœuds nécessite un niveau d'aisance raisonnable dans le travail avec des ordinateurs, bien que de nouveaux outils apparaissent au fil du temps pour rendre cela plus facile. Comprendre l'interface de ligne commande est utile, mais n'est plus strictement nécessaire.
+<ExpandableCard title="À l'aise avec l'informatique" eventCategory="SoloStaking" eventName="clicked comfortable with computers">
+La configuration d'un nœud nécessite un niveau d'aisance raisonnable avec les ordinateurs, bien que de nouveaux outils facilitent ce processus au fil du temps. La compréhension de l'interface de ligne de commande est utile, mais n'est plus strictement requise.
 
-Il faut également faire un petit peu de configuration matérielle et posséder une certaine compréhension des spécifications minimales recommandées.
+Cela nécessite également une configuration matérielle très basique et une certaine compréhension des spécifications minimales recommandées.
 </ExpandableCard>
 
-<ExpandableCard title="Gestion des clés sécurisée" eventCategory="SoloStaking" eventName="clicked secure key management">
-Tout comme la façon dont les clés privées sécurisent votre adresse Ethereum, vous devrez générer des clés spécifiques pour votre validateur. Vous devez comprendre comment conserver toutes vos phrases de récupération ou vos clés privées en sécurité.{' '}
+<ExpandableCard title="Gestion sécurisée des clés" eventCategory="SoloStaking" eventName="clicked secure key management">
+De la même manière que les clés privées sécurisent votre adresse Ethereum, vous devrez générer des clés spécifiquement pour votre validateur. Vous devez comprendre comment garder en lieu sûr et sécurisé toute phrase de récupération ou clé privée.{' '}
 
-[Sécurité d'Ethereum et prévention des escroqueries](/security/)
+[Sécurité Ethereum et prévention des arnaques](/security/)
 </ExpandableCard>
 
 <ExpandableCard title="Maintenance" eventCategory="SoloStaking" eventName="clicked maintenance">
-Le matériel tombe parfois en panne, tout comme les connexions réseau, et les logiciels client ont parfois besoin d'être mis à jour. La maintenance des nœuds est inévitable et nécessitera occasionnellement votre attention. Il est préférable de se tenir au courant de toutes les mises à niveau du réseau prévues, ou d'autres mises à jour critiques des logiciels client.
+Le matériel tombe parfois en panne, les connexions réseau connaissent des erreurs et les logiciels clients doivent parfois être mis à niveau. La maintenance des nœuds est inévitable et nécessitera occasionnellement votre attention. Vous voudrez vous assurer de rester au courant de toute mise à niveau réseau anticipée ou de toute autre mise à niveau client critique.
 </ExpandableCard>
 
 <ExpandableCard title="Disponibilité fiable" eventCategory="SoloStaking" eventName="clicked reliable uptime">
-Vos récompenses sont proportionnelles au temps passé par votre validateur en ligne et au fait qu'il atteste correctement. Tout temps passé hors ligne s'accompagne de pénalités proportionnelles au nombre de validateurs qui se trouvent hors ligne au même moment, mais <a href="#faq">ne donne pas lieu à des sanctions de délestage (slashing)</a>. La bande passante est également un facteur important, car les récompenses sont réduites pour les attestations qui ne sont pas reçues à temps. Les exigences varient, mais un minimum de 10 Mbit/s est recommandé (débits descendant et montant).
+Vos récompenses sont proportionnelles au temps pendant lequel votre validateur est en ligne et atteste correctement. L'indisponibilité entraîne des pénalités proportionnelles au nombre d'autres validateurs hors ligne au même moment, mais <a href="#faq">n'entraîne pas de délestage</a>. La bande passante a également son importance, car les récompenses sont diminuées pour les attestations qui ne sont pas reçues à temps. Les exigences varient, mais un minimum de 10 Mb/s en débit ascendant et descendant est recommandé.
 </ExpandableCard>
 
-<ExpandableCard title="Risque de sanctions (délestage)" eventCategory="SoloStaking" eventName="clicked slashing risk">
-Les <em>sanctions de délestage (slashing)</em> diffèrent des pénalités d'inactivité (applicables si un validateur est hors ligne). Ce sont des pénalités bien plus graves, réservées aux délits ayant un caractère malveillant. Exécuter un client minoritaire en ayant vos clés chargées sur un seul appareil à la fois permet de minimiser le risque de délestage. Cela étant dit, toute personne plaçant des ETH doit être consciente du risque de délestage.
+<ExpandableCard title="Risque de délestage" eventCategory="SoloStaking" eventName="clicked slashing risk">
+Différent des pénalités d'inactivité pour être hors ligne, le <em>délestage</em> est une pénalité beaucoup plus grave réservée aux infractions malveillantes. En exécutant un client minoritaire avec vos clés chargées sur une seule machine à la fois, votre risque d'être délesté est minimisé. Cela étant dit, tous les validateurs doivent être conscients des risques de délestage.
 
-<a href="https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50/">Plus de détails sur le slashing et le cycle de vie du validateur</a>
+<a href="https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50/"> Plus d'informations sur le délestage et le cycle de vie du validateur</a>
 </ExpandableCard>
+
 </InfoGrid>
 
 <StakingComparison page="solo" />
 
-## Fonctionnement {#how-it-works}
+## Comment ça marche {#how-it-works}
 
 <StakingHowSoloWorks />
 
 Lorsque vous êtes actif, vous gagnerez des récompenses ETH, qui seront déposées périodiquement dans votre adresse de retrait.
 
-Si vous le désirez, vous pouvez vous retirer en tant que validateur, ce qui élimine l'obligation d'être en ligne et met fin à toute autre récompense. Votre solde restant sera alors retiré à l'adresse de retrait que vous avez désignée lors de la configuration.
+Si vous le souhaitez, vous pouvez quitter votre rôle de validateur, ce qui élimine l'obligation d'être en ligne et arrête toute récompense future. Votre solde restant sera alors retiré à l'adresse de retrait que vous avez désignée lors de la configuration.
 
-[En savoir plus sur les retraits de mise en jeu](/staking/withdrawals/)
+[En savoir plus sur les retraits](/staking/withdrawals/)
 
-## Commencer avec la plateforme de lancement de la mise en jeu {#get-started-on-the-staking-launchpad}
+## Démarrez sur la plateforme de lancement de la mise en jeu {#get-started-on-the-staking-launchpad}
 
-La plateforme de lancement de la mise en jeu est une application open source qui vous aidera à devenir un validateur. Elle vous guidera dans le choix de vos clients, génèrera vos clés et déposera vos ETH dans le contrat de dépôt des mises en jeu. Une liste de vérification est fournie pour vous assurer que vous avez fait le tour de la question pour installer votre validateur en toute sécurité.
+La plateforme de lancement de la mise en jeu est une application open source qui vous aidera à devenir un validateur. Elle vous guidera dans le choix de vos clients, générera vos clés et déposera vos ETH dans le contrat de dépôt de mise en jeu. Une liste de vérification est fournie pour vous assurer que vous avez tout couvert pour configurer votre validateur en toute sécurité.
 
 <StakingLaunchpadWidget />
 
@@ -95,11 +96,11 @@ La plateforme de lancement de la mise en jeu est une application open source qui
 
 Un nombre croissant d'outils et de services vous aident à mettre en jeu vos ETH à domicile, mais chacun comporte des risques et des avantages différents.
 
-Les indicateurs d'attributs sont utilisés ci-dessous pour signaler des forces ou faiblesses notables d'un outil de mise en jeu répertorié. Utilisez cette section comme référence pendant que vous choisissez les outils qui vous aideront dans votre parcours de mise en jeu.
+Les indicateurs d'attributs sont utilisés ci-dessous pour signaler les points forts ou les faiblesses notables que peut présenter un outil de mise en jeu répertorié. Utilisez cette section comme référence pendant que vous choisissez les outils qui vous aideront dans votre parcours de mise en jeu.
 
 <StakingConsiderations page="solo" />
 
-## Explorer les outils de configuration de noeud et de client {#node-and-client-tools}
+## Explorer les outils de configuration de nœuds et de clients {#node-and-client-tools}
 
 Il existe une variété d'options disponibles pour vous aider dans votre configuration. Utilisez les indicateurs ci-dessus pour vous guider à travers les outils ci-dessous.
 
@@ -109,82 +110,85 @@ Il existe une variété d'options disponibles pour vous aider dans votre configu
 
 <StakingProductsCardGrid category="nodeTools" />
 
-Veuillez noter l'importance de choisir un [client minoritaire](/developers/docs/nodes-and-clients/client-diversity/) , car cela améliore la sécurité du réseau et limite vos risques. Les outils qui permettent de configurer un client minoritaire sont désignés comme <em style={{ textTransform: "uppercase" }}>"multi-client."</em>
+Veuillez noter l'importance de choisir un [client minoritaire](/developers/docs/nodes-and-clients/client-diversity/), car cela améliore la sécurité du réseau et limite vos risques. Les outils qui vous permettent de configurer un client minoritaire sont désignés par <em style={{ textTransform: "uppercase" }}>« multi-client ».</em>
 
 ### Générateurs de clés
 
-Ces outils peuvent être utilisés en alternative à [l'interface de dépôt de mise en jeu](https://github.com/ethereum/staking-deposit-cli/) pour vous aider à générer vos clés.
+Ces outils peuvent être utilisés comme alternative au [Staking Deposit CLI](https://github.com/ethereum/staking-deposit-cli/) pour aider à la génération de clés.
 
 <StakingProductsCardGrid category="keyGen" />
 
-Vous souhaitez suggérer un outil de mise en jeu que nous avons manqué ? Consultez notre [politique de liste de produits](/contributing/adding-staking-products/) pour voir s'il conviendrait, et le soumettre à examen.
+Vous souhaitez suggérer un outil de mise en jeu que nous avons manqué ? Consultez notre [politique de référencement de produits](/contributing/adding-staking-products/) pour voir si cela convient, et pour le soumettre à un examen.
 
 ## Explorer les guides de mise en jeu à domicile {#staking-guides}
 
 <StakingGuides />
 
-## Questions fréquemment posées {#faq}
+## Foire aux questions {#faq}
 
 Voici quelques-unes des questions les plus fréquentes relatives à la mise en jeu qui valent la peine d'être connues.
 
-<ExpandableCard title="Qu'est-ce qu'un validateur ?">
-
-Un validateur est une entité virtuelle existant sur Ethereum et participant au consensus du protocole Ethereum. Les validateurs sont représentés par un solde, une clé publique et d'autres propriétés. Un <em>client de validateur</em> est le logiciel qui agit au nom du validateur en détenant et en utilisant sa clé privée. Un même client peut contenir plusieurs paires de clés, contrôlant de nombreux validateurs.
+<ExpandableCard title="Qu'est-ce qu'un validateur ?">
 
+Un <em>validateur</em> est une entité virtuelle qui vit sur Ethereum et participe au consensus du protocole Ethereum. Les validateurs sont représentés par un solde, une clé publique et d'autres propriétés. Un <em>client de validateur</em> est le logiciel qui agit au nom du validateur en détenant et en utilisant sa clé privée. Un seul client de validateur peut détenir de nombreuses paires de clés, contrôlant ainsi de nombreux validateurs.
 </ExpandableCard>
 
-<ExpandableCard title="Puis-je déposer plus de 32 ETH ?">
-Chaque paire de clés associée à un validateur nécessite exactement 32 ETH pour être activée. Déposer plus d'ETH sur un même ensemble de clés n'augmente pas le potentiel de récompense, car chaque validateur est limité à un <a href="https://www.attestant.io/posts/understanding-validator-effective-balance/">solde effectif</a> de 32 ETH. Cela signifie que la mise en jeu se fait par tranches de 32 ETH, chacune avec son propre jeu de clés et son propre solde.
+<ExpandableCard title="Puis-je déposer plus de 32 ETH ?">
+Oui, les comptes de validateurs modernes sont capables de contenir jusqu’à 2048 ETH. Les ETH supplémentaires au-delà de 32 s'accumuleront de manière progressive, augmentant par paliers de nombres entiers à mesure que votre solde réel augmente. Ceci est connu sous le nom de <a href="https://www.attestant.io/posts/understanding-validator-effective-balance/">solde effectif</a>.
+
+Pour augmenter le solde effectif d’un compte, et donc accroître les récompenses, il faut dépasser une marge de 0,25 ETH au-delà de chaque palier entier en ETH. Par exemple, un compte avec un solde réel de 32,9 ETH et un solde effectif de 32 ETH devrait gagner encore 0,35 ETH pour porter son solde réel au-delà de 33,25 ETH avant de déclencher une augmentation du solde effectif.
+
+Cette marge empêche également le solde effectif de baisser tant qu’il n’est pas descendu de 0,25 ETH en dessous de son solde effectif actuel.
 
-Ne déposez pas plus de 32 ETH pour un seul validateur. Cela n'augmentera pas vos récompenses. Si une adresse de retrait a été définie pour le validateur, Les fonds excédentaires de 32 ETH seront automatiquement retirés à cette adresse lors du prochain [balayage de validateur](/staking/withdrawals/#validator-sweeping).
+Chaque paire de clés associée à un validateur nécessite au minimum 32  ETH pour être activée. Tout solde au-delà de ce montant peut être retiré à l’adresse de retrait associée à tout moment, via une transaction signée par cette adresse. Tout fonds dépassant le solde effectif maximal sera automatiquement retiré de façon périodique.
 
-Si la mise en jeu à domicile vous semble trop exigeante, envisagez d'utiliser un fournisseur [de mise en jeu en tant que service](/staking/saas/), ou si vous possédez moins de 32 ETH, consultez [les groupes d'enjeu](/staking/pools/).
+Si la mise en jeu à domicile vous semble trop exigeante, envisagez d'utiliser un fournisseur de [mise en jeu en tant que service](/staking/saas/), ou si vous disposez de moins de 32 ETH, consultez les [pools de mise en jeu](/staking/pools/).
 </ExpandableCard>
 
-<ExpandableCard title="Vais-je être sanctionné si je me déconnecte ? (tdlr : Non.)">
-Se déconnecter pendant que le réseau se finalise correctement n'entraînera PAS de délestage. De petites <em>pénalités d'inactivité</em> sont encourues si votre validateur n'est pas disponible pour attester pendant une période donnée (d'une durée de 6,4 minutes chacune), mais cela reste très différent du <em>délestage</em>. Ces pénalités sont légèrement inférieures à la récompense que vous auriez obtenue si le validateur avait été disponible pour attester, et les pertes peuvent être récupérées avec un temps de remise en ligne à peu près équivalent.
+<ExpandableCard title="Serai-je délesté si je suis hors ligne ? (En bref : non.)">
+Se déconnecter pendant que le réseau se finalise correctement n'entraînera PAS de délestage. De petites <em>pénalités d'inactivité</em> sont encourues si votre validateur n'est pas disponible pour attester pendant une époque donnée (d'une durée de 6,4 minutes chacune), mais cela reste très différent du <em>délestage</em>. Ces pénalités sont légèrement inférieures à la récompense que vous auriez obtenue si le validateur avait été disponible pour attester, et les pertes peuvent être récupérées avec un temps de remise en ligne à peu près équivalent.
 
 Notez que les pénalités d'inactivité sont proportionnelles au nombre de validateurs se trouvant hors ligne en même temps. Dans les cas où une grande partie du réseau est hors ligne en même temps, les pénalités pour chacun de ces validateurs seront plus importantes que lorsqu'un seul validateur est indisponible.
 
 Dans des cas extrêmes, si le réseau cesse de se finaliser parce que plus d'un tiers des valideurs sont hors ligne, ces utilisateurs subiront ce que l'on appelle une <em>fuite d'inactivité quadratique</em>, qui consiste en une fuite exponentielle d'ETH à partir de comptes de valideurs hors ligne. Cela permet au réseau de s'auto-régénérer en brûlant les ETH des validateurs inactifs jusqu'à ce que leur solde atteigne 16 ETH, après quoi ils seront automatiquement éjectés du pool de validateurs. Les validateurs en ligne restants comprendront finalement, à nouveau, 2/3 du réseau, satisfaisant ainsi la supermajorité nécessaire pour finaliser à nouveau la chaîne.
 </ExpandableCard>
 
-<ExpandableCard title="Comment être sûr de ne pas subir de délestage ?">
-Pour faire court, cela ne peut jamais être totalement garanti, mais si vous êtes de bonne foi, que vous utilisez un client minoritaire et que vous ne conservez vos clés de signature que sur une seule machine à la fois, le risque de subir un délestage est quasiment nul.
+<ExpandableCard title="Comment m'assurer de ne pas être délesté ?">
+En bref, cela ne peut jamais être entièrement garanti, mais si vous agissez de bonne foi, si vous exécutez un client minoritaire et ne conservez vos clés de signature que sur une seule machine à la fois, le risque de subir un délestage est quasi nul.
 
-Seuls quelques moyens spécifiques peuvent aboutir à ce qu'un validateur soit délesté et éjecté du réseau. À l'heure où nous écrivons ces lignes, les délestages qui se sont produits sont exclusivement le produit de configurations matérielles redondantes où les clés de signature sont stockées sur deux machines distinctes à la fois. Cela peut entraîner par inadvertance un <em>double vote</em> de vos clés, ce qui constitue une faute sanctionnable.
+Seuls quelques moyens spécifiques peuvent aboutir à ce qu'un validateur soit délesté et éjecté du réseau. À l'heure où nous écrivons ces lignes, les délestages qui se sont produits sont exclusivement le produit de configurations matérielles redondantes où les clés de signature sont stockées sur deux machines distinctes à la fois. Cela peut entraîner par inadvertance un <em>double vote</em> de vos clés, ce qui constitue une faute passible de délestage.
 
-L'exécution d'un client supermajoritaire (tout client utilisé par plus de 2/3 du réseau) comporte également le risque d'un délestage dans le cas où ce client présente un bogue qui entraîne une fouche de la chaîne. Cela peut aboutir à une fourche défectueuse qui sera finalisée. Pour revenir à la chaîne voulue, il faudrait soumettre un <em>vote circulaire</em> en essayant d'annuler un bloc finalisé. Il s'agit également d'une infraction passible de sanctions et peut être évité simplement, en utilisant, à la place, un client minoritaire.
+L'exécution d'un client supermajoritaire (tout client utilisé par plus de 2/3 du réseau) comporte également le risque d'un délestage potentiel dans le cas où ce client présente un bogue qui entraîne une fourche de la chaîne. Cela peut aboutir à une fourche défectueuse qui sera finalisée. Pour revenir à la chaîne voulue, il faudrait soumettre un <em>vote circulaire</em> en essayant d'annuler un bloc finalisé. Il s'agit également d'une infraction passible de délestage et qui peut être évitée simplement en utilisant un client minoritaire à la place.
 
 Des bogues équivalents dans <em>un client minoritaire ne seraient jamais finalisés</em> et ne donneraient donc jamais lieu à un vote circulaire, et entraîneraient simplement des pénalités d'inactivité, et <em>non un délestage</em>.
 
 <ul>
-  <li><a href="https://hackernoon.com/ethereums-client-diversity-problem">En savoir plus sur l'importance de gérer un client minoritaire.</a></li>
+  <li><a href="https://hackernoon.com/ethereums-client-diversity-problem">En savoir plus sur l'importance d'exécuter un client minoritaire.</a></li>
   <li><a href="https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50">En savoir plus sur la prévention du délestage</a></li>
 </ul>
 </ExpandableCard>
 
-<ExpandableCard title="Quel est le meilleur client ?">
-Les clients individuels peuvent varier légèrement en termes de performances et d'interface utilisateur, car ils sont tous développés par des équipes différentes utilisant des langages de programmation variés. Ceci étant dit, aucun d'entre eux n'est "le meilleur". Tous les clients de production sont d'excellents logiciels, qui exécutent tous les mêmes fonctions de base pour se synchroniser et interagir avec la blockchain.
+<ExpandableCard title="Quel est le meilleur client ?">
+Les clients individuels peuvent varier légèrement en termes de performances et d'interface utilisateur, car ils sont tous développés par des équipes différentes utilisant des langages de programmation variés. Ceci étant dit, aucun d'entre eux n'est « le meilleur ». Tous les clients de production sont d'excellents logiciels, qui exécutent tous les mêmes fonctions de base pour se synchroniser et interagir avec la blockchain.
 
-Puisque tous les clients de production fournissent les mêmes fonctionnalités de base, il est en fait très important que vous choisissiez un <strong>client minoritaire</strong>, c'est-à-dire tout client qui n'est actuellement PAS utilisé par une majorité de valideurs sur le réseau. Cela peut sembler paradoxal, mais le fait d'utiliser un client majoritaire ou supermajoritaire vous expose à un risque accru de délestage en cas de bogue dans ce client. Utiliser un client minoritaire limite considérablement ces risques.
+Puisque tous les clients de production fournissent les mêmes fonctionnalités de base, il est en fait très important que vous choisissiez un <strong>client minoritaire</strong>, c'est-à-dire tout client qui n'est actuellement PAS utilisé par une majorité de validateurs sur le réseau. Cela peut sembler paradoxal, mais le fait d'utiliser un client majoritaire ou supermajoritaire vous expose à un risque accru de délestage en cas de bogue dans ce client. Utiliser un client minoritaire limite considérablement ces risques.
 
 <a href="https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA">En savoir plus sur les raisons pour lesquelles la diversité des clients est essentielle</a>
 </ExpandableCard>
 
-<ExpandableCard title="Puis-je simplement utiliser un VPS (serveur privé virtuel) ?">
-Bien qu'un serveur privé virtuel (VPS) puisse être utilisé en remplacement du matériel domestique, l'accès physique et l'emplacement de votre client validateur <em>ont leur importance</em>. Les solutions centralisées dans le cloud, telles que Amazon Web Services ou Digital Ocean, offrent la commodité de ne pas avoir à obtenir et à faire fonctionner du matériel, au détriment de la centralisation du réseau.
+<ExpandableCard title="Puis-je simplement utiliser un VPS (serveur privé virtuel) ?">
+Bien qu'un serveur privé virtuel (VPS) puisse être utilisé en remplacement du matériel domestique, l'accès physique et l'emplacement de votre client validateur <em>ont leur importance</em>. Les solutions cloud centralisées, telles qu'Amazon Web Services ou Digital Ocean, offrent la commodité de ne pas avoir à obtenir et à faire fonctionner du matériel, au détriment de la centralisation du réseau.
 
 Plus il y a de clients validateurs fonctionnant sur une seule solution de stockage en cloud centralisée, plus cela devient dangereux pour ces utilisateurs. Tout événement qui mettrait ces fournisseurs hors ligne, qu'il s'agisse d'une attaque, d'une demande réglementaire ou d'une simple panne de courant ou d'Internet, entraînera la mise hors ligne simultanée de tous les clients de validation qui dépendent de ce serveur.
 
-Les pénalités hors ligne sont proportionnelles au nombre de personnes se trouvant hors ligne au même moment. L'utilisation d'un VPS augmente considérablement le risque de voir les pénalités hors ligne devenir plus sévères, et accroît votre risque de fuite quadratique ou de délestage dans le cas où la panne serait suffisamment importante. Pour minimiser vos propres risques et ceux encourus par le réseau, les utilisateurs sont fortement encouragés à se procurer et à exploiter leur propre matériel.
+Les pénalités hors ligne sont proportionnelles au nombre de personnes se trouvant hors ligne au même moment. L'utilisation d'un VPS augmente considérablement le risque que les pénalités pour indisponibilité soient plus sévères, et accroît votre risque de fuite quadratique ou de délestage dans le cas où la panne serait suffisamment importante. Pour minimiser vos propres risques et ceux encourus par le réseau, les utilisateurs sont fortement encouragés à se procurer et à exploiter leur propre matériel.
 </ExpandableCard>
 
-<ExpandableCard title="Comment débloquer mes récompenses ou récupérer mon ETH ?">
+<ExpandableCard title="Comment débloquer mes récompenses ou récupérer mes ETH ?">
 
 Les retraits de quelque nature que ce soit de la Chaîne Phare (Beacon Chain) exigent que les identifiants de retrait soient définis.
 
-Les nouvelles personnes plaçant des ETH définissent ceci au moment de la génération et du dépôt de clés. Les stakers existants qui n'ont pas déjà défini cela peuvent mettre à jour leurs clés pour supporter cette fonctionnalité.
+Les nouveaux validateurs définissent cela au moment de la génération et du dépôt des clés. Les validateurs existants qui n'ont pas encore défini cela peuvent mettre à niveau leurs clés pour prendre en charge cette fonctionnalité.
 
 Une fois que les identifiants de retrait sont définis, les paiements de récompense (ETH cumulés par rapport aux 32 initiaux) seront distribués périodiquement à l'adresse de retrait automatiquement.
 
@@ -193,13 +197,13 @@ Pour déverrouiller et recevoir la totalité de votre solde, vous devez égaleme
 <ButtonLink href="/staking/withdrawals/">En savoir plus sur les retraits de mise en jeu</ButtonLink>
 </ExpandableCard>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [L'Annuaire de la mise en jeu sur Ethereum.](https://www.staking.directory/) - _Eridian and Spacesider_
-- [Ethereum's Client Diversity Problem](https://hackernoon.com/ethereums-client-diversity-problem) - _@emmanuelawosika 2022_
-- [Helping Client Diversity](https://www.attestant.io/posts/helping-client-diversity/) - _Jim McDonald 2022_
-- [Client diversity on Ethereum's consensus layer](https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA) - _jmcook.eth 2022_
-- [How To: Shop For Ethereum Validator Hardware](https://www.youtube.com/watch?v=C2wwu1IlhDc) - _EthStaker 2022_
-- [Eth2 Slashing Prevention Tips](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50) - _Raul Jordan 2020_
+- [L'annuaire de la mise en jeu sur Ethereum](https://www.staking.directory/) - _Eridian et Spacesider_
+- [Le problème de la diversité des clients d'Ethereum](https://hackernoon.com/ethereums-client-diversity-problem) - _@emmanuelawosika 2022_
+- [Aider à la diversité des clients](https://www.attestant.io/posts/helping-client-diversity/) - _Jim McDonald 2022_
+- [La diversité des clients sur la couche de consensus d'Ethereum](https://mirror.xyz/jmcook.eth/S7ONEka_0RgtKTZ3-dakPmAHQNPvuj15nh0YGKPFriA) - _jmcook.eth 2022_
+- [Comment : Acheter du matériel pour un validateur Ethereum](https://www.youtube.com/watch?v=C2wwu1IlhDc) - _EthStaker 2022_
+- [Conseils pour la prévention du délestage sur Eth2](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50) - _Raul Jordan 2020_
 
 <QuizWidget quizKey="staking-solo" />
diff --git a/public/content/translations/fr/staking/withdrawals/index.md b/public/content/translations/fr/staking/withdrawals/index.md
index 6409f08253e..67cc8812be2 100644
--- a/public/content/translations/fr/staking/withdrawals/index.md
+++ b/public/content/translations/fr/staking/withdrawals/index.md
@@ -1,10 +1,10 @@
 ---
 title: Retraits de la mise en jeu
-description: Page résumant ce que sont les retraits de staking, comment ils fonctionnent et ce que les stakers doivent faire pour obtenir leurs récompenses
+description: "Page résumant ce que sont les retraits de staking, comment ils fonctionnent et ce que les stakers doivent faire pour obtenir leurs récompenses"
 lang: fr
 template: staking
 image: /images/staking/leslie-withdrawal.png
-alt: Leslie le rhinocéros avec ses récompenses de staking
+alt: "Leslie le rhinocéros avec ses récompenses de staking"
 sidebarDepth: 2
 summaryPoints:
   - La mise à niveau Shanghai/Capella a permis les retraits de staking sur Ethereum
@@ -13,15 +13,11 @@ summaryPoints:
   - Les validateurs qui quittent complètement le staking recevront leur solde restant
 ---
 
-<UpgradeStatus dateKey="page-staking-withdrawals-when">
-Les retraits de staking ont été activés avec la mise à niveau Shanghai/Capella, qui a eu lieu le 12 avril 2023.&nbsp;<a href="#when" customEventOptions={{ eventCategory: "Anchor link", eventAction: "When's it shipping?", eventName: "click" }}>Plus d'informations sur Shanghai/Capella</a>
-</UpgradeStatus>
+**Les retraits de mise en jeu** font référence aux transferts d'ETH depuis un compte de validateur sur la couche de consensus d'Ethereum (la Chaîne phare), vers la couche d’exécution où ils peuvent faire l'objet de transactions.
 
-**Les retraits de staking** font référence aux transferts d'ETH depuis le compte d'un validateur sur la couche de consensus d'Ethereum (la chaîne phare) vers la couche d'exécution où ils peuvent être traités.
+**Les paiements de récompenses pour le solde excédant 32 ETH** seront automatiquement et régulièrement envoyés à une adresse de retrait liée à chaque validateur, une fois celle-ci fournie par l'utilisateur. Les utilisateurs peuvent également **sortir entièrement de la mise en jeu**, débloquant ainsi la totalité de leur solde de validateur.
 
-**Les paiements des récompenses au dessus d'un solde** de 32 ETH seront automatiquement et régulièrement envoyés à une adresse de retrait liée à chaque validateur, une fois fourni par l’utilisateur. Les utilisateurs peuvent également **quitter le staking entièrement**, débloquer leur solde de validateur complet.
-
-## Récompenses de staking {#staking-rewards}
+## Récompenses de mise en jeu {#staking-rewards}
 
 Les paiements de récompenses sont traités automatiquement pour les comptes des validateurs actifs avec un solde effectif de 32 ETH maximum.
 
@@ -39,7 +35,7 @@ Avant la mise à niveau de Shanghai/Capella, vous ne pouviez pas utiliser l'ETH
 
 <WithdrawalsTabComparison />
 
-### Informations importantes {#important-notices}
+### Avis importants {#important-notices}
 
 Fournir une adresse de retrait est une étape requise pour tout compte de validateur avant d'être admissible à un retrait d'ETH sur son solde.
 
@@ -47,26 +43,26 @@ Fournir une adresse de retrait est une étape requise pour tout compte de valida
 <AlertEmoji text="⚠️"/>
 <AlertContent>
 <AlertDescription>
-  <strong>Chaque compte de validateur ne peut se voir attribué qu'une seule adresse de retrait.</strong> Une fois qu'une adresse est choisie et soumise à la couche de consensus, elle ne peut pas être annulée ou modifiée à nouveau. Vérifiez la propriété et l'exactitude de l'adresse fournie avant de la soumettre.
+<strong>Chaque compte de validateur ne peut se voir attribuer qu'une seule adresse de retrait, une seule fois.</strong> Une fois qu'une adresse est choisie et soumise à la couche de consensus, cette action ne peut être ni annulée ni modifiée. Vérifiez la propriété et l'exactitude de l'adresse fournie avant de la soumettre.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
 Le fait de ne pas fournir cette adresse ne pose <strong>aucun danger pour vos fonds pendant ce temps</strong>, à condition que votre phrase mnémonique/de récupération soit restée en sécurité hors-ligne, et n'ait été compromise d'aucune façon. Ne pas ajouter d’identifiants de retrait laissera simplement l’ETH verrouillé sur le compte du validateur tel qu'il était jusqu'à jusqu’à ce qu’une adresse de retrait soit fournie.
 
-## Quitter entièrement le staking {#exiting-staking-entirely}
+## Sortir entièrement de la mise en jeu {#exiting-staking-entirely}
 
-Fournir une adresse de retrait est nécessaire pour que _les fonds_ puissent être transférés sur un solde de compte de validateur.
+La fourniture d'une adresse de retrait est obligatoire avant que le _moindre_ fonds puisse être transféré hors du solde d'un compte de validateur.
 
 Les utilisateurs qui cherchent à quitter entièrement le staking et à retirer leur solde complet doivent également signer et diffuser un message de « sortie volontaire » avec des clés de validateur qui lanceront le processus de sortie de la mise en jeu. Ceci est exécuté avec votre client de validateur et soumis à votre nœud de consensus, et ne nécessite pas de gaz.
 
 Le processus d'un validateur sortant du staking prend un temps variable, en fonction du nombre d'autres individus sortant en même temps. Une fois terminé, ce compte ne sera plus responsable de l'exécution des tâches du réseau de validateur, ne sera plus admissible aux récompenses, et n'aura plus d'ETH « en jeu ». À ce moment, le compte sera marqué comme entièrement « retirable ».
 
-Une fois qu'un compte est marqué comme « retirable » et que les identifiants de retrait ont été fournis, un utilisateur n'a plus rien à faire d'autre qu'attendre. Les comptes sont automatiquement et continuellement balayés par les proposeurs de blocs pour les fonds sortis qui sont admissibles, et le solde de votre compte sera transféré en entier (également connu sous le nom de « retrait complet ») au cours du prochain <a href="#validator-sweeping" customEventOptions={{ eventCategory: "Anchor link", eventAction: "Exiting staking entirely (sweep)", eventName: "click" }}>balayage</a>.
+Une fois qu'un compte est marqué comme « retirable » et que les identifiants de retrait ont été fournis, un utilisateur n'a plus rien à faire d'autre qu'attendre. Les comptes sont automatiquement et continuellement balayés par les proposeurs de blocs pour les fonds sortis éligibles, et le solde de votre compte sera transféré en totalité (ce que l'on appelle un « retrait complet ») lors du prochain <a href="#validator-sweeping" customEventOptions={{ eventCategory: "Anchor link", eventAction: "Exiting staking entirely (sweep)", eventName: "click" }}>balayage</a>.
 
-## Quand les retraits de staking sont-ils activés ? {#when}
+## Quand les retraits de mise en jeu ont-ils été activés ? {#when}
 
-Les retraits de staking sont disponibles ! La fonction de retrait a été activée dans le cadre de la mise à niveau Shanghai/Capella qui a eu lieu le 12 avril 2023.
+La fonctionnalité de retrait a été activée dans le cadre de la mise à niveau Shanghai/Capella qui a eu lieu le **12 avril 2023**.
 
 La mise à niveau Shanghai/Capella a permis de récupérer de l'Ether précédemment mis en jeu vers un compte Ethereum standard. Cela a fermé la boucle de la liquidité mise en jeu, et a fait avancer Ethereum sur son chemin de construction d'un écosystème durable, évolutif, sûr et décentralisé.
 
@@ -91,29 +87,29 @@ Lorsqu'un validateur doit proposer le bloc suivant, il est tenu de constituer un
 <AlertEmoji text="🕛"/>
 <AlertContent>
 <AlertDescription>
-Pensez à une horloge analogique. L'aiguille de l’horloge pointe vers l’heure, progresse dans une direction, ne saute pas d’heures, et finit par revenir au début après que le dernier nombre est atteint.<br/><br/>
-Maintenant au lieu de 1 à 12, imaginez que l'horloge a 0 à N <em>(le nombre total de comptes de validateur qui ont déjà été enregistrés sur la couche de consensus, plus de 500 000 en janvier 2023).</em><br/><br/>
-L'aiguille de l’horloge pointe vers le prochain validateur qui doit être vérifié pour les retraits éligibles. Il commence à 0 et progresse tout autour sans sauter de compte. Lorsque le dernier validateur est atteint, le cycle reprend au début.
+Pensez à une horloge analogique. L'aiguille de l'horloge indique l'heure, progresse dans une seule direction, ne saute aucune heure et finit par revenir au début une fois le dernier chiffre atteint.<br/><br/>
+Maintenant, au lieu des chiffres 1 à 12, imaginez que l'horloge va de 0 à N <em>(le nombre total de comptes de validateurs jamais enregistrés sur la couche de consensus, plus de 500 000 en janvier 2023).</em><br/><br/>
+L'aiguille de l'horloge pointe vers le prochain validateur qui doit être vérifié pour les retraits éligibles. Elle commence à 0 et fait le tour complet sans sauter aucun compte. Lorsque le dernier validateur est atteint, le cycle reprend au début.
 </AlertDescription>
 </AlertContent>
 </Alert>
 
-#### Vérification des retraits sur un compte {#checking-an-account-for-withdrawals}
+#### Vérifier les retraits d'un compte {#checking-an-account-for-withdrawals}
 
 Lorsqu'un proposant passe en revue les validateurs pour d'éventuels retraits, chaque validateur vérifié est évalué en fonction d'une courte série de questions afin de déterminer si un retrait doit être déclenché et, le cas échéant, quel montant d'ETH doit être retiré.
 
-1. **Une adresse de retrait a-t-elle été fournie ? ** Si aucune adresse de retrait n'a été fournie, le compte est ignoré et aucun retrait n'est effectué.
-2. **Le validateur est-il sorti et peut-il être retiré ? ** Si le validateur est complètement sorti et que nous avons atteint l'époque où son compte est considéré comme « pouvant être retiré », alors un retrait complet sera effectué. Le solde total restant sera alors transféré à l'adresse de retrait.
-3. **Le solde effectif est-il plafonné à 32 ? ** Si le compte dispose d'identifiants de retrait, qu'il n'est pas entièrement clôturé et que des récompenses supérieures à 32 sont en attente, un retrait partiel sera effectué et ne transférera que les récompenses supérieures à 32 à l'adresse de retrait de l'utilisateur.
+1. **Une adresse de retrait a-t-elle été fournie ?** Si aucune adresse de retrait n'a été fournie, le compte est ignoré et aucun retrait n'est initié.
+2. **Le validateur est-il sorti et retirable ?** Si le validateur est complètement sorti, et que nous avons atteint l'époque où son compte est considéré comme « retirable », alors un retrait complet sera traité. Le solde total restant sera alors transféré à l'adresse de retrait.
+3. **Le solde effectif est-il plafonné à 32 ?** Si le compte dispose d'identifiants de retrait, n'est pas entièrement sorti et a des récompenses en attente au-dessus de 32, un retrait partiel sera traité, qui ne transférera que les récompenses au-dessus de 32 à l'adresse de retrait de l'utilisateur.
 
 Seules deux actions entreprises par les opérateurs de validateurs au cours du cycle de vie d'un validateur influencent directement ce flux :
 
 - Fournir des justificatifs de retrait pour permettre toute forme de retrait
 - Sortir du réseau déclenchera un retrait complet
 
-### Sans gaz {#gas-free}
+### Sans frais de gaz {#gas-free}
 
-Cette approche des retraits de staking évite d'obliger les stakers à soumettre manuellement une transaction demandant le retrait d'une quantité particulière d'ETH. Cela signifie qu'aucun **gaz (frais de transaction)** n'est requis, et les retraits ne concurrencent pas non plus l'espace de bloc existant de la couche d'exécution.
+Cette approche des retraits de staking évite d'obliger les stakers à soumettre manuellement une transaction demandant le retrait d'une quantité particulière d'ETH. Cela signifie qu'il n'y a **aucun gaz (frais de transaction) requis**, et que les retraits ne sont pas non plus en concurrence pour l'espace de bloc existant sur la couche d’exécution.
 
 ### À quelle fréquence recevrai-je mes récompenses de mise en jeu ? {#how-soon}
 
@@ -123,34 +119,34 @@ En élargissant ce calcul, nous pouvons estimer le temps nécessaire pour traite
 
 <TableContainer>
 
-| Nombre de retraits | Délai d'exécution |
-| :-------------:|:-------------:|
-| 400 000 | 3,5 jours |
-| 500 000 | 4,3 jours |
-| 600 000 | 5,2 jours |
-| 700 000 | 6,1 jours |
-| 800 000 | 7,0 jours |
+| Nombre de retraits | Temps d'exécution |
+| :----------------: | :---------------: |
+|       400 000      |     3,5 jours     |
+|       500 000      |     4,3 jours     |
+|       600 000      |     5,2 jours     |
+|       700 000      |     6,1 jours     |
+|       800 000      |     7,0 jours     |
 
 </TableContainer>
 
 Comme vous pouvez le constater, ce processus ralentit au fur et à mesure que le nombre de validateurs augmente sur le réseau. Une augmentation des crénaux manqués pourrait ralentir proportionnellement ce phénomène, mais cela représente généralement le côté le plus lent des résultats possibles.
 
-## Questions fréquemment posées {#faq}
+## Foire aux questions {#faq}
 
 <ExpandableCard
-title="Une fois que j'ai fourni une adresse de retrait, puis-je la changer pour une autre adresse de retrait ?"
+title="Une fois que j'ai fourni une adresse de retrait, puis-je la remplacer par une autre adresse de retrait ?"
 eventCategory="FAQ"
-eventAction="Once I have provided a withdrawal address, can I change it to an alternative withdrawal address?"
+eventAction="Une fois que j'ai fourni une adresse de retrait, puis-je la remplacer par une autre adresse de retrait ?"
 eventName="read more">
-Non, la procédure de fourniture des identifiants de retrait est une procédure unique, qui ne peut être modifiée une fois qu'elle a été soumise.
+Non, le processus de fourniture des identifiants de retrait est un processus unique qui ne peut être modifié une fois soumis.
 </ExpandableCard>
 
 <ExpandableCard
-title="Pourquoi une adresse de retrait ne peut être définie qu'une seule fois ?"
+title="Pourquoi une adresse de retrait ne peut-elle être définie qu'une seule fois ?"
 eventCategory="FAQ"
-eventAction="Why can a withdrawal address only be set once?"
+eventAction="Pourquoi une adresse de retrait ne peut-elle être définie qu'une seule fois ?"
 eventName="read more">
-En définissant l'adresse de retrait d'une couche d'exécution, les identifiants de retrait de ce validateur ont été modifiés de manière permanente. Cela signifie que les anciens identifiants ne fonctionneront plus et que les nouveaux identifiants renvoient à un compte de la couche d'exécution.
+En définissant une adresse de retrait de la couche d’exécution, les identifiants de retrait de ce validateur sont modifiés de manière permanente. Cela signifie que les anciens identifiants ne fonctionneront plus et que les nouveaux identifiants renvoient à un compte de la couche d'exécution.
 
 Les adresses de retrait peuvent être soit un contrat intelligent (contrôlé par son code), soit un compte détenu en externe (EOA, contrôlé par sa clé privée). Actuellement, ces comptes n'ont aucun moyen de communiquer un message à la couche de consensus qui signalerait un changement d'identifiant du validateur, et l'ajout de cette fonctionnalité compliquerait inutilement le protocole.
 
@@ -158,27 +154,26 @@ En guise d'alternative au changement d'adresse de retrait pour un validateur par
 </ExpandableCard>
 
 <ExpandableCard
-title="Que se passe-t-il si je participe à des jetons de mise en jeu ou à la mise en jeu mutualisée"
+title="Et si je participe au staking de jetons ou au staking en pool ?"
 eventCategory="FAQ"
 eventAction="What if I participate in staking tokens or pooled staking"
 eventName="read more">
 
-Si vous faites partie d'un [groupe d'enjeux](/staking/pools/) ou si vous détenez des jetons de mise en jeu, vous devez vous renseigner auprès de votre fournisseur pour savoir comment les retraits de mise en jeu sont gérés, car chaque service fonctionne différemment.
-
-En général, les utilisateurs sont censés être libres de récupérer leur ETH sous-jacent mis en jeu, ou de changer le fournisseur de mise en jeu qu'ils utilisent. Si un groupe particulier devient trop important, les fonds peuvent être retirés, rachetés, et remisés auprès d'un <a href="https://rated.network/">fournisseur plus petit</a>. Ou, si vous avez accumulé suffisamment d'ETH, vous pouvez [miser depuis chez vous](/staking/solo/).
+Si vous faites partie d'un [pool de jalonnement](/staking/pools/) ou si vous détenez des jetons de jalonnement, vous devez vérifier auprès de votre fournisseur pour plus de détails sur la façon dont les retraits de jalonnement sont gérés, car chaque service fonctionne différemment.
 
+En général, les utilisateurs sont censés être libres de récupérer leur ETH sous-jacent mis en jeu, ou de changer le fournisseur de mise en jeu qu'ils utilisent. Si un groupe particulier devient trop important, les fonds peuvent être retirés, rachetés, et remisés auprès d'un <a href="https://rated.network/">fournisseur plus petit</a>. Ou, si vous avez accumulé suffisamment d'ETH, vous pourriez [s'engager de chez vous](/staking/solo/).
 </ExpandableCard>
 
 <ExpandableCard
-title="Est-ce que les paiements de récompense (retraits partiels) se font automatiquement ?"
+title="Les paiements de récompenses (retraits partiels) s'effectuent-ils automatiquement ?"
 eventCategory="FAQ"
-eventAction="Do reward payments (partial withdrawals) happen automatically?"
+eventAction="Les paiements de récompenses (retraits partiels) s'effectuent-ils automatiquement ?"
 eventName="read more">
-Oui, à condition que votre validateur ait fourni une adresse de retrait. Elle doit être fournie une fois pour permettre tout retrait initialement, puis les paiements de récompenses seront automatiquement déclenchés tous les deux ou trois jours avec chaque balayage des validateurs.
+Oui, tant que votre validateur a fourni une adresse de retrait. Elle doit être fournie une fois pour permettre tout retrait initialement, puis les paiements de récompenses seront automatiquement déclenchés tous les deux ou trois jours avec chaque balayage des validateurs.
 </ExpandableCard>
 
 <ExpandableCard
-title="Les retraits complets sont-ils effectués automatiquement ?"
+title="Les retraits complets s'effectuent-ils automatiquement ?"
 eventCategory="FAQ"
 eventAction="Do full withdrawals happen automatically?"
 eventName="read more">
@@ -186,14 +181,13 @@ eventName="read more">
 Non, si votre validateur est toujours actif sur le réseau, un retrait total ne se fera pas automatiquement. Pour cela, il faut déclencher manuellement une sortie volontaire.
 
 Une fois qu'un validateur a terminé le processus de sortie, et en supposant que le compte possède des identifiants de retrait, le solde restant sera <em>alors</em> retiré lors du prochain <a href="#validator-sweeping">balayage du validateur</a>.
-
 </ExpandableCard>
 
 <ExpandableCard title="Puis-je retirer un montant personnalisé ?"
 eventCategory="FAQ"
-eventAction="Can I withdraw a custom amount?"
+eventAction="Puis-je retirer un montant personnalisé ?"
 eventName="read more">
-Les retraits sont conçus pour être effectués automatiquement, en transférant tous les ETH qui ne contribuent pas activement à la mise. Cela comprend le solde complet pour les comptes qui ont terminé de processus de sortie.
+Les retraits sont conçus pour être poussés automatiquement, transférant tout ETH qui ne contribue pas activement à la mise. Cela comprend le solde complet pour les comptes qui ont terminé de processus de sortie.
 
 Il n'est pas possible de demander manuellement le retrait de quantités spécifiques d'ETH.
 </ExpandableCard>
@@ -201,27 +195,26 @@ Il n'est pas possible de demander manuellement le retrait de quantités spécifi
 <ExpandableCard
 title="J'opère un validateur. Où puis-je trouver plus d'informations sur l'activation des retraits ?"
 eventCategory="FAQ"
-eventAction="I operate a validator. Where can I find more information on enabling withdrawals?"
+eventAction="I operate a validator. Où puis-je trouver plus d'informations sur l'activation des retraits ?"
 eventName="read more">
 
 Il est recommandé aux opérateurs de validateurs de consulter la page <a href="https://launchpad.ethereum.org/withdrawals/">Staking Launchpad Withdrawals</a> où vous trouverez plus de détails sur la façon de préparer votre validateur aux retraits, le calendrier des événements, et davantage d'informations sur le fonctionnement des retraits.
 
-Pour commencer en testant votre configuration sur un réseau de test, visitez la <a href="https://holesky.launchpad.ethereum.org">Platforme de lancement pour la mise en jeu sur le réseau de test Holesky</a>.
-
+Pour essayer d'abord votre configuration sur un réseau de test, visitez la <a href="https://hoodi.launchpad.ethereum.org">plateforme de lancement de mise en jeu du réseau de test Hoodi</a> pour commencer.
 </ExpandableCard>
 
 <ExpandableCard
-title="Puis-je réactiver mon validateur après la sortie en déposant plus d'ETH ?"
+title="Puis-je réactiver mon validateur après l'avoir quitté en déposant plus d'ETH ?"
 eventCategory="FAQ"
-eventAction="Can I re-activate my validator after exiting by depositing more ETH?"
+eventAction="Puis-je réactiver mon validateur après l'avoir quitté en déposant plus d'ETH ?"
 eventName="read more">
 Non. Une fois qu'un validateur est sorti et que son solde total a été retiré, tous les fonds supplémentaires déposés sur ce validateur seront automatiquement transférés à l'adresse de retrait lors du prochain balayage du validateur. Pour remettre en jeu l'ETH, un nouveau validateur doit être activé.
 </ExpandableCard>
 
-## Complément d'information {#further-reading}
+## En savoir plus {#further-reading}
 
-- [Retraits de la plateforme de lancement de la mise en jeu](https://launchpad.ethereum.org/withdrawals)
-- [EIP-4895 : la chaîne phare signale les retraits comme des opérations](https://eips.ethereum.org/EIPS/eip-4895)
-- [PEEPanEIP #94 : Retrait de l'ETH misé (Testing) avec Potuz & Hsiao-Wei Wang](https://www.youtube.com/watch?v=G8UstwmGtyE)
-- [PEEPanEIP#68 : EIP-4895 : Retraits de la chaîne de balises en tant qu'opérations avec Alex Stokes](https://www.youtube.com/watch?v=CcL9RJBljUs)
-- [Comprendre le Solde Effectif du Validateur](https://www.attestant.io/posts/understanding-validator-effective-balance/)
+- [Retraits sur la plateforme de lancement de la mise en jeu](https://launchpad.ethereum.org/withdrawals)
+- [EIP-4895 : Retraits poussés de la Chaîne Phare en tant qu'opérations](https://eips.ethereum.org/EIPS/eip-4895)
+- [PEEPanEIP #94 : Retrait d'ETH mis en jeu (test) avec Potuz & Hsiao-Wei Wang](https://www.youtube.com/watch?v=G8UstwmGtyE)
+- [PEEPanEIP#68 : EIP-4895 : Retraits poussés de la Chaîne Phare en tant qu'opérations, avec Alex Stokes](https://www.youtube.com/watch?v=CcL9RJBljUs)
+- [Comprendre le solde effectif du validateur](https://www.attestant.io/posts/understanding-validator-effective-balance/)
diff --git a/public/content/translations/fr/web3/index.md b/public/content/translations/fr/web3/index.md
index aa0fdb313ed..da16c030f7b 100644
--- a/public/content/translations/fr/web3/index.md
+++ b/public/content/translations/fr/web3/index.md
@@ -1,6 +1,6 @@
 ---
 title: Qu'est-ce que le Web3 et pourquoi est-ce important ?
-description: Une introduction au Web3 — la prochaine évolution du World Wide Web — et son intérêt.
+description: "Une introduction au Web3 — la prochaine évolution du World Wide Web — et son intérêt."
 lang: fr
 ---
 
@@ -12,7 +12,8 @@ lang: fr
 
 La centralisation a permis à des milliards de personnes d'accéder au World Wide Web et de créer l'infrastructure stable et robuste sur laquelle il repose. Dans le même temps, une poignée d'entités centralisées ont pris le contrôle de larges pans du World Wide Web, décidant de manière unilatérale de ce qui est autorisé ou non.
 
-Le Web3 est la réponse à ce dilemme. Contrairement à un Web dominé par les grandes entreprises technologiques, le Web3 est décentralisé et est construit, exploité et détenu par ses utilisateurs. Le Web3 donne le pouvoir aux individus plutôt qu'aux entreprises. Avant de parler du Web3, il faut comprendre comment nous en sommes arrivés là.
+Le Web3 est la réponse à ce dilemme. Contrairement à un Web dominé par les grandes entreprises technologiques, le Web3 est décentralisé et est construit, exploité et détenu par ses utilisateurs. Le Web3 donne le pouvoir aux individus plutôt qu'aux entreprises.
+Avant de parler du Web3, il faut comprendre comment nous en sommes arrivés là.
 
 <Divider />
 
@@ -26,34 +27,34 @@ En 1989, au CERN, à Genève, Tim Berners-Lee était occupé à développer les
 
 Les premiers pas de la création de Berners-Lee, connue aujourd'hui sous le nom de "Web 1.0", se sont déroulés approximativement entre 1990 et 2004. Le Web 1.0 était principalement constitué de sites Web statiques appartenant à des entreprises, et l'interaction entre les utilisateurs était quasi inexistante - les individus produisaient rarement du contenu - ce qui lui a valu d'être connu sous le nom de Web en lecture seule.
 
-![Architecture client-serveur représentant le Web 1.0](./web1.png)
+![Architecture client-serveur, représentant le Web 1.0](./web1.png)
 
-### Web 2.0 : lecture/écriture (2004-maintenant) {#web2}
+### Web 2.0 : Lecture/écriture (2004-aujourd'hui) {#web2}
 
 La période Web 2.0 a commencé en 2004 avec l'émergence des plateformes de médias sociaux. Au lieu d'une lecture seule, le web a évolué pour être en lecture-écriture. Au lieu de fournir du contenu aux utilisateurs, les entreprises ont également commencé à fournir des plateformes pour partager du contenu généré par les utilisateurs et s'engager dans des interactions entre utilisateurs. À mesure que de plus en plus de gens sont arrivés en ligne, une poignée de grandes entreprises ont commencé à contrôler une quantité disproportionnée du trafic et de la valeur générés sur le web. Le Web 2.0 a également donné naissance au modèle de revenus axé sur la publicité. Bien que les utilisateurs puissent créer du contenu, ils n'en sont pas propriétaires ou ne bénéficient pas de sa monétisation.
 
-![Architecture client-serveur représentant le Web 2.0](./web2.png)
+![Architecture client-serveur, représentant le Web 2.0](./web2.png)
 
 <Divider />
 
-## Web 3.0 : Read-Write-Own (Lire-Écrire-Posséder) {#web3}
+## Web 3.0 : Lecture-écriture-possession {#web3}
 
-Les prémisses du « Web 3.0 » ont été élaborés par le co-fondateur d'[Ethereum](/what-is-ethereum/) Gavin Wood, peu après le lancement d'Ethereum en 2014. Gavin a mis en mots une solution à un problème que beaucoup d'adopteurs précoces de crypto-monnaies ressentaient : le Web exigeait trop de confiance. En d'autres termes, la majeure partie du Web que les gens connaissent et utilisent aujourd'hui repose sur la confiance en une poignée d'entreprises privées qui agissent dans l'intérêt du public.
+La prémisse du « Web 3.0 » a été inventée par Gavin Wood, cofondateur d'[Ethereum](/what-is-ethereum/), peu après le lancement d'Ethereum en 2014. Gavin a mis en mots une solution à un problème que beaucoup d'adopteurs précoces de crypto-monnaies ressentaient : le Web exigeait trop de confiance. En d'autres termes, la majeure partie du Web que les gens connaissent et utilisent aujourd'hui repose sur la confiance en une poignée d'entreprises privées qui agissent dans l'intérêt du public.
 
-![Architecture de nœud décentralisée, représentant Web3](./web3.png)
+![Architecture de nœuds décentralisée, représentant Web3](./web3.png)
 
 ### Qu'est-ce que Web3 ? {#what-is-web3}
 
-Web3 est devenu un terme fourre-tout pour la vision d'un nouvel et meilleur internet. Web3 utilise des blockchains, des cryptomonnaies et des NFT pour rendre le pouvoir aux utilisateurs sous forme de propriété. [Un post de 2021 sur Twitter](https://twitter.com/j1mmyeth/status/1459003044067258370) le résume parfaitement : Web1 était en lecture seule, Web2 est en lecture/écriture, Web3 sera lu/écrit/possédé.
+Web3 est devenu un terme fourre-tout pour la vision d'un nouvel et meilleur internet. Web3 utilise des blockchains, des cryptomonnaies et des NFT pour rendre le pouvoir aux utilisateurs sous forme de propriété. [Un post de 2020 sur Twitter](https://twitter.com/himgajria/status/1266415636789334016) le résume parfaitement : Web1 était en lecture seule, Web2 est en lecture/écriture, et Web3 sera lu/écrit/possédé.
 
-#### Principes fondamentaux du Web3 {#core-ideas}
+#### Idées fondamentales du Web3 {#core-ideas}
 
 Bien qu'il soit difficile de fournir une définition stricte de ce qu'est le Web3, quelques principes fondamentaux guident sa création.
 
-- **Le Web3 est décentralisé :** au lieu que de larges pans de l'internet soient détenus et contrôlés par quelques entités centralisées, la propriété est distribuée entre ses créateurs et ses utilisateurs.
-- **Le Web3 est ouvert :** tout le monde a un accès égal pour contribuer au Web3, et personne ne peut être exclu.
-- **Le Web3 supporte les paiements natifs :** il utilise la cryptomonnaie pour dépenser et virer de l'argent en ligne, au lieu de s'appuyer sur l'infrastructure obsolète des banques et des processeurs de paiement.
-- **Le Web3 est « trustless » :** il fonctionne en utilisant des mesures incitatives et des mécanismes économiques au lieu de se fier à des tiers de confiance.
+- **Le Web3 est décentralisé :** au lieu que de larges pans d'Internet soient contrôlés et détenus par des entités centralisées, la propriété est répartie entre ses créateurs et ses utilisateurs.
+- **Le Web3 est sans permission :** tout le monde dispose d'un accès égal pour participer au Web3, et personne n'est exclu.
+- **Le Web3 intègre des paiements natifs :** il utilise la cryptomonnaie pour dépenser et envoyer de l'argent en ligne au lieu de s'appuyer sur l'infrastructure obsolète des banques et des processeurs de paiement.
+- **Le Web3 est sans confiance :** il fonctionne à l'aide d'incitations et de mécanismes économiques au lieu de dépendre de tiers de confiance.
 
 ### Pourquoi le Web3 est-il important ? {#why-is-web3-important}
 
@@ -63,14 +64,14 @@ Bien que les fonctionnalités clés du Web3 ne soient pas isolées et ne rentren
 
 Le Web3 vous donne la propriété de vos actifs numériques de façon inégalée. Par exemple, disons que vous jouez à un jeu web2. Si vous achetez un objet dans le jeu, il est lié directement à votre compte. Si les créateurs du jeu suppriment votre compte, vous perdrez ces objets. Ou, si vous arrêtez de jouer au jeu, vous perdez la valeur que vous avez investie dans vos objets pendant que vous jouiez.
 
-Le Web3 permet la propriété directe via les [jetons non-fongibles (NFT)](/glossary/#nft). Personne, pas même les créateurs du jeu, n'a le pouvoir de vous retirer votre propriété. En outre, si vous vous arrêtez de jouer, vous pouvez vendre ou échanger vos objets en jeu sur des marchés ouverts et récupérer leur valeur.
+Le Web3 permet la propriété directe par le biais de [jetons non fongibles (NFTs)](/glossary/#nft). Personne, pas même les créateurs du jeu, n'a le pouvoir de vous retirer votre propriété. En outre, si vous vous arrêtez de jouer, vous pouvez vendre ou échanger vos objets en jeu sur des marchés ouverts et récupérer leur valeur. Explorez les [jeux en chaîne](/gaming/) pour voir cela en action.
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
 <AlertContent className="flex-row items-center justify-between">
   <div>En savoir plus sur les NFT</div>
   <ButtonLink href="/nft/">
-    Plus d'infos sur les NFT
+    En savoir plus sur les NFT
   </ButtonLink>
 </AlertContent>
 </Alert>
@@ -85,18 +86,18 @@ Sur Web3, vos données vivent sur la blockchain. Lorsque vous décidez de quitte
 
 Le Web 2.0 exige que les créateurs de contenu fassent confiance aux plateformes pour ne pas modifier les règles, mais la résistance à la censure est une fonctionnalité native d'une plateforme Web3.
 
-#### Organisation autonome décentralisée (DAO) {#daos}
+#### Organisations autonomes décentralisées (DAO) {#daos}
 
 En plus de posséder vos données sur le Web3, vous pouvez posséder la plateforme en tant que groupe, en utilisant des jetons qui agissent comme des parts dans une entreprise. Les DAO vous permettent de coordonner la propriété décentralisée d'une plateforme et de prendre des décisions concernant son futur.
 
-Les DAO sont définies techniquement comme des [contrats intelligents](/glossary/#smart-contract) convenus qui automatisent les prises de décision décentralisées sur un ensemble de ressources (jetons). Les utilisateurs disposant de jetons votent sur la manière dont les ressources sont dépensées, et le code exécute automatiquement le résultat du vote.
+Les DAO sont techniquement définies comme des [contrats intelligents](/glossary/#smart-contract) convenus qui automatisent la prise de décision décentralisée sur un ensemble de ressources (jetons). Les utilisateurs disposant de jetons votent sur la manière dont les ressources sont dépensées, et le code exécute automatiquement le résultat du vote.
 
 Le fait est toutefois que les gens définissent de nombreuses communautés Web3 comme étant des DAO. Ces communautés ont toutes des niveaux différents de décentralisation et d'automatisation par code. Actuellement, nous explorons ce que sont les DAO et comment elles pourraient évoluer à l'avenir.
 
 <Alert variant="update">
 <AlertEmoji text=":eyes:"/>
 <AlertContent className="flex-row items-center justify-between">
-  <div>En savoir plus sur les DAO</div>
+  <div>En savoir plus sur les DAOs</div>
   <ButtonLink href="/dao/">
     En savoir plus sur les DAO
   </ButtonLink>
@@ -107,33 +108,34 @@ Le fait est toutefois que les gens définissent de nombreuses communautés Web3
 
 Normalement, vous créez un compte pour chaque plateforme que vous utilisez. Par exemple, vous pourriez avoir un compte Twitter, un compte YouTube et un compte Reddit. Vous voulez changer votre nom tel qu'il s'affiche ou votre photo de profil ? Vous devez le faire sur tous les comptes. Vous pouvez utiliser des connexions avec les réseaux sociaux dans certains cas, mais cela pose un problème bien connu : la censure. En un seul clic, ces plateformes peuvent vous bloquer l'accès à toute votre vie en ligne. Pire encore, de nombreuses plates-formes exigent que vous leur fassiez confiance en leur confiant des informations personnelles pour créer un compte.
 
-Le Web3 résout ces problèmes en vous permettant de contrôler votre identité digitale avec une adresse Ethereum et un profil de [service de nom Ethereum (ENS)](/glossary/#ens). Utiliser une adresse Ethereum offre un moyen de connexion unique à toutes les plateformes qui est sûr, résistant à la censure et anonyme.
+Le Web3 résout ces problèmes en vous permettant de contrôler votre identité numérique avec une adresse Ethereum et un profil [Ethereum Name Service (ENS)](/glossary/#ens). Utiliser une adresse Ethereum offre un moyen de connexion unique à toutes les plateformes qui est sûr, résistant à la censure et anonyme.
 
 ### Paiements natifs {#native-payments}
 
-L'infrastructure de paiement sur le Web2 repose sur les banques et les processeurs de paiement, excluant les personnes sans compte bancaire ou les personnes qui vivent dans le mauvais pays. Le Web3 utilise des jetons comme [ETH](/glossary/#ether) pour envoyer de l'argent directement depuis un navigateur et ne nécessite pas de tiers de confiance.
+L'infrastructure de paiement sur le Web2 repose sur les banques et les processeurs de paiement, excluant les personnes sans compte bancaire ou les personnes qui vivent dans le mauvais pays.
+Le Web3 utilise des jetons comme l'[ETH](/glossary/#ether) pour envoyer de l'argent directement dans le navigateur et ne nécessite aucun tiers de confiance.
 
 <ButtonLink href="/eth/">
-  Autres informations sur ETH
+  En savoir plus sur l'ETH
 </ButtonLink>
 
-## Limitations du Web3 {#web3-limitations}
+## Limites du Web3 {#web3-limitations}
 
 Malgré les nombreux avantages du Web3 dans sa forme actuelle, il existe encore de nombreuses limites que l'écosystème doit dépasser pour pouvoir prospérer.
 
 ### Accessibilité {#accessibility}
 
-Des fonctionnalités importantes du Web3, comme Sign-in with Ethereum (siwe), sont déjà disponibles gratuitement pour tout le monde. Mais le coût relatif des transactions reste encore élevé pour beaucoup de personnes. Le Web3 est moins susceptible d'être utilisé dans les pays moins riches et en développement, en raison de frais de transaction élevés. Sur Ethereum, ces défis sont résolus par [la feuille de route](/roadmap/) et [les solutions de mise à l'échelle de la couche 2](/glossary/#layer-2). La technologie est prête, mais les solutions de niveau 2 doivent être plus largement adoptées pour rendre le Web3 accessible à tous.
+Des fonctionnalités importantes du Web3, comme Sign-in with Ethereum (siwe), sont déjà disponibles gratuitement pour tout le monde. Mais le coût relatif des transactions reste encore élevé pour beaucoup de personnes. Le Web3 est moins susceptible d'être utilisé dans les pays moins riches et en développement, en raison de frais de transaction élevés. Sur Ethereum, ces défis sont en cours de résolution grâce à [la feuille de route](/roadmap/) et aux [solutions de mise à l'échelle de couche 2](/glossary/#layer-2). La technologie est prête, mais les solutions de niveau 2 doivent être plus largement adoptées pour rendre le Web3 accessible à tous.
 
 ### Expérience utilisateur {#user-experience}
 
-La barrière technique à l'entrée sur le Web3 est actuellement trop élevée. Les utilisateurs doivent comprendre les problèmes de sécurité, comprendre la documentation technique complexe et naviguer dans des interfaces utilisateur non intuitives. Les [éditeurs de portefeuilles](/wallets/find-wallet/), en particulier, y travaillent, mais davantage d'avancées seront nécessaires pour que le Web3 soit adopté massivement.
+La barrière technique à l'entrée sur le Web3 est actuellement trop élevée. Les utilisateurs doivent comprendre les problèmes de sécurité, comprendre la documentation technique complexe et naviguer dans des interfaces utilisateur non intuitives. [Les fournisseurs de portefeuilles](/wallets/find-wallet/), en particulier, travaillent à résoudre ce problème, mais davantage de progrès sont nécessaires avant que le Web3 ne soit adopté massivement.
 
-### Formation {#education}
+### Éducation {#education}
 
-Le Web3 introduit de nouveaux paradigmes qui nécessitent l'apprentissage de modèles mentaux différents de ceux utilisés sur le Web2.0. Un effort éducatif similaire a été consenti tandis que le Web1.0 gagnait en popularité à la fin des années 1990. Les partisans de la toile mondiale ont utilisé tout un tas de techniques pour éduquer le public, allant de simples métaphores (autoroutes de l'information, navigateurs, surfer sur le web) jusqu'à des [programmes télévisés](https://www.youtube.com/watch?v=SzQLI7BxfYI). Le Web3 n'est pas difficile, mais il est différent. Les initiatives éducatives informant les utilisateurs du Web2 de ces paradigmes propres au Web3 sont vitales pour son succès.
+Le Web3 introduit de nouveaux paradigmes qui nécessitent l'apprentissage de modèles mentaux différents de ceux utilisés sur le Web2.0. Un effort d'éducation similaire a eu lieu lorsque le Web1.0 gagnait en popularité à la fin des années 1990 ; les partisans du World Wide Web ont utilisé toute une série de techniques pédagogiques pour instruire le public, allant de métaphores simples (l'autoroute de l'information, les navigateurs, surfer sur le Web) à des [émissions de télévision](https://www.youtube.com/watch?v=SzQLI7BxfYI). Le Web3 n'est pas difficile, mais il est différent. Les initiatives éducatives informant les utilisateurs du Web2 de ces paradigmes propres au Web3 sont vitales pour son succès.
 
-Ethereum.org contribue à l'éducation Web3 par le biais de son [Programme de Traduction](/contributing/translation-program/) visant à traduire les contenus Ethereum importants dans autant de langues que possible.
+Ethereum.org contribue à l'éducation sur le Web3 par le biais de notre [Programme de traduction](/contributing/translation-program/), qui vise à traduire le contenu important d'Ethereum dans le plus de langues possible.
 
 ### Infrastructure centralisée {#centralized-infrastructure}
 
@@ -145,23 +147,23 @@ Le Web3 est un écosystème jeune et en pleine évolution. Gavin Wood a inventé
 
 Nous n'en sommes qu'au début de la création d'un meilleur Web avec le Web3, mais l'avenir du Web se fera plus radieux à mesure que nous continuerons d'améliorer l'infrastructure qui le supportera.
 
-## Comment puis-je m'impliquer ? {#get-involved}
+## Comment puis-je participer ? {#get-involved}
 
 - [Obtenir un portefeuille](/wallets/)
 - [Trouver une communauté](/community/)
-- [Explorer des applications Web3](/apps/)
+- [Explorer les applications Web3](/apps/)
 - [Rejoindre une DAO](/dao/)
-- [Construire sur le Web3](/developers/)
+- [Développer sur le Web3](/developers/)
 
-## Lectures complémentaires {#further-reading}
+## En savoir plus {#further-reading}
 
 Le Web3 n’est pas strictement défini. Plusieurs participants de la Communauté ont des points de vue différents à ce sujet. Voici quelques-uns d'entre eux :
 
-- [Qu'est-ce que le Web3? L'Internet décentralisé du futur expliqué](https://www.freecodecamp.org/news/what-is-web3) – _Nader Dabit_
+- [Qu'est-ce que le Web3? [L'Internet décentralisé du futur expliqué](https://www.freecodecamp.org/news/what-is-web3) – _Nader Dabit_
 - [Comprendre le Web 3](https://medium.com/l4-media/making-sense-of-web-3-c1a9e74dcae) – _Josh Stark_
-- [Importance du Web3](https://future.a16z.com/why-web3-matters/) — _Chris Dixon_
+- [Pourquoi le Web3 est important](https://a16zcrypto.com/posts/article/why-web3-matters/) — _Chris Dixon_
 - [Pourquoi la décentralisation est importante](https://onezero.medium.com/why-decentralization-matters-5e3f79f7638e) - _Chris Dixon_
-- [Panorama du Web3](https://a16z.com/wp-content/uploads/2021/10/The-web3-Readlng-List.pdf) – _a16z_
-- [Débat sur le Web3](https://www.notboring.co/p/the-web3-debate) – _Packy McCormick_
+- [Le paysage du Web3](https://a16z.com/wp-content/uploads/2021/10/The-web3-Readlng-List.pdf) – _a16z_
+- [Le débat sur le Web3](https://www.notboring.co/p/the-web3-debate) – _Packy McCormick_
 
 <QuizWidget quizKey="web3" />
diff --git a/public/content/translations/fr/what-are-apps/index.md b/public/content/translations/fr/what-are-apps/index.md
new file mode 100644
index 00000000000..3591ce8ee91
--- /dev/null
+++ b/public/content/translations/fr/what-are-apps/index.md
@@ -0,0 +1,80 @@
+---
+title: applications Ethereum
+metaTitle: "Applications Ethereum | Applications décentralisées sur Ethereum"
+description: "Les Applications sur Ethereum sont gratuites, globales et utilisent une Blockchain publique au lieu de serveurs privés. Ceci signifie qu'il est possible d'utiliser le même compte dans chaque projet et maintenir sa vie privée."
+lang: fr
+template: use-cases
+emoji: ":handshake:"
+sidebarDepth: 2
+showDropdown: false
+image: /images/doge-computer.png
+summary: "Les Applications sur Ethereum sont gratuites, globales et utilisent une Blockchain publique au lieu de serveurs privés. Ceci signifie qu'il est possible d'utiliser le même compte dans chaque projet et maintenir sa vie privée."
+---
+
+## Applications avec superpouvoirs {#apps-with-superpowers}
+
+Les applications Ethereum peuvent être vues comme des applications ordinaires. Cependant, en coulisses elles ont quelques qualités spéciales.
+
+Une fois qu'une application est publiée sur la Blockchain Ethereum, il n'est plus possible de la stopper. Ceci parce que le réseau Ethereum fonctionne de manière décentralisée sur des milliers d'ordinateurs à travers le monde. Personne ne peut mettre hors service les applications exécutées sur Ethereum, car il n’y a pas de serveur unique à cibler. Ethereum est également neutre et donc n'importe qui, n'importe où dans le monde, peut l'utiliser ou même s'y connecter et y créer ses modifications.
+
+## Qu'est-ce qu'une dApp? {#what-is-a-dapp}
+
+Les applications Ethereum ont leur logique exécutée sur la blockchain Ethereum plutôt que sur des serveurs centralisés. C'est pourquoi on les appelle souvent applications décentralisées ou dApps en abrégé.
+
+<CardGrid>
+  <Card title="Plus confidentiel" emoji=":detective:" description="Il vous suffit d'un portefeuille Ethereum pour utiliser n'importe quelle dapp. Vos données personnelles ne sont pas requises. C'est l'Internet tel qu'il aurait toujours dû être."/>
+  <Card title="Accessible partout" emoji="🌍" description="Les dapps ne sont pas régies par les règles des régions ou des boutiques d'applications. Votre accès dépend d'une connexion Internet, et non de l'endroit où vous vivez." />
+  <Card title="Services moins chers" emoji=":handshake:" description="Les dapps sont peer-to-peer. L'absence d'intermédiaires qui prélèvent une commission signifie des services moins chers." />
+</CardGrid>
+
+## Pourquoi est-ce important {#why-does-this-matter}
+
+Les applications Ethereum peuvent faire des choses qui ne sont tout simplement pas possibles avec les applications traditionnelles. C’est comme prêter de l’argent à un parfait inconnu avec la garantie que vous récupérerez votre argent, plus les intérêts. Sans payer un intermédiaire « digne de confiance », comme un avocat ou un notaire, pour gérer la transaction.
+
+Il existe des applications pour tout : jeux, finances, travail, messagerie, stockage et bien plus encore. Avec la plupart des applications, vous n’êtes pas soumis à des publicités ni limité par un accès restreint.
+
+Tout ce dont vous avez besoin est un portefeuille Ethereum et un peu d'ETH pour commencer à utiliser n'importe quelle application Ethereum.
+
+## Comment cela fonctionne-t-il? {#how-does-it-work}
+
+Les applications sont alimentées par des contrats intelligents : des morceaux de code qui sont enregistrés et fonctionnent sur la blockchain Ethereum. Contrairement aux applications traditionnelles, ces applications n’ont pas besoin d’une entreprise en informatique pour les faire fonctionner.
+
+| Fonctionnalité                        | Applications traditionnelles         | Applications Ethereum                 |
+| ------------------------------------- | ------------------------------------ | ------------------------------------- |
+| **Qui les contrôle ?**                | Une entreprise                       | Personne                              |
+| **fonctionne sur**                    | Les serveurs d'une entreprise privée | La Blockchain Ethereum publique       |
+| **Peut-elle être censurée ?**         | Oui                                  | Non                                   |
+| **À qui appartiennent vos données ?** | Habituellement pas vous              | Vous êtes propriétaire de vos données |
+
+<WhatAreAppsStories />
+
+<div className="w-full md:w-1/2 mx-auto md:mx-0">
+
+![](developers-eth-blocks.png)
+</div>
+
+## Les applications Ethereum sont comme des Legos {#ethereum-apps-are-like-legos}
+
+Quand les applications sont toutes construites sur Ethereum, elles sont alors aussi toutes compatibles. Un jeton pour une application fonctionnera aussi sur une autre complètement différente. C’est comme pouvoir publier des tweets sur votre mur Facebook. En fait, vous pouvez souvent réutiliser le même profil dans de nombreuses applications Ethereum différentes sans avoir besoin de vous inscrire partout séparément.
+
+<BrowseApps />
+
+## En savoir plus {#further-reading}
+
+- [Ethereum pour les débutants](/what-is-ethereum)
+- [Qu’est-ce qu’un contrat intelligent ?](/developers/docs/smart-contracts/)
+- [Documentation technique des applications décentralisées](/developers/docs/dapps/)
+
+## Foire aux questions {#faq}
+
+<ExpandableCard title="Que signifie dapp ?" visible>
+  <p>DApp signifie application décentralisée. Ce sont des applications construites sur des réseaux blockchain comme Ethereum. On les appelle décentralisés car le réseau sous-jacent sur lequel elles fonctionnent est décentralisé.</p>
+</ExpandableCard>
+
+<ExpandableCard title="Puis-je acheter des cryptomonnaies sur une dapp ?" visible>
+  <p>Certaines applications vous permettent d'échanger ou d'acheter des jetons cryptographiques, mais toutes les applications ne sont pas destinées à cela. Si vous cherchez à acheter vos premiers jetons, visitez [Get ETH](/get-eth).</p>
+</ExpandableCard>
+
+<ExpandableCard title="Quel est le meilleur portefeuille crypto ?" visible>
+  <p>Votre portefeuille cryptographique vous permet de conserver vos jetons et de gérer votre compte Ethereum. Il existe de nombreux portefeuilles formidables, chacun ayant un objectif différent. Pour savoir quel portefeuille vous convient le mieux, visitez notre [liste de portefeuilles](/wallets/find-wallet).</p>
+</ExpandableCard>
\ No newline at end of file
diff --git a/public/content/translations/fr/whitepaper/index.md b/public/content/translations/fr/whitepaper/index.md
index 0aded9b348b..d34904c1aac 100644
--- a/public/content/translations/fr/whitepaper/index.md
+++ b/public/content/translations/fr/whitepaper/index.md
@@ -1,39 +1,39 @@
 ---
 title: Livre blanc Ethereum
-description: Document d'introduction à Ethereum, publié en 2013 avant son lancement.
+description: "Document d'introduction à Ethereum, publié en 2013 avant son lancement."
 lang: fr
 sidebarDepth: 2
 hideEditButton: true
 ---
 
-# Livre blanc Ethereum {#ethereum-whitepaper}
+# Livre blanc d'Ethereum {#ethereum-whitepaper}
 
 _Ce document d'introduction a été publié pour la première fois en 2014 par Vitalik Buterin, le fondateur d'[Ethereum](/what-is-ethereum/), avant le lancement du projet en 2015. Il convient de noter qu'Ethereum, comme nombre de projets open source gérés de façon communautaire, a évolué depuis sa création._
 
-_Même s'il date déjà de plusieurs années, nous conservons ce document car il constitue une référence utile et une représentation précise d'Ethereum et de la vision du projet. Pour plus d'infos sur les derniers développements d'Ethereum et la façon dont les modifications du protocole sont mises en œuvre, nous vous recommandons de lire [ce guide](/learn/)._
+_Même s'il date déjà de plusieurs années, nous conservons ce document car il constitue une référence utile et une représentation précise d'Ethereum et de la vision du projet. Pour en savoir plus sur les derniers développements d'Ethereum et sur la manière dont les modifications du protocole sont apportées, nous vous recommandons [ce guide](/learn/)._
 
-[Les chercheurs et universitaires à la recherche d'une version historique ou canonique du livre blanc [à partir de décembre 2014] peuvent utiliser ce PDF.](./whitepaper-pdf/Ethereum_Whitepaper_-_Buterin_2014.pdf)
+[Les chercheurs et universitaires à la recherche d'une version historique ou canonique du livre blanc [de décembre 2014] devraient utiliser ce PDF.](./whitepaper-pdf/Ethereum_Whitepaper_-_Buterin_2014.pdf)
 
-## Une plateforme d'applications décentralisées et de contrats intelligents de nouvelle génération {#a-next-generation-smart-contract-and-decentralized-application-platform}
+## Une plateforme de contrats intelligents et d'applications décentralisées de nouvelle génération {#a-next-generation-smart-contract-and-decentralized-application-platform}
 
-Le développement du Bitcoin par Satoshi Nakamoto en 2009 a souvent été salué comme une évolution radicale de la monnaie et des devises. Il s'agissait en effet du premier exemple d'actif numérique n'ayant simultanément aucune garantie ni "[valeur intrinsèque](http://bitcoinmagazine.com/8640/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it/)", et aucun contrôleur ni émetteur centralisé. L'attention est cependant en train de se porter sur un autre aspect (sans doute plus important) du Bitcoin : la technologie blockchain sous-jacente comme outil de consensus distribué. Parmi les autres applications de la technologie blockchain fréquemment citées, on trouve l'utilisation d'actifs numériques pour représenter des monnaies personnalisées et des instruments financiers ("[Colored coins](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)"), la propriété d'appareils physiques sous-jacents ("[Smart property](https://en.bitcoin.it/wiki/Smart_Property)"), des actifs non fongibles comme les noms de domaine ("[Namecoin](http://namecoin.org)"), ainsi que des applications plus complexes dans lesquelles des actifs numériques sont directement contrôlés par une portion de code exécutant des règles diverses ("[Contrats intelligents](http://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/idea.html)"), ou encore des "[organisations autonomes décentralisées" (ou DAO)](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/) basées sur la blockchain. Ce qu'Ethereum souhaite proposer, c'est une blockchain avec un véritable langage de programmation intégré, Turing-complet, pouvant être utilisé pour créer des « contrats » susceptibles d'encoder des fonctions de transition d'état arbitraires. Cela permettra aux utilisateurs de créer n'importe lequel des systèmes cités ci-dessus, ainsi que beaucoup d'autres que nous n'avons pas encore imaginés, le tout en quelques lignes de code.
+Le développement de Bitcoin par Satoshi Nakamoto en 2009 a souvent été salué comme une évolution radicale de la monnaie et de la devise, étant le premier exemple d'un actif numérique qui n'a simultanément aucune garantie ou « [valeur intrinsèque](https://bitcoinmagazine.com/culture/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it) », et aucun émetteur ou contrôleur centralisé. L'attention est cependant en train de se porter sur un autre aspect (sans doute plus important) du Bitcoin : la technologie blockchain sous-jacente comme outil de consensus distribué. Les applications alternatives fréquemment citées de la technologie blockchain incluent l'utilisation d'actifs numériques sur la blockchain pour représenter des devises et des instruments financiers personnalisés (les « [pièces colorées](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit) »), la propriété d'un appareil physique sous-jacent (la « [propriété intelligente](https://en.bitcoin.it/wiki/Smart_Property) »), des actifs non fongibles tels que les noms de domaine (« [Namecoin](http://namecoin.org) »), ainsi que des applications plus complexes impliquant que des actifs numériques soient directement contrôlés par un morceau de code implémentant des règles arbitraires (les « [contrats intelligents](http://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/idea.html) ») ou même des « [organisations autonomes décentralisées](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/) » (DAO) basées sur la blockchain. Ce qu'Ethereum souhaite proposer, c'est une blockchain avec un véritable langage de programmation intégré, Turing-complet, pouvant être utilisé pour créer des « contrats » susceptibles d'encoder des fonctions de transition d'état arbitraires. Cela permettra aux utilisateurs de créer n'importe lequel des systèmes cités ci-dessus, ainsi que beaucoup d'autres que nous n'avons pas encore imaginés, le tout en quelques lignes de code.
 
-## Introduction au Bitcoin et aux concepts existants {#introduction-to-bitcoin-and-existing-concepts}
+## Introduction à Bitcoin et aux concepts existants {#introduction-to-bitcoin-and-existing-concepts}
 
 ### Historique {#history}
 
-Le concept de monnaie numérique décentralisée, ainsi que des applications alternatives comme les registres de propriété, font l'objet d'études depuis des décennies. Les protocoles anonymes de monnaie électronique des années 1980 et 1990, principalement fondés sur une primitive cryptographique appelée Chaumian Blinding (signature aveugle), ont fourni une monnaie à un niveau de confidentialité élevé, mais leurs protocoles sous-jacents ont largement échoué à se populariser en raison de leur dépendance à un intermédiaire centralisé. En 1998, la [b-money](http://www.weidai.com/bmoney.txt) de Wei Dai fut la première proposition d'une idée de créer une monnaie via la résolution d'un calcul cryptographique ainsi que l'idée d'un consensus décentralisé, mais la proposition n'était pas assez étayée quant à la manière d'implémenter un consens décentralisé. En 2005, Hal Finney présenta le concept de "[preuves de travail réutilisables](https://nakamotoinstitute.org/finney/rpow/)", qui reprenait les idées de b-money et des puzzles cryptographiques Hashcash d'Adam Back, gourmands en ressources informatiques, pour créer un concept de cryptomonnaie, mais sans parvenir à une solution idéale puisqu'il nécessitait un système informatique de confiance comme backend. En 2009, une monnaie décentralisée fut implémentée pour la première fois par Satoshi Nakamoto, qui combinait des primitives reconnues utilisant la cryptographie asymétrique pour gérer la propriété, à un algorithme de consensus, le « proof-of-work », pour garder une trace des détenteurs de monnaie.
+Le concept de monnaie numérique décentralisée, ainsi que des applications alternatives comme les registres de propriété, font l'objet d'études depuis des décennies. Les protocoles anonymes de monnaie électronique des années 1980 et 1990, principalement fondés sur une primitive cryptographique appelée Chaumian Blinding (signature aveugle), ont fourni une monnaie à un niveau de confidentialité élevé, mais leurs protocoles sous-jacents ont largement échoué à se populariser en raison de leur dépendance à un intermédiaire centralisé. En 1998, le [b-money](http://www.weidai.com/bmoney.txt) de Wei Dai a été la première proposition à introduire l'idée de créer de la monnaie en résolvant des énigmes informatiques ainsi que le consensus décentralisé, mais la proposition était peu détaillée sur la manière dont le consensus décentralisé pouvait réellement être mis en œuvre. En 2005, Hal Finney a présenté le concept de « [preuves de travail réutilisables](https://nakamotoinstitute.org/finney/rpow/) », un système qui reprend les idées du b-money et les énigmes Hashcash d'Adam Back, difficiles à résoudre sur le plan informatique, pour créer un concept de cryptomonnaie, mais qui, une fois de plus, n'a pas atteint l'idéal en s'appuyant sur l'informatique de confiance comme backend. En 2009, une monnaie décentralisée fut implémentée pour la première fois par Satoshi Nakamoto, qui combinait des primitives reconnues utilisant la cryptographie asymétrique pour gérer la propriété, à un algorithme de consensus, le « proof-of-work », pour garder une trace des détenteurs de monnaie.
 
-Le mécanisme de la preuve de travail a été une réelle avancée dans ce domaine, car il a permis de résoudre simultanément deux problèmes. Premièrement, cela a fourni un algorithme de consensus simple et efficace, permettant aux noeuds du réseau de s'accorder collectivement sur un ensemble de mises à jour canonique sur l'état du registre de Bitcoin. Deuxièmement, cela a fourni un mécanisme permettant de participer librement au consensus, résolvant le problème politique de décider qui peut influer sur le consensus, tout en empêchant simultanément les attaques Sybil. Il y parvient en substituant un obstacle formel à la participation, comme l'obligation d'être enregistré en tant qu'entité unique sur une liste donnée, par une barrière économique : le poids d'un seul nœud dans le processus de vote par consensus est directement proportionnel à la puissance de calcul que celui-ci apporte. Depuis, une autre approche a été proposée, la _preuve d'enjeu_ (Proof of stake), qui calcule le poids d'un nœud proportionnellement à ses avoirs en monnaie et non pas à ses ressources de calcul. La discussion sur les mérites relatifs des deux approches dépasse la portée de ce document, mais il convient de noter que les deux peuvent être utilisées pour servir de colonne vertébrale à une cryptomonnaie.
+Le mécanisme de la preuve de travail a été une réelle avancée dans ce domaine, car il a permis de résoudre simultanément deux problèmes. Premièrement, cela a fourni un algorithme de consensus simple et efficace, permettant aux noeuds du réseau de s'accorder collectivement sur un ensemble de mises à jour canonique sur l'état du registre de Bitcoin. Deuxièmement, cela a fourni un mécanisme permettant de participer librement au consensus, résolvant le problème politique de décider qui peut influer sur le consensus, tout en empêchant simultanément les attaques Sybil. Il y parvient en substituant un obstacle formel à la participation, comme l'obligation d'être enregistré en tant qu'entité unique sur une liste donnée, par une barrière économique : le poids d'un seul nœud dans le processus de vote par consensus est directement proportionnel à la puissance de calcul que celui-ci apporte. Depuis, une approche alternative a été proposée, appelée _preuve d'enjeu_, qui calcule le poids d'un nœud comme étant proportionnel à ses avoirs en monnaie et non à ses ressources informatiques ; la discussion des mérites relatifs des deux approches dépasse le cadre de ce document, mais il convient de noter que les deux approches peuvent servir de colonne vertébrale à une cryptomonnaie.
 
-### Bitcoin en tant que système de transition d'état {#bitcoin-as-a-state-transition-system}
+### Bitcoin en tant que système de transition d'états {#bitcoin-as-a-state-transition-system}
 
-![Transition d'état Ethereum](./ethereum-state-transition.png)
+![Transition d'état d'Ethereum](./ethereum-state-transition.png)
 
-D'un point de vue technique, le registre d'une cryptomonnaie telle que le Bitcoin peut être considéré comme un système de transition d'état dans lequel il existe un « état », représentant le statut de propriété de tous les bitcoins existants, et une « fonction de transition d'état », qui associe un état et une transaction, et en fait résulter un nouvel état. Par exemple, dans un système bancaire classique, l'état est un bilan, une transaction est une demande de déplacer X $ de A vers B, et la fonction de transition d'état diminue la valeur du compte A de X $ et augmente la valeur du compte B de X $. Si le compte A a moins de X $ au départ, la fonction de transition d'état renvoie une erreur. On peut donc formellement définir :
+D'un point de vue technique, le registre d'une cryptomonnaie telle que le Bitcoin peut être considéré comme un système de transition d'état dans lequel il existe un « état », représentant le statut de propriété de tous les bitcoins existants, et une « fonction de transition d'état », qui associe un état et une transaction, et en fait résulter un nouvel état. Dans un système bancaire standard, par exemple, l'état est un bilan, une transaction est une demande de transfert de X $ de A à B, et la fonction de transition d'état réduit la valeur du compte de A de X $ et augmente la valeur du compte de B de X $. Si le compte de A a moins de X $ au départ, la fonction de transition d'état renvoie une erreur. On peut donc formellement définir :
 
 ```
-APPLY(S,TX) -> S' or ERROR
+APPLY(S,TX) -> S' ou ERREUR
 ```
 
 Dans le système bancaire défini ci-dessus :
@@ -50,100 +50,100 @@ APPLY({ Alice: $50, Marc: $50 },"send $70 from Alice to Marc") = ERROR
 
 Dans Bitcoin, l'« état » est l'ensemble de toutes les unités de compte (techniquement, les sorties de transaction non dépensées, « unspent transaction outputs » ou UTXO) qui ont été minées, mais pas encore dépensées, chaque UTXO ayant une valeur nominale et un propriétaire (défini par une adresse de 20 octets qui est en fait une clé cryptographique publique<sup>[fn1](#notes)</sup>). Une transaction comporte une ou plusieurs entrées, chacune contenant une référence à un UTXO existant et une signature cryptographique produite par la clé privée associée à l'adresse du propriétaire, ainsi qu'une ou plusieurs sorties, chacune comportant un nouvel UTXO à ajouter à l'état.
 
-La fonction de transition d'état `APPLY(S,TX) -> S'` peut grossièrement être définie comme suit :
+La fonction de transition d'états `APPLY(S,TX) -> S'` peut être définie grossièrement comme suit :
 
 <ol>
   <li>
     Pour chaque entrée dans <code>TX</code> :
     <ul>
     <li>
-        Si l'UTXO référencé n'est pas <code>S</code>, une erreur est renvoyée.
+        Si l'UTXO référencé n'est pas dans <code>S</code>, retourner une erreur.
     </li>
     <li>
-        Si la signature fournie ne correspond pas à celle du propriétaire de l'UTXO, une erreur est renvoyée.
+        Si la signature fournie ne correspond pas au propriétaire de l'UTXO, retourner une erreur.
     </li>
     </ul>
   </li>
   <li>
-    Si la somme de tous les UTXO d'entrée est inférieure à celle de tous les UTXO de sortie, une erreur est renvoyée.
+    Si la somme des dénominations de tous les UTXO d'entrée est inférieure à la somme des dénominations de tous les UTXO de sortie, retourner une erreur.
   </li>
   <li>
-    <code>S</code> est renvoyé avec tous les UTXO d'entrée supprimés et tous les UTXO de sortie ajoutés.
+    Retourner <code>S</code> avec tous les UTXO d'entrée supprimés et tous les UTXO de sortie ajoutés.
   </li>
 </ol>
 
-La première moitié de la première étape empêche les émetteurs de transaction de dépenser des unités de compte qui n'existent pas, la seconde moitié les empêche de dépenser les unités de compte d'autres personnes, et la deuxième étape assure que la valeur est préservée. Le protocole pour utiliser cela comme moyen de paiement est le suivant. Imaginons qu'Alice veuille envoyer 11,7 BTC à Marc. Alice va commencer par chercher un ensemble disponible d'UTXO qui lui appartiennent, pour un total d'au moins 11,7 BTC. En réalité, Alice ne pourra pas obtenir exactement 11,7 BTC. La plus petite somme qu'elle peut obtenir est 6+4+2=12. Elle crée alors une transaction avec ces trois entrées et deux sorties. La première sortie sera 11,7 BTC avec l'adresse de Marc comme propriétaire, et la seconde sortie représentera les 0,3 BTC de monnaie restante, dont elle est propriétaire.
+La première moitié de la première étape empêche les expéditeurs de transactions de dépenser des pièces qui n'existent pas, la seconde moitié de la première étape empêche les expéditeurs de transactions de dépenser les pièces d'autres personnes, et la deuxième étape assure la conservation de la valeur. Pour utiliser ceci pour le paiement, le protocole est le suivant. Supposons qu'Alice veuille envoyer 11,7 BTC à Bob. D'abord, Alice va chercher un ensemble d'UTXO disponibles qu'elle possède et qui totalisent au moins 11,7 BTC. En réalité, Alice ne pourra pas obtenir exactement 11,7 BTC ; disons que le plus petit montant qu'elle peut obtenir est 6+4+2=12. Elle crée alors une transaction avec ces trois entrées et deux sorties. La première sortie sera de 11,7 BTC avec l'adresse de Bob comme propriétaire, et la seconde sortie sera les 0,3 BTC restants de « monnaie », avec Alice elle-même comme propriétaire.
 
 ### Minage {#mining}
 
 ![Blocs Ethereum](./ethereum-blocks.png)
 
-Si nous avions accès à un service centralisé digne de confiance, il serait trivial d'implémenter ce système : il pourrait être codé exactement comme décrit plus haut, en utilisant le disque dur d'un serveur centralisé pour garder une trace de l'état. Avec Bitcoin, nous essayons toutefois de construire un système monétaire décentralisé et avons donc besoin de combiner le système de transition d'état avec un système de consensus afin de garantir que tout le monde est d'accord sur l'ordre des transactions. Le processus de consensus décentralisé de Bitcoin exige que les nœuds du réseau tentent en continu de produire des paquets de transactions appelés "blocs". Le réseau est destiné à créer un bloc toutes les dix minutes environ, chaque bloc contenant un horodatage, un nonce, une référence au bloc précédent (hachage ou hash) et une liste de toutes les transactions qui ont eu lieu depuis le bloc précédent. Au fil du temps, cela crée une "blockchain" continuelle, croissant sans cesse, qui se met perpétuellement à jour pour représenter l'état le plus récent du registre Bitcoin.
+Si nous avions accès à un service centralisé digne de confiance, ce système serait trivial à mettre en œuvre ; il pourrait simplement être codé exactement comme décrit, en utilisant le disque dur d'un serveur centralisé pour suivre l'état. Cependant, avec Bitcoin, nous essayons de construire un système de monnaie décentralisé, nous devrons donc combiner le système de transition d'états avec un système de consensus afin de nous assurer que tout le monde est d'accord sur l'ordre des transactions. Le processus de consensus décentralisé de Bitcoin exige que les nœuds du réseau tentent continuellement de produire des paquets de transactions appelés « blocs ». Le réseau est conçu pour produire environ un bloc toutes les dix minutes, chaque bloc contenant un horodatage, un nonce, une référence au (c.-à-d. le hachage du) bloc précédent et une liste de toutes les transactions qui ont eu lieu depuis le bloc précédent. Au fil du temps, cela crée une « blockchain » persistante, en croissance constante, qui se met à jour en permanence pour représenter le dernier état du registre Bitcoin.
 
-L'algorithme utilisé pour vérifier qu'un bloc est valide, exprimé dans ce paradigme, est le suivant :
+L'algorithme pour vérifier si un bloc est valide, exprimé dans ce paradigme, est le suivant :
 
 1. On vérifie que le bloc précédent référencé par le bloc existe et est valide.
 2. On vérifie que l'horodatage du bloc est supérieur à celui du précédent bloc<sup>[fn2](#notes)</sup> et qu'il n'excède pas 2 heures dans l'avenir.
 3. On vérifie que la preuve de travail du bloc est valide.
-4. `S[0]` doit être l'état à la fin du bloc précédent.
-5. On suppose que `TX` est la liste des transactions du bloc avec `n` transactions. Pour tout `i` dans `0...n-1`, alors `S[i+1] = APPLY(S[i],TX[i])` Si une application renvoie une erreur, sortie et valeur false renvoyée.
-6. La valeur true est renvoyée et `S[n]` est enregistré comme comme état à la fin de ce bloc.
+4. Soit `S[0]` l'état à la fin du bloc précédent.
+5. Supposons que `TX` est la liste des transactions du bloc avec `n` transactions. Pour tout `i` dans `0...n-1`, définissez `S[i+1] = APPLY(S[i],TX[i])` Si une application renvoie une erreur, quittez et retournez faux.
+6. Retourner vrai, et enregistrer `S[n]` comme l'état à la fin de ce bloc.
 
-Fondamentalement, chaque transaction du bloc doit fournir une transition d'état valide vers un nouvel état, à partir de ce qui était l'état conforme avant que la transaction ne soit exécutée vers le nouvel état. Notez que l'état n'est aucunement encodé dans le bloc. Ce n'est qu'une abstraction dont le nœud validateur doit se souvenir et il ne peut être calculé de façon sécurisée pour n'importe quel bloc qu'en partant de l'état d'origine et en y appliquant séquentiellement toutes les transactions de chaque bloc. Notez par ailleurs que l'ordre dans lequel le mineur inclut les transactions dans le bloc a de l'importance. S'il existe deux transactions A et B dans un bloc de telle façon que B dépense un UTXO créé par A, alors le bloc sera valable si A précède B, et non l'inverse.
+Essentiellement, chaque transaction dans le bloc doit fournir une transition d'état valide depuis ce qui était l'état canonique avant l'exécution de la transaction vers un nouvel état. Notez que l'état n'est en aucun cas encodé dans le bloc ; il s'agit d'une pure abstraction qui doit être mémorisée par le nœud de validation et qui ne peut être calculée (de manière sécurisée) pour n'importe quel bloc qu'en partant de l'état de genèse et en appliquant séquentiellement chaque transaction dans chaque bloc. De plus, notez que l'ordre dans lequel le mineur inclut les transactions dans le bloc est important ; s'il y a deux transactions A et B dans un bloc telles que B dépense un UTXO créé par A, alors le bloc sera valide si A vient avant B mais pas autrement.
 
-La seule condition de validité présente dans la liste ci-dessus qu'on ne trouve pas dans d'autres systèmes est l'exigence de "preuve de travail" (PoW). La condition précise est que le double hash SHA256 de chaque bloc, traité comme un nombre de 256 bits, doit être inférieur à une cible ajustée dynamiquement qui, à la rédaction de ce document, est d'environ 2<sup>187</sup>. L'objectif est de rendre "difficile" la création de blocs en terme de calculs, ce qui empêche les pirates effectuant une attaque Sybil de recréer toute la blockchain en leur faveur. SHA256 étant conçu comme une fonction pseudo-aléatoire complètement imprévisible, la seule façon de créer un bloc valide est de faire des essais et des corrections, en incrémentant le nonce de façon répétée pour voir si chaque nouveau hachage correspond.
+La seule condition de validité présente dans la liste ci-dessus qui ne se trouve pas dans d'autres systèmes est l'exigence de la « preuve de travail ». La condition précise est que le double hachage SHA256 de chaque bloc, traité comme un nombre de 256 bits, doit être inférieur à une cible ajustée dynamiquement, qui au moment de la rédaction de ce document est d'environ 2<sup>187</sup>. Le but est de rendre la création de blocs « difficile » d'un point de vue informatique, empêchant ainsi les attaquants Sybil de refaire toute la blockchain en leur faveur. SHA256 étant conçu comme une fonction pseudo-aléatoire complètement imprévisible, la seule façon de créer un bloc valide est de faire des essais et des corrections, en incrémentant le nonce de façon répétée pour voir si chaque nouveau hachage correspond.
 
-D'après l'objectif actuel de \~2<sup>187</sup>, le réseau doit faire une moyenne de \~2<sup>69</sup> essais avant de trouver un bloc valide. En général, la cible est recalibrée par le réseau tous les 2 016 blocs de sorte qu'en moyenne, un nouveau bloc est produit par un nœud du réseau toutes les dix minutes. Afin de compenser le travail de calcul des mineurs, chacun d'entre eux est en droit d'inclure pour chaque bloc miné une transaction qui lui octroie 25 BTC sortant de nulle part. En outre, si une transaction a une valeur totale d'entrées supérieure à celle des sorties, la différence revient également au mineur sous forme de "frais de transaction". Par ailleurs, il s'agit également du seul mécanisme par lequel les BTC sont émis, car l'état d'origine ne contenait aucune unité de compte.
+À la cible actuelle d'environ 2<sup>187</sup>, le réseau doit faire en moyenne environ 2<sup>69</sup> tentatives avant qu'un bloc valide soit trouvé ; en général, la cible est recalibrée par le réseau tous les 2016 blocs pour qu'en moyenne un nouveau bloc soit produit par un nœud du réseau toutes les dix minutes. Afin de compenser le travail de calcul des mineurs, chacun d'entre eux est en droit d'inclure pour chaque bloc miné une transaction qui lui octroie 25 BTC sortant de nulle part. De plus, si une transaction a une dénomination totale plus élevée dans ses entrées que dans ses sorties, la différence va également au mineur en tant que « frais de transaction ». Incidemment, c'est aussi le seul mécanisme par lequel les BTC sont émis ; l'état de genèse ne contenait aucune pièce.
 
-Afin de mieux comprendre le but du minage, nous allons examiner ce qui se passe en cas d'attaque malveillante. La cryptographie sous-jacente à Bitcoin étant connue pour être bien sécurisée, l'attaquant va cibler la partie du système Bitcoin qui n'est pas directement protégée par la cryptographie : l'ordre des transactions. La stratégie de l'attaquant est donc simple :
+Afin de mieux comprendre le but du minage, examinons ce qui se passe en cas d'attaquant malveillant. La cryptographie sous-jacente de Bitcoin étant connue pour être sécurisée, l'attaquant ciblera la seule partie du système Bitcoin qui n'est pas protégée directement par la cryptographie : l'ordre des transactions. La stratégie de l'attaquant est donc simple :
 
 1. Envoyer 100 BTC à un commerçant en échange d'un produit (de préférence, un bien numérique à livraison rapide).
 2. Attendre la livraison du produit.
 3. Produire une autre transaction en s'envoyant 100 BTC à lui-même.
 4. Essayer de convaincre le réseau que la transaction qu'il s'est envoyée à lui-même est celle réalisée en premier.
 
-Une fois l'étape (1) réalisée, un mineur inclura la transaction dans un bloc après quelques minutes. Par exemple, le bloc numéro 270000. Au bout d'environ une heure, cinq autres blocs auront été ajoutés à la chaîne après ce bloc, chacun d'entre eux pointant indirectement vers la transaction et ainsi, la "confirmant". À ce stade, le commerçant acceptera le paiement comme finalisé et livrera le produit. Partant du postulat qu'il s'agit d'un bien numérique, la livraison est instantanée. L'attaquant crée maintenant une autre transaction en s'envoyant 100 BTC à lui-même. S'il l'envoie simplement dans la nature, la transaction ne sera pas traitée : les mineurs vont tenter d'exécuter `APPLY(S,TX)` et remarqueront que `TX` consomme un UTXO qui n'est plus dans l'état. Au lieu de cela, l'attaquant crée donc une « fourche » (une scission) dans la blockchain en commençant par miner une autre version du bloc 270000 pointant vers le même bloc parent 269999, mais contenant la nouvelle transaction à la place de l'ancienne. Les données du bloc étant différentes, cela nécessite de refaire la preuve de travail. De plus, le hash de la nouvelle version du bloc 270000 de l'attaquant est différente, donc les blocs d'origine de 270001 à 270005 ne « pointent » pas vers lui. La chaîne d'origine et la nouvelle chaîne de l'attaquant sont donc bien complètement séparées. La règle étant que, dans le cas d'une fourche, c'est la plus longue blockchain qui est considérée comme la vraie, les mineurs légitimes travaillent donc sur la chaîne 270005 tandis que l'attaquant travaille seul sur la chaîne 270000. Pour que la blockchain de l'attaquant soit la plus longue, il aurait besoin d'avoir plus de puissance de calcul que le reste du réseau combiné afin de rattraper son retard (d'où l'attaque dite "de 51 %").
+Une fois l'étape (1) réalisée, un mineur inclura la transaction dans un bloc après quelques minutes. Par exemple, le bloc numéro 270000. Après environ une heure, cinq autres blocs auront été ajoutés à la chaîne après ce bloc, chacun de ces blocs pointant indirectement vers la transaction et la « confirmant » ainsi. À ce stade, le commerçant acceptera le paiement comme finalisé et livrera le produit ; comme nous supposons qu'il s'agit d'un bien numérique, la livraison est instantanée. Maintenant, l'attaquant crée une autre transaction s'envoyant les 100 BTC à lui-même. Si l'attaquant la diffuse simplement, la transaction ne sera pas traitée ; les mineurs essaieront d'exécuter `APPLY(S,TX)` et remarqueront que `TX` consomme un UTXO qui n'est plus dans l'état. Au lieu de cela, l'attaquant crée donc une « fourche » (une scission) dans la blockchain en commençant par miner une autre version du bloc 270000 pointant vers le même bloc parent 269999, mais contenant la nouvelle transaction à la place de l'ancienne. Parce que les données du bloc sont différentes, cela nécessite de refaire la preuve de travail. De plus, le hash de la nouvelle version du bloc 270000 de l'attaquant est différente, donc les blocs d'origine de 270001 à 270005 ne « pointent » pas vers lui. La chaîne d'origine et la nouvelle chaîne de l'attaquant sont donc bien complètement séparées. La règle étant que, dans le cas d'une fourche, c'est la plus longue blockchain qui est considérée comme la vraie, les mineurs légitimes travaillent donc sur la chaîne 270005 tandis que l'attaquant travaille seul sur la chaîne 270000. Pour que l'attaquant fasse de sa blockchain la plus longue, il devrait avoir plus de puissance de calcul que le reste du réseau combiné pour rattraper son retard (d'où l'« attaque des 51 % »).
 
 ### Arbres de Merkle {#merkle-trees}
 
-![SPV chez Bitcoin](./spv-bitcoin.png)
+![SPV dans Bitcoin](./spv-bitcoin.png)
 
-_À gauche : Il suffit de ne présenter qu'un petit nombre de nœuds dans un arbre de Merkle pour donner la preuve de la validité d'une branche._
+_À gauche : il suffit de présenter un petit nombre de nœuds dans un arbre de Merkle pour donner une preuve de la validité d'une branche._
 
-_À droite : Toute tentative de modifier quelque partie que ce soit d'un arbre de Merkle conduira forcément à une incohérence plus haut dans la chaîne._
+_À droite : toute tentative de modification d'une partie de l'arbre de Merkle entraînera une incohérence quelque part plus haut dans la chaîne._
 
-Une importante fonctionnalité d'évolutivité de Bitcoin est que le bloc est stocké dans une structure de données multiniveau. Le "hash" (ou hachage) d'un bloc n'est en fait que celui de l'en-tête du bloc, soit environ 200 octets de données contenant l'horodatage, le nonce, le hash du bloc précédent et le hash racine d'une structure de données appelée Arbre de Merkle, qui stocke toutes les transactions du bloc. Un arbre de Merkle est un type d'arbre binaire composé d'un ensemble de nœuds avec nombre de nœuds feuilles au bas de l'arbre contenant les données sous-jacentes, un ensemble de nœuds intermédiaires où chacun est le hash de ses deux enfants, et pour finir, un nœud racine unique, également formé à partir du hash de ses deux enfants, qui représente la "cime" de l'arbre. L'objectif de l'arbre de Merkle est de permettre la livraison des données d'un bloc de façon fragmentaire : un nœud peut télécharger uniquement l'en-tête d'un bloc à partir d'une source, la petite partie de l'arbre qui le concerne à partir d'une autre source, tout en étant assuré que toutes les données sont correctes. La raison pour laquelle cela fonctionne est que les hachages se propagent vers le haut : si un utilisateur malveillant tente d'insérer une fausse transaction dans le bas d'un arbre de Merkle, cela modifiera le nœud au-dessus, puis le nœud au-dessus suivant, pour finalement changer la racine de l'arbre et donc le hash du bloc, ce qui fait que le protocole enregistre celui-ci comme un bloc complètement différent (presque certainement avec une preuve de travail non valide).
+Une caractéristique importante de l'évolutivité de Bitcoin est que le bloc est stocké dans une structure de données à plusieurs niveaux. Le « hachage » d'un bloc n'est en fait que le hachage de l'en-tête du bloc, un morceau de données d'environ 200 octets qui contient l'horodatage, le nonce, le hachage du bloc précédent et le hachage racine d'une structure de données appelée l'arbre de Merkle stockant toutes les transactions du bloc. Un arbre de Merkle est un type d'arbre binaire, composé d'un ensemble de nœuds avec un grand nombre de nœuds feuilles au bas de l'arbre contenant les données sous-jacentes, un ensemble de nœuds intermédiaires où chaque nœud est le hachage de ses deux enfants, et enfin un seul nœud racine, également formé à partir du hachage de ses deux enfants, représentant le « sommet » de l'arbre. Le but de l'arbre de Merkle est de permettre que les données d'un bloc soient livrées de manière fragmentée : un nœud peut télécharger uniquement l'en-tête d'un bloc d'une source, la petite partie de l'arbre qui le concerne d'une autre source, et être toujours assuré que toutes les données sont correctes. La raison pour laquelle cela fonctionne est que les hachages se propagent vers le haut : si un utilisateur malveillant tente d'échanger une fausse transaction au bas d'un arbre de Merkle, ce changement provoquera un changement dans le nœud au-dessus, puis un changement dans le nœud encore au-dessus, changeant finalement la racine de l'arbre et donc le hachage du bloc, ce qui amènera le protocole à l'enregistrer comme un bloc complètement différent (presque certainement avec une preuve de travail invalide).
 
-On peut dire que le protocole de l'arbre de Merkle est essentiel à la viabilité du système à long terme. Un nœud complet ("full node") du réseau Bitcoin, qui stocke et traite l'intégralité de chaque bloc, nécessitait environ 15 Go d'espace disque sur le réseau Bitcoin en avril 2014, avec une croissance d'un gigaoctet par mois. La situation actuelle est viable pour certains ordinateurs de bureau, mais pas pour les téléphones, et à l'avenir, seuls les entreprises et les passionnés seront en mesure de participer. Un protocole connu sous le nom de vérification de paiement simplifiée (ou SPV) permet l'existence d'une autre catégorie de nœuds, appelés Nœuds légers ("light nodes"). Ce protocole permet aux nœuds légers de déterminer avec une vraie garantie de sécurité le statut de n'importe quelle transaction Bitcoin, ainsi que son solde actuel, en ne téléchargeant qu'une très petite partie de la blockchain.
+Le protocole de l'arbre de Merkle est sans doute essentiel à la durabilité à long terme. Un « nœud complet » dans le réseau Bitcoin, qui stocke et traite l'intégralité de chaque bloc, occupe environ 15 Go d'espace disque sur le réseau Bitcoin en avril 2014, et croît de plus d'un gigaoctet par mois. Actuellement, c'est viable pour certains ordinateurs de bureau et non pour les téléphones, et plus tard, seules les entreprises et les amateurs pourront participer. Un protocole connu sous le nom de « vérification de paiement simplifiée » (SPV) permet l'existence d'une autre classe de nœuds, appelés « nœuds légers », qui téléchargent les en-têtes de bloc, vérifient la preuve de travail sur les en-têtes de bloc, puis ne téléchargent que les « branches » associées aux transactions qui les concernent. Cela permet aux nœuds légers de déterminer avec une forte garantie de sécurité quel est l'état de n'importe quelle transaction Bitcoin, ainsi que leur solde actuel, tout en ne téléchargeant qu'une très petite partie de l'ensemble de la blockchain.
 
-### Autres applications de la blockchain {#alternative-blockchain-applications}
+### Applications de blockchain alternatives {#alternative-blockchain-applications}
 
-L'application de l'idée sous-jacente de la blockchain à d'autres concepts a également une longue histoire. En 2005, Nick Szabo invente le concept de « [secure property titles with ownerauthority](https://nakamotoinstitute.org/secure-property-titles/) » (titres de propriété sécurisés avec preuve de possession), un document décrivant comment de « nouvelles avancées dans la technologie des bases de données répliquées » permettent à un système fondé sur la blockchain de stocker une sorte de cadastre des propriétaires de terrains, créant ainsi un cadre élaboré qui inclut des concepts comme l'occupation d'un terrain, la prescription acquisitive et la taxe foncière en Géorgie. Il n'existait toutefois malheureusement aucun système de base de données répliquées efficace à cette époque. Le protocole n'a donc jamais été implémenté en pratique. Après 2009, une fois développé le consensus décentralisé de Bitcoin, un certain nombre d'autres applications ont néanmoins rapidement commencé à émerger.
+L'idée de reprendre le concept sous-jacent de la blockchain et de l'appliquer à d'autres concepts a également une longue histoire. En 2005, Nick Szabo a proposé le concept de « [titres de propriété sécurisés avec autorité du propriétaire](https://nakamotoinstitute.org/library/secure-property-titles/) », un document décrivant comment les « nouvelles avancées dans la technologie des bases de données répliquées » permettront un système basé sur la blockchain pour stocker un registre des propriétaires de terrains, créant un cadre élaboré incluant des concepts tels que la propriété par occupation, la prescription acquisitive et l'impôt foncier géorgien. Cependant, il n'existait malheureusement pas de système de base de données répliquée efficace à l'époque, et le protocole n'a donc jamais été mis en pratique. Après 2009, cependant, une fois le consensus décentralisé de Bitcoin développé, un certain nombre d'applications alternatives ont rapidement commencé à émerger.
 
-- **Namecoin** : créée en 2010, [Namecoin](https://namecoin.org/) peut être décrite comme une base de données décentralisée d'enregistrement de noms. Dans les protocoles décentralisés comme Tor, Bitcoin et BitMessage, il doit exister un moyen d'identifier les comptes afin que d'autres personnes puissent interagir avec eux, mais dans toutes les solutions existantes, le seul type d'identificateur disponible est un hachage pseudo-aléatoire comme `1LW79wp5ZBqaHW1jL5TCiBCrhQYtHagUWy`. Idéalement, on souhaiterait avoir un compte avec un nom comme « george ». Cependant, le problème est que si une personne peut créer un compte nommé « george », quelqu'un d'autre peut utiliser le même processus afin d'enregistrer « george » pour lui-même et se faire passer pour lui. La seule solution est d'appliquer le paradigme du premier déposant, où le premier enregistrement réussit tandis que le second échoue, parfaitement adapté pour le protocole de consensus Bitcoin. Namecoin est l'implémentation la plus ancienne et la plus réussie d'un système d'enregistrement de noms reposant sur cette idée.
-- **Pièces colorées** : le but des [pièces colorées (colored coins)](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit) est de servir de protocole pour permettre aux utilisateurs de créer leur propre monnaie numérique, ou dans le cas courant, mais néanmoins important, d'une monnaie à une seule unité, de créer des jetons (tokens) numériques sur la blockchain de Bitcoin. Dans le protocole des pièces colorées, on « émet » une nouvelle monnaie en attribuant publiquement une couleur à un UTXO Bitcoin spécifique, et le protocole définit récursivement la couleur des autres UTXO pour qu'elle soit identique à celle des entrées dépensées par la transaction qui les crée (certaines règles spéciales s'appliquent dans le cas d'entrées de couleurs mélangées). Cela permet aux utilisateurs de conserver des portefeuilles ne contenant que des UTXO d'une couleur donnée et de les envoyer comme des Bitcoins normaux, en remontant l'historique de la blockchain pour déterminer la couleur de n'importe quel UTXO reçu.
-- **Metacoins** : l'idée derrière un metacoin consiste à superposer un protocole à Bitcoin, en utilisant les transactions Bitcoin pour stocker les transactions Metacoin, mais en ayant une fonction de transition d'état différente, `APPLY'`. Comme le protocole Metacoin ne peut pas empêcher l'apparition de transactions non valides dans la blockchain Bitcoin, une règle a été ajoutée selon laquelle si `APPLY'(S,TX)` renvoie une erreur, le protocole donne par défaut `APPLY'(S,TX) = S`. Cela facilite le mécanisme de création d'un protocole de cryptomonnaie arbitraire, qui comprend potentiellement des fonctionnalités avancées ne pouvant être implémentées à l'intérieur même de Bitcoin, mais avec un coût de développement très bas puisque les complexités du minage et du réseau sont déjà gérées par le protocole Bitcoin. Les metacoins ont été utilisés pour implémenter certains types de contrats financiers, d'enregistrements de nom et de bourses d'échange décentralisées.
+- **Namecoin** - créé en 2010, [Namecoin](https://namecoin.org/) est mieux décrit comme une base de données d'enregistrement de noms décentralisée. Dans les protocoles décentralisés comme Tor, Bitcoin et BitMessage, il doit y avoir un moyen d'identifier les comptes pour que d'autres personnes puissent interagir avec eux, mais dans toutes les solutions existantes, le seul type d'identifiant disponible est un hachage pseudo-aléatoire comme `1LW79wp5ZBqaHW1jL5TCiBCrhQYtHagUWy`. Idéalement, on souhaiterait avoir un compte avec un nom comme « george ». Cependant, le problème est que si une personne peut créer un compte nommé « george », quelqu'un d'autre peut utiliser le même processus afin d'enregistrer « george » pour lui-même et se faire passer pour lui. La seule solution est d'appliquer le paradigme du premier déposant, où le premier enregistrement réussit tandis que le second échoue, parfaitement adapté pour le protocole de consensus Bitcoin. Namecoin est l'implémentation la plus ancienne et la plus réussie d'un système d'enregistrement de noms reposant sur cette idée.
+- **Pièces colorées** - le but des [pièces colorées](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit) est de servir de protocole pour permettre aux gens de créer leurs propres monnaies numériques - ou, dans le cas trivial important d'une monnaie à une unité, des jetons numériques, sur la blockchain Bitcoin. Dans le protocole des pièces colorées, on « émet » une nouvelle monnaie en attribuant publiquement une couleur à un UTXO Bitcoin spécifique, et le protocole définit récursivement la couleur des autres UTXO pour qu'elle soit identique à celle des entrées dépensées par la transaction qui les crée (certaines règles spéciales s'appliquent dans le cas d'entrées de couleurs mélangées). Cela permet aux utilisateurs de conserver des portefeuilles ne contenant que des UTXO d'une couleur donnée et de les envoyer comme des Bitcoins normaux, en remontant l'historique de la blockchain pour déterminer la couleur de n'importe quel UTXO reçu.
+- **Métacoins** - l'idée derrière un métacoin est d'avoir un protocole qui vit au-dessus de Bitcoin, utilisant les transactions Bitcoin pour stocker les transactions de métacoins mais ayant une fonction de transition d'état différente, `APPLY'`. Parce que le protocole de métacoin ne peut pas empêcher les transactions de métacoins invalides d'apparaître dans la blockchain Bitcoin, une règle est ajoutée : si `APPLY'(S,TX)` renvoie une erreur, le protocole se rabat sur `APPLY'(S,TX) = S`. Cela facilite le mécanisme de création d'un protocole de cryptomonnaie arbitraire, qui comprend potentiellement des fonctionnalités avancées ne pouvant être implémentées à l'intérieur même de Bitcoin, mais avec un coût de développement très bas puisque les complexités du minage et du réseau sont déjà gérées par le protocole Bitcoin. Les metacoins ont été utilisés pour implémenter certains types de contrats financiers, d'enregistrements de nom et de bourses d'échange décentralisées.
 
-Il existe donc généralement deux approches pour construire un protocole de consensus : développer un réseau indépendant, ou développer un protocole au-dessus de Bitcoin. La première approche, bien qu'elle soit raisonnablement efficace dans le cas d'applications comme Namecoin, est difficile à implémenter : chaque implémentation nécessite un bootstrap avec une chaîne indépendante, ainsi que la rédaction et le test de tout le code de transition d'état et de réseau. En outre, nous prévoyons que l'ensemble des applications de la technologie de consensus décentralisé suivra une distribution en loi de puissance, où la grande majorité des applications seront trop petites pour justifier leur propre blockchain, et nous notons qu'il existe de grandes classes d'applications décentralisées, en particulier des organisations autonomes décentralisées, qui ont besoin d'interagir les unes avec les autres.
+Ainsi, en général, il existe deux approches pour construire un protocole de consensus : construire un réseau indépendant et construire un protocole au-dessus de Bitcoin. La première approche, bien que raisonnablement réussie dans le cas d'applications comme Namecoin, est difficile à mettre en œuvre ; chaque implémentation individuelle doit démarrer une blockchain indépendante, ainsi que construire et tester tout le code de transition d'état et de réseau nécessaire. De plus, nous prévoyons que l'ensemble des applications pour la technologie de consensus décentralisé suivra une distribution de loi de puissance où la grande majorité des applications serait trop petite pour justifier leur propre blockchain, et nous notons qu'il existe de grandes classes d'applications décentralisées, en particulier les organisations autonomes décentralisées, qui ont besoin d'interagir les unes avec les autres.
 
-L'approche fondée sur Bitcoin, en revanche, a l'inconvénient de ne pas hériter des fonctionnalités de vérification de paiement simplifiée (SPV) de Bitcoin. La SPV fonctionne pour Bitcoin car elle utilise la profondeur de la blockchain comme proxy de validation. À un certain point, quand on est remonté assez loin dans les ancêtres d'une transaction, on peut légitimement affirmer qu'ils font partie de l'état. D'un autre côté, les méta-protocoles fondés sur la blockchain ne peuvent pas forcer celle-ci à ne pas inclure les transactions qui ne sont pas valides dans le contexte de leurs propres protocoles. C'est pourquoi une implémentation entièrement sécurisée du méta-protocole de SPV devrait examiner l'intégralité de la blockchain Bitcoin jusqu'au début pour déterminer si certaines transactions sont valides ou non. Actuellement, toutes les implémentations "légères" des méta-protocoles fondés sur Bitcoin se fient à un serveur de confiance pour fournir les données. Un résultat à l'évidence insatisfaisant surtout lorsque le but premier d'une cryptomonnaie est d'éliminer le besoin de confiance.
+L'approche basée sur Bitcoin, d'un autre côté, a le défaut de ne pas hériter des fonctionnalités de vérification de paiement simplifiée de Bitcoin. La SPV fonctionne pour Bitcoin parce qu'elle peut utiliser la profondeur de la blockchain comme un proxy pour la validité ; à un certain moment, une fois que les ancêtres d'une transaction sont suffisamment anciens, on peut dire qu'ils faisaient légitimement partie de l'état. Les méta-protocoles basés sur la blockchain, d'autre part, ne peuvent pas forcer la blockchain à ne pas inclure des transactions qui ne sont pas valides dans le contexte de leurs propres protocoles. Par conséquent, une implémentation de méta-protocole SPV entièrement sécurisée devrait remonter jusqu'au début de la blockchain Bitcoin pour déterminer si certaines transactions sont valides ou non. Actuellement, toutes les implémentations « légères » de méta-protocoles basés sur Bitcoin reposent sur un serveur de confiance pour fournir les données, ce qui est sans doute un résultat très sous-optimal, surtout lorsque l'un des principaux objectifs d'une cryptomonnaie est d'éliminer le besoin de confiance.
 
-### Langage de script {#scripting}
+### Scriptage {#scripting}
 
-Même sans extension, le protocole Bitcoin permet d'obtenir une version "faible" du concept de contrats intelligents ("smart contracts"). Les UTXO Bitcoin peuvent non seulement être détenus par une clé publique, mais aussi par un script plus complexe exprimé dans un langage de programmation simple basé sur une pile. Dans ce paradigme, une transaction dépensant ces UTXO doit fournir les données qui satisfont le script. En effet, même le simple mécanisme de propriété d'une clé publique est implémenté via un script : celui-ci prend une signature à courbe elliptique en entrée, vérifie qu'il correspond à la transaction et à l'adresse propriétaire de l'UTXO, et renvoie 1 quand la vérification réussi ou 0 dans le cas contraire. D'autres scripts plus compliqués existent pour d'autres cas d'utilisation. Par exemple, on peut concevoir un script qui requiert les signatures de deux clés privées sur trois pour être validé ("multisig"), une configuration utile pour les comptes d'entreprise, les comptes d'épargne sécurisés ou certains cas de dépôts fiduciaires. Les scripts peuvent également être utilisés afin d'offrir des récompenses pour résoudre des problèmes de calculs mathématiques, et vous pouvez même en concevoir un qui déclarerait "cet UTXO Bitcoin est le vôtre si vous pouvez fournir une preuve de SPV que vous m'avez envoyé une transaction Dogecoin de telle valeur", ce qui permet la création d'une bourse d'échange entre différentes cryptomonnaies.
+Même sans aucune extension, le protocole Bitcoin facilite en fait une version faible du concept de « contrats intelligents ». Les UTXO dans Bitcoin peuvent être possédés non seulement par une clé publique, mais aussi par un script plus compliqué exprimé dans un langage de programmation simple basé sur une pile. Dans ce paradigme, une transaction dépensant cet UTXO doit fournir des données qui satisfont le script. En effet, même le mécanisme de base de la propriété de clé publique est implémenté via un script : le script prend une signature de courbe elliptique en entrée, la vérifie par rapport à la transaction et à l'adresse qui possède l'UTXO, et renvoie 1 si la vérification est réussie et 0 sinon. D'autres scripts plus compliqués existent pour divers cas d'utilisation supplémentaires. Par exemple, on peut construire un script qui requiert des signatures de deux des trois clés privées données pour valider (« multisig »), une configuration utile pour les comptes d'entreprise, les comptes d'épargne sécurisés et certaines situations de dépôt fiduciaire pour commerçants. Les scripts peuvent également être utilisés pour payer des primes pour des solutions à des problèmes de calcul, et on peut même construire un script qui dit quelque chose comme « cet UTXO Bitcoin est à vous si vous pouvez fournir une preuve SPV que vous m'avez envoyé une transaction Dogecoin de cette dénomination », permettant essentiellement un échange décentralisé entre cryptomonnaies.
 
-Le langage de script, tel qu'il est implémenté dans Bitcoin, a toutefois d'importantes limitations :
+Cependant, le langage de script tel qu'implémenté dans Bitcoin a plusieurs limitations importantes :
 
-- **Défaut de langage Turing-complet** : bien que le langage de script de Bitcoin prenne en charge un large sous-ensemble de calculs, il est loin de tout prendre en charge. La principale catégorie manquante est celle des boucles. Cela évite les boucles infinies lors de la vérification d'une transaction. Théoriquement, c'est un obstacle surmontable pour les programmeurs de scripts, car toute boucle peut être simulée en répétant simplement plusieurs fois le code sous-jacent avec une instruction « if » (si), mais cela conduit à des scripts qui sont très volumineux. Par exemple, l'implémentation d'un algorithme de signature à courbe elliptique alternatif pourrait nécessiter 256 itérations de multiplications, chacune incluse individuellement dans le code.
-- **Défaut de valeur** : un script UTXO n'a aucun moyen de contrôler précisemment le montant pouvant être retiré. Un cas d'utilisation très intéressant d'un contrat d'oracle serait un contrat de couverture dans lequel A et B investiraient 1000 $ de BTC. Au bout de 30 jours, le script enverrait 1000 $ de BTC à A et le reste à B. Un oracle serait nécessaire pour déterminer la valeur du BTC en USD, mais il s'agirait néanmoins d'une énorme amélioration en termes de confiance et d'infrastructure requise par rapport aux solutions totalement centralisées actuellement disponibles. Les UTXO étant toutefois en tout-ou-rien, la seule façon d'arriver à cela serait un bricolage très peu efficace où l'on disposerait de nombreux UTXO de diverses dénominations (c'est-à-dire un UTXO de 2<sup>k</sup> pour chaque k jusqu'à 30) et où l'oracle choisirait quel UTXO envoyer à A et lequel envoyer à B.
-- **Manque d'état** : un UTXO peut être dépensé ou non. Il n'est pas possible d'avoir de scripts ni de contrats multi-étapes qui conserveraient un autre état interne au-delà de cela. Il est donc difficile de réaliser des contrats d'options multi-étapes, des offres d'échange décentralisées ou des protocoles d'engagement cryptographiques à deux étapes (nécessaires pour les primes de calcul sécurisées). Cela signifie que les UTXO ne peuvent être utilisés que pour construire des contrats simples à usage unique, et non des contrats dynamiques plus complexes comme les organisations décentralisées, ce qui rend aussi l'implémentation des méta-protocoles plus compliquée. L'état binaire combiné au défaut de valeur rend impossible une autre application importante : les limites de retrait.
-- **Inaccessibilité de la blockchain** : les UTXO n'ont pas accès à certaines données de la blockchain, comme le nonce et le hachage du bloc précédent. Cela limite considérablement les applications de jeux d'argent, et plusieurs autres catégories, en privant le langage de script d'une source d'aléatoire potentiellement précieuse.
+- **Manque de Turing-complétude** - c'est-à-dire que, bien qu'il y ait un grand sous-ensemble de calculs que le langage de script de Bitcoin prend en charge, il ne prend pas en charge la quasi-totalité. La principale catégorie manquante est celle des boucles. Cela évite les boucles infinies lors de la vérification d'une transaction. Théoriquement, c'est un obstacle surmontable pour les programmeurs de scripts, car toute boucle peut être simulée en répétant simplement plusieurs fois le code sous-jacent avec une instruction « if » (si), mais cela conduit à des scripts qui sont très volumineux. Par exemple, l'implémentation d'un algorithme de signature à courbe elliptique alternatif pourrait nécessiter 256 itérations de multiplications, chacune incluse individuellement dans le code.
+- **Aveuglement à la valeur** - il n'y a aucun moyen pour un script UTXO de fournir un contrôle fin sur le montant qui peut être retiré. Un cas d'utilisation très intéressant d'un contrat d'oracle serait un contrat de couverture dans lequel A et B investiraient 1000 $ de BTC. Au bout de 30 jours, le script enverrait 1000 $ de BTC à A et le reste à B. Un oracle serait nécessaire pour déterminer la valeur du BTC en USD, mais il s'agirait néanmoins d'une énorme amélioration en termes de confiance et d'infrastructure requise par rapport aux solutions totalement centralisées actuellement disponibles. Cependant, comme les UTXO sont tout ou rien, la seule façon d'y parvenir est par un hack très inefficace consistant à avoir de nombreux UTXO de dénominations variables (par ex., un UTXO de 2<sup>k</sup> pour chaque k jusqu'à 30) et de laisser l'oracle choisir quel UTXO envoyer à A et lequel à B.
+- **Manque d'état** - les UTXO peuvent être soit dépensés, soit non dépensés ; il n'y a aucune possibilité pour des contrats ou des scripts à plusieurs étapes qui conserveraient un autre état interne au-delà de cela. Il est donc difficile de réaliser des contrats d'options multi-étapes, des offres d'échange décentralisées ou des protocoles d'engagement cryptographiques à deux étapes (nécessaires pour les primes de calcul sécurisées). Cela signifie que les UTXO ne peuvent être utilisés que pour construire des contrats simples à usage unique, et non des contrats dynamiques plus complexes comme les organisations décentralisées, ce qui rend aussi l'implémentation des méta-protocoles plus compliquée. L'état binaire combiné au défaut de valeur rend impossible une autre application importante : les limites de retrait.
+- **Aveuglement à la blockchain** - les UTXO sont aveugles aux données de la blockchain telles que le nonce, l'horodatage et le hachage du bloc précédent. Cela limite considérablement les applications de jeux d'argent, et plusieurs autres catégories, en privant le langage de script d'une source d'aléatoire potentiellement précieuse.
 
-Nous discernons donc trois approches pour développer des applications avancées sur la base d'une cryptomonnaie : la construction d'une nouvelle blockchain, l'utilisation de scripts reposant sur Bitcoin et la construction d'un méta-protocole reposant sur Bitcoin. La création d'une nouvelle blockchain offre une liberté illimitée pour construire un éventail de fonctionnalités, mais nécessite d'importants efforts en termes de temps de développement, de mise en service et de sécurité. L'utilisation de scripts est simple à implémenter et à normaliser, mais est très limitée en terme de fonctionnalités, et les méta-protocoles, bien que simples, souffrent de défauts en matière d'évolutivité. Avec Ethereum, nous avons l'intention de construire un autre framework, qui offre des perspectives bien plus importantes tant au niveau de la simplicité de développement que de la puissance des clients légers, tout en permettant aux applications de partager un environnement économique bénéficiant de la sécurité de la blockchain.
+Ainsi, nous voyons trois approches pour construire des applications avancées au-dessus de la cryptomonnaie : construire une nouvelle blockchain, utiliser le scriptage au-dessus de Bitcoin, et construire un méta-protocole au-dessus de Bitcoin. Construire une nouvelle blockchain permet une liberté illimitée dans la construction d'un ensemble de fonctionnalités, mais au prix du temps de développement, de l'effort de démarrage et de la sécurité. L'utilisation du scriptage est facile à mettre en œuvre et à standardiser, mais ses capacités sont très limitées, et les méta-protocoles, bien que faciles, souffrent de défauts d'évolutivité. Avec Ethereum, nous avons l'intention de construire un cadre alternatif qui offre des gains encore plus importants en termes de facilité de développement ainsi que des propriétés de client léger encore plus fortes, tout en permettant aux applications de partager un environnement économique et la sécurité de la blockchain.
 
 ## Ethereum {#ethereum}
 
-L'objectif d'Ethereum est de créer un autre protocole pour développer des applications décentralisées, en offrant un ensemble différent de compromis qui sera, nous le pensons, très utile pour une large classe d'applications décentralisées. Il sera principalement axé sur les situations dans lesquelles le développement rapide, la sécurité des petites applications rarement utilisées et la possibilité pour les différentes applications d'interagir ensemble de façon très efficace sont importants. Ethereum parvient à cela en construisant ce qui constitue la couche fondamentale abstraite essentielle : une blockchain intégrant un langage de programmation Turing-complet, permettant à tous de rédiger des contrats intelligents et des applications décentralisées où l'on peut créer ses propres règles arbitraires de propriété, formats de transaction et fonctions de transition d'état. Une version dépouillée de Namecoin peut être rédigée en deux lignes de code, et d'autres protocoles comme les systèmes de réputation et de monnaies peuvent être développés en moins de vingt lignes. Les contrats intelligents, ces "boîtes" cryptographiques qui contiennent une valeur et ne se déverrouillent que si certaines conditions sont remplies, peuvent également être construits au-dessus de la plateforme, avec bien plus de puissance que celle du langage de script Bitcoin en raison des capacités supplémentaires offerte par la Turing-complétude, la visibilité des valeurs, de la blockchain, et l'état.
+L'intention d'Ethereum est de créer un protocole alternatif pour construire des applications décentralisées, offrant un ensemble de compromis différent qui, nous le pensons, sera très utile pour une grande classe d'applications décentralisées, avec un accent particulier sur les situations où le temps de développement rapide, la sécurité pour les applications petites et rarement utilisées, et la capacité de différentes applications à interagir très efficacement, sont importants. Ethereum y parvient en construisant ce qui est essentiellement la couche fondamentale abstraite ultime : une blockchain avec un langage de programmation Turing-complet intégré, permettant à quiconque d'écrire des contrats intelligents et des applications décentralisées où ils peuvent créer leurs propres règles arbitraires pour la propriété, les formats de transaction et les fonctions de transition d'état. Une version dépouillée de Namecoin peut être écrite en deux lignes de code, et d'autres protocoles comme les monnaies et les systèmes de réputation peuvent être construits en moins de vingt lignes. Les contrats intelligents, des « boîtes » cryptographiques qui contiennent de la valeur et ne la déverrouillent que si certaines conditions sont remplies, peuvent également être construits sur la plateforme, avec une puissance bien plus grande que celle offerte par le scriptage Bitcoin en raison des pouvoirs ajoutés de la Turing-complétude, de la connaissance de la valeur, de la connaissance de la blockchain et de l'état.
 
 ### Comptes Ethereum {#ethereum-accounts}
 
@@ -151,14 +151,14 @@ Dans Ethereum, l'état est composé d'objets appelés « comptes », chaque comp
 
 - Le **nonce**, un compteur utilisé pour s'assurer que chaque transaction ne peut être traitée qu'une seule fois
 - Le **solde en ether** actuel du compte
-- Le **code de contrat** du compte, s'il existe
+- Le **code du contrat** du compte, s'il est présent
 - Le **stockage** du compte (vide par défaut)
 
-L'« ether » est le principal cryptocarburant interne d'Ethereum. Il est utilisé pour payer les frais de transaction. D'une manière générale, il existe deux types de comptes : les **comptes externes**, contrôlés par des clés privées, et les **comptes de contrat**, contrôlés par leur code de contrat. Un compte externe n'a pas de code et il est possible d'envoyer des messages à partir de celui-ci en créant et en signant une transaction. Dans un compte de contrat, chaque fois que celui-ci reçoit un message, son code s'active, ce qui lui permet de lire et d'écrire dans la mémoire de stockage interne et, à son tour, d'envoyer d'autres messages ou de créer des contrats.
+L'« ether » est le principal cryptocarburant interne d'Ethereum. Il est utilisé pour payer les frais de transaction. En général, il existe deux types de comptes : les **comptes externes**, contrôlés par des clés privées, et les **comptes de contrat**, contrôlés par le code de leur contrat. Un compte externe n'a pas de code et il est possible d'envoyer des messages à partir de celui-ci en créant et en signant une transaction. Dans un compte de contrat, chaque fois que celui-ci reçoit un message, son code s'active, ce qui lui permet de lire et d'écrire dans la mémoire de stockage interne et, à son tour, d'envoyer d'autres messages ou de créer des contrats.
 
 Notez que dans Ethereum, les « contrats » ne doivent pas être considérés comme quelque chose qui doit être « rempli » ni « respecté ». Il s'agit plutôt d'« agents autonomes », qui vivent à l'intérieur de l'environnement d'exécution Ethereum, exécutant toujours un morceau de code spécifique lorsqu'ils sont appelés par un message ou une transaction, et ayant un contrôle direct sur leur propre solde d'ether et leur propre magasin de clés/valeurs afin de garder une trace des variables persistantes.
 
-### Messages et transactions {#messages-and-transactions}
+### Messages et Transactions {#messages-and-transactions}
 
 Dans Ethereum, le terme « transaction » désigne le paquet de données signées qui stocke un message à envoyer depuis un compte externe. Les transactions contiennent :
 
@@ -166,12 +166,12 @@ Dans Ethereum, le terme « transaction » désigne le paquet de données signée
 - une signature identifiant l'expéditeur ;
 - le montant en ETH à transférer de l'expéditeur au destinataire ;
 - un champ de données facultatif ;
-- une valeur `STARTGAS`, qui représente le nombre maximum d'étapes de calcul autorisé pour exécuter la transaction ;
-- une valeur `GASPRICE`, qui représente les frais que l'expéditeur paie pour chaque étape de calcul.
+- Une valeur `STARTGAS`, représentant le nombre maximal d'étapes de calcul que l'exécution de la transaction est autorisée à prendre
+- Une valeur `GASPRICE`, représentant les frais que l'expéditeur paie par étape de calcul
 
 Les trois premiers champs sont des champs standards attendus dans toute cryptomonnaie. Le champ de données n'a pas de fonction par défaut, mais la machine virtuelle a un code d'opération qu'un contrat peut utiliser pour accéder aux données. Voilà un exemple de cas d'utilisation : si un contrat fonctionne comme un service d'enregistrement de domaine sur la blockchain, il voudra peut-être interpréter les données transférées comme contenant deux « champs », le premier étant un domaine à enregistrer, le second étant l'adresse IP à enregistrer. Le contrat lira ces valeurs à partir des données du message et les stockera de manière adéquate.
 
-Les champs `STARTGAS` et `GASPRICE` sont essentiels au mécanisme anti-déni de service d'Ethereum. Afin d'éviter les boucles infinies accidentelles ou hostiles, ou d'autres gaspillages de calcul dans le code, il est nécessaire que chaque transaction limite le nombre d'étapes de calcul dans l'exécution du code. L'unité fondamentale de calcul est le « gaz ». En général, une étape de calcul coûte 1 unité de gaz, mais certaines opérations coûtent plus cher, car elles sont plus gourmandes en calcul ou augmentent la quantité de données à stocker comme partie intégrante de l'état. Il existe aussi des frais de 5 unités de gaz pour chaque octet de données de transaction. Le but de ce système de frais est d'exiger d'un attaquant qu'il paie proportionnellement chaque ressource qu'il consomme, y compris le calcul, la bande passante et le stockage. Ainsi, toute transaction conduisant le réseau à consommer une plus grande quantité de l'une de ces ressources doit payer des frais de gaz à peu près proportionnels à cette augmentation.
+Les champs `STARTGAS` et `GASPRICE` sont cruciaux pour le modèle anti-déni de service d'Ethereum. Afin d'éviter les boucles infinies accidentelles ou hostiles, ou d'autres gaspillages de calcul dans le code, il est nécessaire que chaque transaction limite le nombre d'étapes de calcul dans l'exécution du code. L'unité fondamentale de calcul est le « gaz ». En général, une étape de calcul coûte 1 unité de gaz, mais certaines opérations coûtent plus cher, car elles sont plus gourmandes en calcul ou augmentent la quantité de données à stocker comme partie intégrante de l'état. Il existe aussi des frais de 5 unités de gaz pour chaque octet de données de transaction. Le but de ce système de frais est d'exiger d'un attaquant qu'il paie proportionnellement chaque ressource qu'il consomme, y compris le calcul, la bande passante et le stockage. Ainsi, toute transaction conduisant le réseau à consommer une plus grande quantité de l'une de ces ressources doit payer des frais de gaz à peu près proportionnels à cette augmentation.
 
 ### Messages {#messages}
 
@@ -181,21 +181,21 @@ Les contrats ont la capacité d'envoyer des "messages" à d'autres contrats. Les
 - le destinataire du message ;
 - le montant en ETH à transférer avec le message ;
 - un champ de données facultatif ;
-- une valeur `STARTGAS`.
+- Une valeur `STARTGAS`
 
-En substance, un message est comme une transaction, sauf qu'il est émis par un contrat et non par un acteur externe. Un message est émis lorsqu'un contrat en cours d'exécution utilise le code d'opération `CALL`, qui produit et exécute un message. Tout comme une transaction, un message provoque l'exécution du code du compte destinataire. Ainsi, les contrats peuvent interagir avec d'autres contrats exactement de la même façon que des acteur externes.
+En substance, un message est comme une transaction, sauf qu'il est émis par un contrat et non par un acteur externe. Un message est produit lorsqu'un contrat exécutant actuellement du code exécute l'opcode `CALL`, qui produit et exécute un message. Tout comme une transaction, un message provoque l'exécution du code du compte destinataire. Ainsi, les contrats peuvent interagir avec d'autres contrats exactement de la même façon que des acteur externes.
 
 Notez que l'allocation de gaz assignée par une transaction ou un contrat concerne la totalité du gaz consommé par cette transaction et toutes les sous-exécutions. Par exemple, si un acteur externe A envoie une transaction à B avec 1 000 unités de gaz, que B consomme 600 unités de gaz avant d'envoyer un message à C, et que l’exécution interne de C consomme 300 unités de gaz avant le retour, B pourra encore consommer 100 unités de gaz avant d'être en panne sèche.
 
-### Fonction de transition d'état Ethereum {#ethereum-state-transition-function}
+### Fonction de transition d'état d'Ethereum {#ethereum-state-transition-function}
 
-![Transition d'état ETH](./ether-state-transition.png)
+![Transition d'état de l'ether](./ether-state-transition.png)
 
-La fonction de transition d'état Ethereum `APPLY(S,TX) -> S'` peut être définie comme suit :
+La fonction de transition d'état d'Ethereum, `APPLY(S,TX) -> S'` peut être définie comme suit :
 
-1. On vérifie que la transaction est bien formée (c.-à-d. qu'elle a le bon nombre de valeurs), que la signature est valide et que le nonce correspond à celui du compte de l'expéditeur. Sinon, une erreur est renvoyée.
-2. On calcule les frais de transaction correspondant à `STARTGAS * GASPRICE`, et on détermine l'adresse d'envoi à partir de la signature. On déduit les frais du solde du compte de l'expéditeur et on incrémente son nonce. Si le solde est insuffisant, une erreur est renvoyée.
-3. On initialise `GAS = STARTGAS`, et on enlève une certaine quantité de gaz par octet afin de payer pour les octets de la transaction.
+1. Vérifier si la transaction est bien formée (c.-à-d. a le bon nombre de valeurs), si la signature est valide et si le nonce correspond au nonce du compte de l'expéditeur. Sinon, une erreur est renvoyée.
+2. Calculer les frais de transaction comme `STARTGAS * GASPRICE`, et déterminer l'adresse d'envoi à partir de la signature. On déduit les frais du solde du compte de l'expéditeur et on incrémente son nonce. Si le solde est insuffisant, une erreur est renvoyée.
+3. Initialiser `GAS = STARTGAS`, et retirer une certaine quantité de gaz par octet pour payer les octets de la transaction.
 4. On transfère la valeur de la transaction du compte de l'expéditeur vers celui du destinataire. Si le compte destinataire n'existe pas encore, on le crée. Si le compte destinataire est un contrat, on exécute le code du contrat, soit jusqu'à la fin, soit jusqu'à ce que l'exécution soit à court de gaz.
 5. Si le transfert de valeur échoue parce que l'expéditeur n'a pas assez d'argent ou que l'exécution du code est en panne de gaz, on annule tous les changements d'état à l'exception du paiement des frais et on ajoute les frais au compte du mineur.
 6. Sinon, on rembourse les frais correspondant au gaz restant à l'expéditeur, et on envoie les frais correspondant au gaz consommé au mineur.
@@ -207,34 +207,34 @@ if !self.storage[calldataload(0)]:
   self.storage[calldataload(0)] = calldataload(32)
 ```
 
-Notez qu'en réalité, le code du contrat est écrit en code EVM de bas niveau. Pour plus de clarté, cet exemple est écrit en Serpent, un de nos langages de haut niveau qui peut être compilé en code EVM. Supposons que l'espace de stockage du contrat soit initialement vide et qu'une transaction soit émise avec un valeur de 10 ETH, 2 000 gaz à un prix unitaire de 0,001 ETH et 64 octets de données, avec les octets 0 à 31 représentant le nombre `2` et les octets 32 à 63 représentant la chaîne `CHARLIE`. Dans ce cas, le processus de la fonction de transition d'état est le suivant :
+Notez qu'en réalité, le code du contrat est écrit en code EVM de bas niveau. Pour plus de clarté, cet exemple est écrit en Serpent, un de nos langages de haut niveau qui peut être compilé en code EVM. Supposons que le stockage du contrat soit initialement vide, et qu'une transaction soit envoyée avec une valeur de 10 ethers, 2000 gaz, un prix de gaz de 0,001 ether, et 64 octets de données, où les octets 0-31 représentent le nombre `2` et les octets 32-63 représentent la chaîne `CHARLIE`. Dans ce cas, le processus de la fonction de transition d'état est le suivant :
 
 1. On vérifie que la transaction est valide et bien formée.
 2. On vérifie que l'expéditeur de la transaction dispose d'au moins 2 000 \* 0,001 = 2 ETH. Si c'est le cas, on déduit 2 ETH de son compte.
 3. On initialise gaz = 2 000. En supposant que la transaction fasse 170 octets de long et que le coût par octet soit 5 UC, on soustrait 850, de sorte qu'il reste 1 150.
 4. On déduit 10 ETH supplémentaires du compte de l'expéditeur et on les ajoute à celui du contrat.
-5. On exécute le code. Dans ce cas, c'est simple : il vérifie si l'index `2` de l'espace de stockage du contrat est utilisé, remarque qu'il ne l'est pas, puis définit l'espace de stockage à l'index `2` à la valeur `CHARLIE`. Supposons que cela consomme 187 unités de gaz, la quantité de gaz restante est alors de 1 150 - 187 = 963.
+5. On exécute le code. Dans ce cas, c'est simple : il vérifie si le stockage du contrat à l'index `2` est utilisé, remarque qu'il ne l'est pas, et définit donc le stockage à l'index `2` à la valeur `CHARLIE`. Supposons que cela consomme 187 unités de gaz, la quantité de gaz restante est alors de 1 150 - 187 = 963.
 6. On rend 963 \* 0,001 = 0,963 ETH au compte de l'expéditeur, puis l'état résultant est renvoyé.
 
-S'il n'existait aucun contrat à l'autre bout de la transaction, le total des frais de gaz seraient égal au `GASPRICE` fourni multiplié par la longueur de la transaction en octets, et les données envoyées avec la transaction ne seraient pas pertinentes.
+S'il n'y avait pas de contrat à la réception de la transaction, alors les frais de transaction totaux seraient simplement égaux au `GASPRICE` fourni multiplié par la longueur de la transaction en octets, et les données envoyées avec la transaction seraient non pertinentes.
 
-Notez que les messages fonctionnent de la même façon que les transactions en terme d'invalidation : si l'exécution d'un message ne dispose pas d'assez de gaz, alors celle-ci, ainsi que toutes les autres exécutions qu'elle a déclenchées, reviennent à leur état initial, mais les exécutions parentes n'ont pas à être invalidées. Cela signifie qu'il est "sans danger" pour un contrat d'appeler un autre contrat, car si A appelle B avec le gaz G, alors l'exécution de A ne consommera jamais plus que le gaz G. Notez qu'il existe un code d'opération `CREATE`, qui crée un contrat. Son principe d'exécution est globalement similaire à `CALL`, excepté que le résultat de l'exécution détermine le code d'un contrat nouvellement créé.
+Notez que les messages fonctionnent de la même façon que les transactions en terme d'invalidation : si l'exécution d'un message ne dispose pas d'assez de gaz, alors celle-ci, ainsi que toutes les autres exécutions qu'elle a déclenchées, reviennent à leur état initial, mais les exécutions parentes n'ont pas à être invalidées. Cela signifie qu'il est "sans danger" pour un contrat d'appeler un autre contrat, car si A appelle B avec le gaz G, alors l'exécution de A ne consommera jamais plus que le gaz G. Enfin, notez qu'il existe un opcode, `CREATE`, qui crée un contrat ; sa mécanique d'exécution est généralement similaire à `CALL`, à l'exception que la sortie de l'exécution détermine le code d'un contrat nouvellement créé.
 
-### Exécution de code {#code-execution}
+### Exécution du code {#code-execution}
 
-Dans les contrats Ethereum, le code est écrit dans un langage bytecode de bas niveau orienté pile, appelé « code de la machine virtuelle Ethereum » ou « code EVM ». Il se compose d'une série d'octets, où chaque octet représente une opération. En général, l'exécution de code est une boucle infinie qui consiste à répéter l'opération au compteur de programme actuel (qui commence à zéro), puis à incrémenter le compteur de un jusqu'à atteindre la fin du code ou une erreur, ou jusqu'à ce qu'une instruction `STOP` ou `RETURN` soit détectée. Les opérations ont accès à trois types d'espace pour stocker des données :
+Dans les contrats Ethereum, le code est écrit dans un langage bytecode de bas niveau orienté pile, appelé « code de la machine virtuelle Ethereum » ou « code EVM ». Il se compose d'une série d'octets, où chaque octet représente une opération. En général, l'exécution du code est une boucle infinie qui consiste à effectuer de manière répétée l'opération au compteur de programme actuel (qui commence à zéro), puis à incrémenter le compteur de programme de un, jusqu'à ce que la fin du code soit atteinte ou qu'une erreur ou une instruction `STOP` ou `RETURN` soit détectée. Les opérations ont accès à trois types d'espace pour stocker des données :
 
-- La **pile** (stack), un conteneur dernier-arrivé-premier-sorti auquel on peut ajouter et extraire des valeurs.
-- La **mémoire** (memory), un tableau d'octets extensible à l'infini.
-- Le **stockage** (storage) à long terme du contrat, un magasin de clés/valeurs. Contrairement à la pile et à la mémoire, qui sont réinitialisées après la fin du calcul, le stockage est conservé sur le long terme.
+- La **pile**, un conteneur de type dernier entré, premier sorti (LIFO) sur lequel des valeurs peuvent être empilées et dépilées
+- **Mémoire**, un tableau d'octets extensible à l'infini
+- Le **stockage** à long terme du contrat, une banque de données clé/valeur. Contrairement à la pile et à la mémoire, qui sont réinitialisées après la fin du calcul, le stockage est conservé sur le long terme.
 
 Le code peut aussi accéder à la valeur, à l'expéditeur et aux données du message reçu, ainsi qu'aux données d'en-tête du bloc. Il peut également renvoyer des données sous forme d'un tableau d'octets en sortie.
 
-Le modèle d'exécution officiel du code EVM est étonnamment simple. Lorsque la machine virtuelle Ethereum est en cours d'exécution, son état de calcul complet peut être défini par le tuple `(block_state, transaction, message, code, memory, stack, pc, gaz)`, où `block_state` est l'état global contenant tous les comptes, et comprend les soldes et le stockage. Au début de chaque cycle d'exécution, l'instruction courante est trouvée en prenant le `pc`ième octet du `code` (ou 0 si `pc >= len(code)`), et chaque instruction a sa propre définition quant à son impact sur le tuple. Par exemple, `ADD` extrait deux éléments de la pile et insère leur somme, réduit `gaz` de 1 et augmente `pc` de 1, tandis que `SSTORE` extrait les deux éléments supérieurs de la pile et insère le deuxième élément dans l'espace de stockage du contrat à l'index spécifié par le premier élément. Bien qu'il existe de nombreuses façons d'optimiser l'exécution de la machine virtuelle Ethereum via la compilation à la volée, une implémentation de base d'Ethereum peut être réalisée en quelques centaines de lignes de code.
+Le modèle d'exécution officiel du code EVM est étonnamment simple. Pendant que la machine virtuelle Ethereum est en cours d'exécution, son état de calcul complet peut être défini par le tuple `(block_state, transaction, message, code, memory, stack, pc, gas)`, où `block_state` est l'état global contenant tous les comptes et incluant les soldes et le stockage. Au début de chaque tour d'exécution, l'instruction actuelle est trouvée en prenant le `pc`-ième octet de `code` (ou 0 si `pc >= len(code)`), et chaque instruction a sa propre définition sur la manière dont elle affecte le tuple. Par exemple, `ADD` dépile deux éléments de la pile et empile leur somme, réduit `gas` de 1 et incrémente `pc` de 1, et `SSTORE` dépile les deux premiers éléments de la pile et insère le deuxième élément dans le stockage du contrat à l'index spécifié par le premier élément. Bien qu'il existe de nombreuses façons d'optimiser l'exécution de la machine virtuelle Ethereum via la compilation à la volée, une implémentation de base d'Ethereum peut être réalisée en quelques centaines de lignes de code.
 
-### Blockchain et minage {#blockchain-and-mining}
+### Blockchain et Minage {#blockchain-and-mining}
 
-![Diagramme des blocs APPLY Ethereum](./ethereum-apply-block-diagram.png)
+![Diagramme d'application de bloc Ethereum](./ethereum-apply-block-diagram.png)
 
 À bien des égards, la blockchain Ethereum est similaire à la blockchain Bitcoin, bien qu'elle présente certaines différences. Concernant l'architecture de la blockchain, la principale différence entre Ethereum et Bitcoin est que, contrairement à Bitcoin, les blocs d'Ethereum contiennent à la fois une copie de la liste des transactions et de l'état le plus récent. De plus, deux autres valeurs sont aussi stockés dans le bloc : le numéro de bloc et la difficulté. Dans Ethereum, l’algorithme de base de validation d'un bloc est le suivant :
 
@@ -242,14 +242,14 @@ Le modèle d'exécution officiel du code EVM est étonnamment simple. Lorsque la
 2. On vérifie que l'horodatage du bloc est supérieur à celui du précédent bloc référencé et qu'il n'excède pas 15 minutes dans l'avenir.
 3. On vérifie que le numéro de bloc, la difficulté, la racine de transaction, la racine oncle et la limite de gaz (plusieurs concepts de bas niveau spécifiques à Ethereum) sont valides.
 4. On vérifie que la preuve de travail du bloc est valide.
-5. `S[0]` doit être l'état à la fin du bloc précédent.
-6. `TX` doit être la liste des transactions du bloc, et `n` les transactions. Pour tout `i` dans `0...n-1`, on définit `S[i+1] = APPLY(S[i],TX[i])`. Si une application renvoie une erreur, ou si la totalité du gaz consommé jusqu'à ce point du bloc dépasse la `GASLIMIT`, une erreur est renvoyée.
-7. `S_FINAL` doit être égal à `S[n]`, mais en ajoutant la récompense de bloc versée au mineur.
-8. On vérifie que la racine de l'arbre de Merkle de l'état `S_FINAL` est égale à la racine de l'état final fournie dans l'en-tête de bloc. Si c'est le cas, le bloc est valide. Sinon, il ne l'est pas.
+5. Soit `S[0]` l'état à la fin du bloc précédent.
+6. Soit `TX` la liste des transactions du bloc, avec `n` transactions. Pour tout `i` dans `0...n-1`, définissez `S[i+1] = APPLY(S[i],TX[i])`. Si une application renvoie une erreur, ou si le gaz total consommé dans le bloc jusqu'à ce point dépasse le `GASLIMIT`, retourner une erreur.
+7. Soit `S_FINAL` égal à `S[n]`, mais en ajoutant la récompense de bloc payée au mineur.
+8. Vérifier si la racine de l'arbre de Merkle de l'état `S_FINAL` est égale à la racine de l'état final fournie dans l'en-tête du bloc. Si c'est le cas, le bloc est valide. Sinon, il ne l'est pas.
 
-L'approche peut sembler très inefficace à première vue, car elle nécessite de stocker l'état complet avec chaque bloc, mais en réalité, l'efficacité devrait être comparable à celle de Bitcoin. Cela vient du fait que l'état est stocké dans une structure en arbre, et qu'après chaque bloc, seule une petite partie de l'arbre doit être modifiée. En général, la grande majorité de l'arbre devrait donc être identique entre deux blocs adjacents. Les données peuvent ainsi être stockées une fois et référencées deux fois en utilisant des pointeurs (c.-à.-d. les hachages des sous-arbres). Un type particulier d'arbre, l'« arbre Patricia » est utilisé pour cela. Il s'agit d'un dérivé du concept d'arbre de Merkle qui permet d'insérer et de supprimer efficacement des nœuds, et pas seulement de les modifier. Par ailleurs, comme toutes les informations d'état font partie du dernier bloc, il n'est pas nécessaire de stocker tout l'historique de la blockchain. Cette stratégie, si elle pouvait être appliquée à Bitcoin, réduirait les besoins de stockage de 5 à 20 fois.
+L'approche peut sembler très inefficace à première vue, car elle nécessite de stocker l'état complet avec chaque bloc, mais en réalité, l'efficacité devrait être comparable à celle de Bitcoin. Cela vient du fait que l'état est stocké dans une structure en arbre, et qu'après chaque bloc, seule une petite partie de l'arbre doit être modifiée. Ainsi, en général, entre deux blocs adjacents, la grande majorité de l'arbre devrait être la même, et donc les données peuvent être stockées une fois et référencées deux fois à l'aide de pointeurs (c.-à-d. les hachages des sous-arbres). Un type particulier d'arbre, l'« arbre Patricia » est utilisé pour cela. Il s'agit d'un dérivé du concept d'arbre de Merkle qui permet d'insérer et de supprimer efficacement des nœuds, et pas seulement de les modifier. Par ailleurs, comme toutes les informations d'état font partie du dernier bloc, il n'est pas nécessaire de stocker tout l'historique de la blockchain. Cette stratégie, si elle pouvait être appliquée à Bitcoin, réduirait les besoins de stockage de 5 à 20 fois.
 
-La question de savoir où le code d'un contrat est exécuté, en termes de matériel physique, est souvent posée. La réponse est simple : le processus d'exécution du code d'un contrat fait partie de la définition de la fonction de transition d'état, qui fait partie de l'algorithme de validation des blocs. Donc quand une transaction est ajoutée au bloc `B`, l'exécution de code engendrée par cette transaction est exécutée par tous les nœuds, actuels et futurs, qui téléchargent et valident le bloc `B`.
+La question de savoir où le code d'un contrat est exécuté, en termes de matériel physique, est souvent posée. La réponse est simple : le processus d'exécution du code du contrat fait partie de la définition de la fonction de transition d'état, qui fait partie de l'algorithme de validation de bloc. Donc si une transaction est ajoutée au bloc `B`, l'exécution du code engendrée par cette transaction sera exécutée par tous les nœuds, maintenant et à l'avenir, qui téléchargent et valident le bloc `B`.
 
 ## Applications {#applications}
 
@@ -263,16 +263,16 @@ Le code de base d'une telle implémentation en Serpent ressemble à ceci :
 
 ```py
 def send(to, value):
-    if self.storage[msg.sender] >= value:
-        self.storage[msg.sender] = self.storage[msg.sender] - value
-        self.storage[to] = self.storage[to] + value
+  if self.storage[msg.sender] >= value:
+    self.storage[msg.sender] = self.storage[msg.sender] - value
+    self.storage[to] = self.storage[to] + value
 ```
 
 Il s'agit fondamentalement d'une implémentation littérale de la fonction de transition d'état de « système bancaire » décrite précédemment dans ce document. Quelques lignes de code supplémentaires sont nécessaires pour spécifier l'étape initiale de distribution des unités monétaires et quelques autres cas particuliers, et idéalement une fonction sera ajoutée pour permettre à d'autres contrats d'obtenir le solde d'une adresse. C'est tout ce qu'il y a à faire ! En théorie, les systèmes de jetons basés sur Ethereum fonctionnant comme des sous-monnaies peuvent potentiellement présenter une autre caractéristique importante qui fait défaut aux méta-monnaies implémentées sur le Bitcoin en chaîne : la capacité de payer les frais de transaction directement dans cette monnaie. Pour mettre cela en œuvre, le contrat gère un solde en ETH grâce auquel il rembourse l'expéditeur du montant en ETH utilisé pour payer les frais, et rééquilibre son solde en collectant les unités monétaires internes qu'il prend en frais pour les revendre dans une vente aux enchères permanente. Les utilisateurs ont donc besoin « d'activer » leurs comptes avec de l'ether (ETH), mais une fois cela fait, ils peuvent réutiliser cette somme puisqu'elle est à chaque fois remboursée par le contrat.
 
-### Produits financiers dérivés et monnaies à valeur stable {#financial-derivatives-and-stable-value-currencies}
+### Dérivés financiers et monnaies à valeur stable {#financial-derivatives-and-stable-value-currencies}
 
-Les produits financiers dérivés sont l'application la plus courante d'un « contrat intelligent » et l'une des plus simples à implémenter en programmation. La principale difficulté dans l'implémentation de contrats financiers est qu'ils nécessitent pour la plupart une référence à une cotation externe. Un contrat intelligent de couverture contre la volatilité de l'ETH (ou de toute autre cryptomonnaie) par rapport au dollar US serait, par exemple, une application très intéressante, mais cela impliquerait que le contrat connaisse le taux de change ETH/USD. Pour ce faire, la méthode la plus simple serait d'utiliser un contrat de « flux de données » géré par une entité définie (par ex., le NASDAQ) et conçu pour que cette entité puisse le mettre à jour quand cela est nécessaire, et qui fournirait une interface permettant à d'autres contrats de lui envoyer un message afin d'obtenir une réponse donnant le taux de change.
+Les produits financiers dérivés sont l'application la plus courante d'un « contrat intelligent » et l'une des plus simples à implémenter en programmation. La principale difficulté dans l'implémentation de contrats financiers est qu'ils nécessitent pour la plupart une référence à une cotation externe. Un contrat intelligent de couverture contre la volatilité de l'ETH (ou de toute autre cryptomonnaie) par rapport au dollar US serait, par exemple, une application très intéressante, mais cela impliquerait que le contrat connaisse le taux de change ETH/USD. La manière la plus simple de le faire est d'utiliser un contrat de « flux de données » maintenu par une partie spécifique (par ex., NASDAQ) conçu de manière à ce que cette partie ait la capacité de mettre à jour le contrat selon les besoins, et fournissant une interface qui permet à d'autres contrats d'envoyer un message à ce contrat et d'obtenir en retour une réponse qui fournit le prix.
 
 Avec cet élément essentiel, le contrat de couverture ressemblerait à ceci :
 
@@ -281,13 +281,13 @@ Avec cet élément essentiel, le contrat de couverture ressemblerait à ceci :
 3. On enregistre la valeur en USD de 1 000 ETH dans l'espace de stockage du contrat, valeur calculée en interrogeant le contrat de flux de données. Appelons cette valeur $x.
 4. Après 30 jours, on autorise A ou B à « réactiver » le contrat afin d'envoyer l'équivalent de $x en ETH (calculé en interrogeant de nouveau le contrat de flux de données afin d'obtenir le nouveau taux) à A et le reste à B.
 
-Ce type de contrat représenterait un beau potentiel dans le monde du cryptocommerce. Un des principaux problèmes souvent mentionné sur les cryptomonnaies, c'est leur volatilité : même si bon nombre d'utilisateurs et commerçants sont intéressés par la fiabilité et la facilité d'utilisation des actifs cryptographiques, il ne souhaitent pas risquer de perdre 23 % de leurs fonds en une seule journée. Jusqu'à présent, la solution la plus souvent proposée était d'avoir des actifs adossés à un émetteur. L'idée est qu'un émetteur crée une sous-monnaie, dans laquelle il a le droit d'émettre et de révoquer des unités, et en fournit une unité à toute personne lui procurant (hors-ligne) une unité d'un actif sous-jacent donné (par ex., l'or, le dollar US). L'émetteur promet ensuite de fournir une unité de l'actif sous-jacent à toute personne qui lui envoie une unité du crypto-actif. Ce mécanisme permet à n'importe quel actif non cryptographique d'être « transformé » en crypto-actif, si l'on peut faire confiance à l'émetteur.
+Ce type de contrat représenterait un beau potentiel dans le monde du cryptocommerce. Un des principaux problèmes souvent mentionné sur les cryptomonnaies, c'est leur volatilité : même si bon nombre d'utilisateurs et commerçants sont intéressés par la fiabilité et la facilité d'utilisation des actifs cryptographiques, il ne souhaitent pas risquer de perdre 23 % de leurs fonds en une seule journée. Jusqu'à présent, la solution la plus couramment proposée a été les actifs garantis par l'émetteur ; l'idée est qu'un émetteur crée une sous-monnaie dans laquelle il a le droit d'émettre et de révoquer des unités, et fournit une unité de la monnaie à quiconque lui fournit (hors ligne) une unité d'un actif sous-jacent spécifié (par ex., or, USD). L'émetteur promet ensuite de fournir une unité de l'actif sous-jacent à toute personne qui lui envoie une unité du crypto-actif. Ce mécanisme permet à n'importe quel actif non cryptographique d'être « transformé » en crypto-actif, si l'on peut faire confiance à l'émetteur.
 
-Dans la pratique, néanmoins, les émetteurs ne sont pas toujours fiables, et dans certains cas l'infrastructure bancaire est trop fragile, ou trop hostile, pour permettre l'existence de tels services. Les produits financiers dérivés constituent une alternative. Ici, au lieu d'un unique émetteur fournissant les fonds pour adosser un actif, c'est un marché décentralisé de spéculateurs pariant sur la hausse du prix d'un crypto-actif de référence (par exemple l'ETH), qui remplit ce rôle. Contrairement aux émetteurs, les spéculateurs ne peuvent pas faire défaut, car le contrat de couverture conserve leurs fonds sous forme de dépôt fiduciaire. Notez que cette approche n'est pas totalement décentralisée, car une source de confiance est toujours nécessaire pour fournir le téléscripteur bien que l'amélioration soit massive en termes de réduction des besoins d'infrastructure (contrairement à un émetteur, la publication d'un taux de change ne nécessite aucun permis et peut être considérée comme de la liberté de parole) et des possibilités de fraude.
+Dans la pratique, néanmoins, les émetteurs ne sont pas toujours fiables, et dans certains cas l'infrastructure bancaire est trop fragile, ou trop hostile, pour permettre l'existence de tels services. Les produits financiers dérivés constituent une alternative. Ici, au lieu qu'un seul émetteur fournisse les fonds pour garantir un actif, c'est un marché décentralisé de spéculateurs, pariant que le prix d'un actif de référence cryptographique (par ex., ETH) augmentera, qui joue ce rôle. Contrairement aux émetteurs, les spéculateurs ne peuvent pas faire défaut, car le contrat de couverture conserve leurs fonds sous forme de dépôt fiduciaire. Notez que cette approche n'est pas totalement décentralisée, car une source de confiance est toujours nécessaire pour fournir le téléscripteur bien que l'amélioration soit massive en termes de réduction des besoins d'infrastructure (contrairement à un émetteur, la publication d'un taux de change ne nécessite aucun permis et peut être considérée comme de la liberté de parole) et des possibilités de fraude.
 
 ### Systèmes d'identité et de réputation {#identity-and-reputation-systems}
 
-La toute première cryptomonnaie alternative, [Namecoin](http://namecoin.org/), a tenté d'utiliser une blockchain similaire à celle de Bitcoin pour fournir un système d'enregistrement de noms, dans lequel les utilisateurs pouvaient enregistrer leurs noms dans une base de données publique avec d'autres données. C'est dans le cadre d'un système [DNS](https://wikipedia.org/wiki/Domain_Name_System), qui associe des noms de domaine comme "bitcoin.org" (ou pour Namecoin, "bitcoin.bit") à une adresse IP, qu'elle est principalement utilisée. D'autres utilisations incluent l’authentification d'e-mails, et potentiellement des systèmes de réputation plus perfectionnés. Voilà un contrat élémentaire permettant de fournir un système d'enregistrement de noms similaire à celui de Namecoin sur Ethereum :
+La toute première cryptomonnaie alternative, [Namecoin](http://namecoin.org/), a tenté d'utiliser une blockchain de type Bitcoin pour fournir un système d'enregistrement de noms, où les utilisateurs peuvent enregistrer leurs noms dans une base de données publique aux côtés d'autres données. Le principal cas d'utilisation cité est pour un système [DNS](https://wikipedia.org/wiki/Domain_Name_System), faisant correspondre des noms de domaine comme « bitcoin.org » (ou, dans le cas de Namecoin, « bitcoin.bit ») à une adresse IP. D'autres utilisations incluent l’authentification d'e-mails, et potentiellement des systèmes de réputation plus perfectionnés. Voilà un contrat élémentaire permettant de fournir un système d'enregistrement de noms similaire à celui de Namecoin sur Ethereum :
 
 ```py
 def register(name, value):
@@ -295,13 +295,13 @@ def register(name, value):
         self.storage[name] = value
 ```
 
-Le contrat est très simple, il s’agit simplement d’une base de données au sein du réseau Ethereum qui peut être ajoutée, mais non modifiée ou supprimée. N'importe qui peut enregistrer un nom et une valeur, et cet enregistrement est inscrit pour toujours. Un contrat d’enregistrement de nom plus sophistiqué aura une « clause fonction » permettant à d'autres contrats de l'interroger, ainsi qu'un mécanisme autorisant le « propriétaire » (le premier déposant) d'un nom à en changer les données ou à en transférer la propriété. On peut même ajouter à cela une fonctionnalité de réputation et de réseau de confiance.
+Le contrat est très simple, il s’agit simplement d’une base de données au sein du réseau Ethereum qui peut être ajoutée, mais non modifiée ou supprimée. N'importe qui peut enregistrer un nom et une valeur, et cet enregistrement est inscrit pour toujours. Un contrat d'enregistrement de nom plus sophistiqué aura également une « clause de fonction » permettant à d'autres contrats de l'interroger, ainsi qu'un mécanisme pour le « propriétaire » (c.-à-d. le premier enregistreur) d'un nom de modifier les données ou de transférer la propriété. On peut même ajouter à cela une fonctionnalité de réputation et de réseau de confiance.
 
-### Stockage décentralisé de fichiers {#decentralized-file-storage}
+### Stockage de fichiers décentralisé {#decentralized-file-storage}
 
 Ces dernières années, plusieurs startups ont été créées dans le secteur du stockage de fichiers en ligne (la plus importante étant Dropbox). Dans le cadre d'un abonnement mensuel payant, elles proposent aux utilisateurs de stocker une copie de sauvegarde de leur disque dur, à laquelle ils peuvent accéder à leur convenance. Toutefois, le marché du stockage de fichiers en ligne reste à ce jour relativement inefficace. Un rapide survol des solutions existantes montre que dans la fourchette de 20 à 200 Go, où il n'existe ni offre gratuite ni offre professionnelle avec remises, le prix mensuel du stockage est supérieur à celui du disque dur lui-même. Les contrats Ethereum permettent le développement d'un écosystème de stockage de fichiers décentralisé, où chaque utilisateur peut recevoir de petites sommes d'argent en louant ses propres disques durs, l'espace inutilisé contribuant à réduire davantage le coût du stockage des fichiers.
 
-La clé de voûte d'un tel système est ce que nous avons appelé le « contrat Dropbox décentralisé ». Ce contrat fonctionne de la façon suivante. Dans un premier temps, les données choisies sont divisées en blocs qui servent à construire un arbre de Merkle, chaque bloc étant chiffré pour assurer la confidentialité. Un contrat est ensuite créé avec une règle stipulant que tous les N blocs, le contrat choisira un index aléatoire de l'arbre de Merkle (en utilisant le hachage du bloc précédent, accessible depuis le code du contrat, comme source aléatoire) et donnera X ETH à la première entité qui fournira une transaction avec une preuve de propriété simplifiée similaire à une vérification du paiement du bloc situé à cet index spécifique dans l'arbre de Merkle. Lorsqu'un utilisateur souhaite télécharger de nouveau un fichier, il peut utiliser un protocole de canal de micropaiement (par ex., payer 1 zsabo par 32 kilo-octets) pour récupérer le fichier. En termes de frais, l'approche la plus efficace consiste pour le payeur à ne pas publier la transaction avant la fin, en la remplaçant plutôt par une autre, plus lucrative, avec le même nonce après chaque 32 kilo-octets.
+La clé de voûte d'un tel système est ce que nous avons appelé le « contrat Dropbox décentralisé ». Ce contrat fonctionne de la façon suivante. Dans un premier temps, les données choisies sont divisées en blocs qui servent à construire un arbre de Merkle, chaque bloc étant chiffré pour assurer la confidentialité. Un contrat est ensuite créé avec une règle stipulant que tous les N blocs, le contrat choisira un index aléatoire de l'arbre de Merkle (en utilisant le hachage du bloc précédent, accessible depuis le code du contrat, comme source aléatoire) et donnera X ETH à la première entité qui fournira une transaction avec une preuve de propriété simplifiée similaire à une vérification du paiement du bloc situé à cet index spécifique dans l'arbre de Merkle. Lorsqu'un utilisateur veut retélécharger son fichier, il peut utiliser un protocole de canal de micropaiement (par ex., payer 1 szabo par 32 kilooctets) pour récupérer le fichier ; l'approche la plus efficace en termes de frais est que le payeur ne publie pas la transaction avant la fin, mais la remplace par une transaction légèrement plus lucrative avec le même nonce après chaque 32 kilooctets.
 
 Une fonctionnalité importante du protocole est que, bien qu'on ait l'impression de faire confiance à plusieurs nœuds aléatoires pour ne pas perdre le fichier, on peut quasiment supprimer ce risque en divisant le fichier en plusieurs parties par partage secret et en surveillant les contrats pour vérifier que chaque partie est toujours présente sur un nœud. Si un contrat émet toujours des paiements, cela apporte la preuve cryptographique que quelqu'un stocke toujours le fichier.
 
@@ -311,11 +311,11 @@ Le concept général d'une « organisation autonome décentralisée » (DAO) est
 
 Une description générale de la façon de coder une DAO est fournie ci-après. La conception la plus simple est tout simplement un morceau de code qui se modifie lui-même et qui ne change que si les deux tiers des membres acceptent la modification. Bien que le code soit théoriquement immuable, on peut facilement contourner ceci et avoir une mutabilité de fait en disposant les morceaux de code dans des contrats séparés, et en stockant l'adresse des contrats à appeler dans un stockage modifiable. Dans une implémentation simple d'un tel contrat DAO, il y aurait donc trois types de transactions, identifiables par les données fournies dans la transaction :
 
-- `[0,i,K,V]` pour enregistrer une proposition avec l'index `i` pour changer l'adresse à l'index de stockage `K` à la valeur `V`
+- `[0,i,K,V]` pour enregistrer une proposition avec l'index `i` afin de changer l'adresse à l'index de stockage `K` à la valeur `V`
 - `[1,i]` pour enregistrer un vote en faveur de la proposition `i`
-- `[2,i]` pour finaliser la proposition `i` si suffisamment de votes ont été enregistrés
+- `[2,i]` pour finaliser la proposition `i` si suffisamment de votes ont été effectués
 
-Le contrat aurait alors des clauses pour chacun de ces types. Il conserverait un enregistrement de toutes les modifications de stockage ouvertes, ainsi qu'une liste de ceux qui ont voté pour. Il inclurait également une liste de tous les membres. Quand une modification de stockage atteint deux tiers de votes « pour » de la part des membres, une transaction de finalisation peut exécuter la modification. Un modèle plus sophistiqué aurait également une fonctionnalité de vote intégrée pour envoyer une transaction, ajouter ou retirer des membres, voire pour permettre une sorte de [démocratie délégative](https://wikipedia.org/wiki/Liquid_democracy)de vote (c.-à-d. que n'importe qui pourrait déléguer à quelqu'un son droit de vote, et l'affectation étant transitoire, si A assigne B et B assigne C, alors C détermine le vote de A). Cette conception permettrait à la DAO de se développer organiquement en tant que communauté décentralisée, permettant éventuellement aux membres de déléguer la tâche de filtrage des membres à des spécialistes, bien que, contrairement au « système actuel », les spécialistes puissent facilement apparaître et disparaître au fil du temps, à mesure que les membres individuels de la communauté changent d'orientation.
+Le contrat aurait alors des clauses pour chacun de ces types. Il conserverait un enregistrement de toutes les modifications de stockage ouvertes, ainsi qu'une liste de ceux qui ont voté pour. Il inclurait également une liste de tous les membres. Quand une modification de stockage atteint deux tiers de votes « pour » de la part des membres, une transaction de finalisation peut exécuter la modification. Un squelette plus sophistiqué aurait également une capacité de vote intégrée pour des fonctionnalités telles que l'envoi d'une transaction, l'ajout et la suppression de membres, et pourrait même prévoir une délégation de vote de style [Démocratie Liquide](https://wikipedia.org/wiki/Liquid_democracy) (c.-à-d. que n'importe qui peut désigner quelqu'un pour voter à sa place, et l'assignation est transitive, donc si A désigne B et B désigne C, alors C détermine le vote de A). Cette conception permettrait à la DAO de se développer organiquement en tant que communauté décentralisée, permettant éventuellement aux membres de déléguer la tâche de filtrage des membres à des spécialistes, bien que, contrairement au « système actuel », les spécialistes puissent facilement apparaître et disparaître au fil du temps, à mesure que les membres individuels de la communauté changent d'orientation.
 
 L'entreprise décentralisée constitue un autre modèle, où n'importe quel compte peut avoir zéro ou plus d'actions, et où deux tiers des actions sont requises pour prendre une décision. Un modèle complet impliquerait une fonctionnalité de gestion d'actifs, la possibilité de faire une offre pour acheter ou vendre des actions, et la possibilité d'accepter les offres (de préférence avec un mécanisme de correspondance d'ordres à l'intérieur du contrat). Une délégation existerait également, à la manière d'une démocratie délégative, généralisant le concept de « conseil d'administration ».
 
@@ -331,23 +331,23 @@ En principe, 1 % par jour suffit à Alice, mais si elle souhaite retirer davant
 
 **2. Assurance récolte**. On peut facilement créer un contrat de produits financiers dérivés en utilisant un flux de données météo au lieu d'un indice de prix. Si un agriculteur normand achète un produit financier dérivé dont les paiements sont inversement proportionnels aux précipitations enregistrées en Normandie et qu'une sécheresse se produit, l'agriculteur recevra automatiquement de l'argent. S'il pleut suffisamment, l'agriculteur sera satisfait, car ses cultures se porteront bien. Cela peut être étendu aux assurances contre les catastrophes naturelles en général.
 
-**3. Flux de données décentralisé**. À la différence, pour les contrats financiers, il est possible de décentraliser le flux de données via un protocole appelé [SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed)". SchellingCoin fonctionne de la façon suivante : N parties insèrent dans le système la valeur d'une donnée spécifique (par ex., le taux ETH/USD). Les valeurs sont triées et les sources de toutes les données comprises entre le 25ème et le 75ème centile reçoivent un jeton en récompense. Chacun a intérêt à donner la même réponse que tout le monde, et la seule valeur sur laquelle de nombreux acteurs peuvent être d'accord est celle évidente par défaut : la vraie valeur. Ceci crée un protocole décentralisé qui peut théoriquement fournir un certain nombre de valeurs, y compris le taux ETH/USD, la température à Berlin ou même le résultat d'un calcul particulier complexe.
+**3. Flux de données décentralisé**. Pour les contrats financiers sur différence, il pourrait être possible de décentraliser le flux de données via un protocole appelé « [SchellingCoin](https://blog.ethereum.org/2014/03/28/schellingcoin-a-minimal-trust-universal-data-feed/) ». SchellingCoin fonctionne essentiellement comme suit : N parties saisissent toutes dans le système la valeur d'une donnée donnée (par ex., le prix ETH/USD), les valeurs sont triées, et toute personne se situant entre le 25e et le 75e percentile reçoit un jeton en récompense. Chacun a intérêt à donner la même réponse que tout le monde, et la seule valeur sur laquelle de nombreux acteurs peuvent être d'accord est celle évidente par défaut : la vraie valeur. Ceci crée un protocole décentralisé qui peut théoriquement fournir un certain nombre de valeurs, y compris le taux ETH/USD, la température à Berlin ou même le résultat d'un calcul particulier complexe.
 
 **4. Dépôt fiduciaire multisignature intelligent**. Bitcoin permet des contrats de transactions multisignatures où, par exemple, trois des cinq clés données peuvent dépenser les fonds. Ethereum permet une plus grande granularité. Par exemple, 4 personnes sur 5 peuvent tout dépenser, 3 personnes sur 5 peuvent dépenser jusqu'à 10 % par jour et 2 personnes sur 5 peuvent dépenser jusqu'à 0,5 % par jour. En outre, la multisignature Ethereum est asynchrone : deux parties peuvent enregistrer leurs signatures sur la blockchain à différents moments, et la dernière signature enverra automatiquement la transaction.
 
-**5. Informatique dans le cloud**. La technologie de l'EVM peut également être utilisée pour créer un environnement informatique vérifiable, permettant aux utilisateurs de demander à d'autres d'effectuer des calculs, puis éventuellement de réclamer des preuves que les calculs ont été effectués correctement à certains points de contrôle choisis au hasard. Ceci permet de créer une informatique dans le cloud, où n'importe quel utilisateur peut participer avec son ordinateur de bureau, portable ou serveur spécialisé, et où un contrôle ponctuel, associé à des dépôts de garantie, permet de garantir que le système est digne de confiance (c'est-à-dire que les nœuds ne peuvent pas tricher de façon rentable). Toutefois, un tel système ne convient pas à toutes les tâches. Par exemple, celles nécessitant un niveau de communication interprocessus élevé ne peuvent pas être effectuées facilement dans un cloud comportant de nombreux nœuds. Toutefois, d'autres tâches sont beaucoup plus faciles à paralléliser. Des projets comme SETI@home, folding@home et les algorithmes génétiques peuvent facilement être implémentés sur une telle plateforme.
+**5. Informatique dans le cloud**. La technologie de l'EVM peut également être utilisée pour créer un environnement informatique vérifiable, permettant aux utilisateurs de demander à d'autres d'effectuer des calculs, puis éventuellement de réclamer des preuves que les calculs ont été effectués correctement à certains points de contrôle choisis au hasard. Cela permet la création d'un marché de l'informatique en nuage où tout utilisateur peut participer avec son ordinateur de bureau, son ordinateur portable ou son serveur spécialisé, et des vérifications ponctuelles ainsi que des dépôts de garantie peuvent être utilisés pour garantir que le système est digne de confiance (c.-à-d. que les nœuds ne peuvent pas tricher de manière rentable). Toutefois, un tel système ne convient pas à toutes les tâches. Par exemple, celles nécessitant un niveau de communication interprocessus élevé ne peuvent pas être effectuées facilement dans un cloud comportant de nombreux nœuds. Toutefois, d'autres tâches sont beaucoup plus faciles à paralléliser. Des projets comme SETI@home, folding@home et les algorithmes génétiques peuvent facilement être implémentés sur une telle plateforme.
 
-**6. Jeux d'argent et de hasard P2P**. Un certain nombre de protocoles de jeux d'argent et de hasard P2P, comme celui de [Cyberdice](http://www.cl.cam.ac.uk/~fms27/papers/2008-StajanoCla-cyberdice.pdf) de Frank Stajano et Richard Clayton, peuvent être implémentés sur la blockchain Ethereum. Le protocole le plus simple est en fait juste un contrat sur la différence du prochain hachage de bloc, et des protocoles plus avancés peuvent être construits à partir de là, créant des services de jeu d'argent et de hasard avec des frais proches de zéro, où il n'existe aucune possibilité de tricher.
+**6. Jeux d'argent et de hasard P2P**. Un grand nombre de protocoles de jeu peer-to-peer, tels que le [Cyberdice](http://www.cl.cam.ac.uk/~fms27/papers/2008-StajanoCla-cyberdice.pdf) de Frank Stajano et Richard Clayton, peuvent être implémentés sur la blockchain Ethereum. Le protocole le plus simple est en fait juste un contrat sur la différence du prochain hachage de bloc, et des protocoles plus avancés peuvent être construits à partir de là, créant des services de jeu d'argent et de hasard avec des frais proches de zéro, où il n'existe aucune possibilité de tricher.
 
-**7. Marchés prédictifs**. Avec un oracle ou SchellingCoin, les marchés prédictifs sont aussi faciles à implémenter. Avec SchellingCoin, ceux-ci pourraient devenir la première application grand public d'une "[futarchie](http://hanson.gmu.edu/futarchy.html)" comme protocole de gouvernance des organisations décentralisées.
+**7. Marchés prédictifs**. Moyennant un oracle ou SchellingCoin, les marchés de prédiction sont également faciles à mettre en œuvre, et les marchés de prédiction ainsi que SchellingCoin pourraient s'avérer être la première application grand public de la [futarchie](https://mason.gmu.edu/~rhanson/futarchy.html) en tant que protocole de gouvernance pour les organisations décentralisées.
 
-**8. Places de marché décentralisées sur la chaîne**, utilisant un système d'identité et de réputation comme base.
+**8. Places de marché décentralisées sur la chaîne**, utilisant le système d'identité et de réputation comme base.
 
-## Généralités et préoccupations {#miscellanea-and-concerns}
+## Divers et préoccupations {#miscellanea-and-concerns}
 
 ### Implémentation modifiée de GHOST {#modified-ghost-implementation}
 
-Le protocole « Greedy Heaviest Observed Subtree » (GHOST) est une innovation introduite par Yonatan Sompolinsky et Aviv Zohar en [décembre 2013](https://eprint.iacr.org/2013/881.pdf). La naissance de GHOST résulte du fait que les blockchains avec des temps de confirmation rapides souffrent d'une faible sécurité en raison d'un taux élevé de blocs caducs. Un certain temps étant nécessaire pour que les blocs se propagent à travers le réseau, si un mineur A mine un bloc et qu'un mineur B parvient à miner un autre bloc avant que le bloc du mineur A ne soit propagé à B, le bloc du mineur B est perdu et ne contribue pas à la sécurité du réseau. Par ailleurs, il existe un problème de centralisation : si le mineur A est un groupe de minage disposant de 30 % de la puissance de hachage du réseau (hashpower) et que B n'en a que 10 %, A risque de produire un bloc caduc 70 % du temps (puisque les autres 30 % du temps, A produit le dernier bloc et obtient donc immédiatement les données de minage). B risque de son côté de produire un bloc caduc 90 % du temps. Ainsi, si l'intervalle entre les blocs est assez court pour que le taux de blocs caducs soit élevé, A sera nettement plus efficace simplement en raison de sa taille. Ces deux effets combinés font que les blockchains produisant rapidement des blocs sont particulièrement susceptibles de générer un groupe de minage bénéficiant d'un pourcentage assez large de la puissance de hachage du réseau. Celui-ci aura alors, de fait, le contrôle du processus de minage.
+Le protocole « Greedy Heaviest Observed Subtree » (GHOST) est une innovation introduite pour la première fois par Yonatan Sompolinsky et Aviv Zohar en [décembre 2013](https://eprint.iacr.org/2013/881.pdf). La naissance de GHOST résulte du fait que les blockchains avec des temps de confirmation rapides souffrent d'une faible sécurité en raison d'un taux élevé de blocs caducs. Un certain temps étant nécessaire pour que les blocs se propagent à travers le réseau, si un mineur A mine un bloc et qu'un mineur B parvient à miner un autre bloc avant que le bloc du mineur A ne soit propagé à B, le bloc du mineur B est perdu et ne contribue pas à la sécurité du réseau. Par ailleurs, il existe un problème de centralisation : si le mineur A est un groupe de minage disposant de 30 % de la puissance de hachage du réseau (hashpower) et que B n'en a que 10 %, A risque de produire un bloc caduc 70 % du temps (puisque les autres 30 % du temps, A produit le dernier bloc et obtient donc immédiatement les données de minage). B risque de son côté de produire un bloc caduc 90 % du temps. Ainsi, si l'intervalle entre les blocs est assez court pour que le taux de blocs caducs soit élevé, A sera nettement plus efficace simplement en raison de sa taille. Ces deux effets combinés font que les blockchains produisant rapidement des blocs sont particulièrement susceptibles de générer un groupe de minage bénéficiant d'un pourcentage assez large de la puissance de hachage du réseau. Celui-ci aura alors, de fait, le contrôle du processus de minage.
 
 Comme l'ont décrit Sompolinsky et Zohar, GHOST résout le premier problème de perte de sécurité du réseau en incluant les blocs caducs dans le calcul de la longueur de la chaîne. C'est-à-dire que non seulement le parent et les ancêtres d'un bloc, mais aussi les descendants caducs de l'ancêtre du bloc (dans le jargon Ethereum, les « oncles ») sont ajoutés au calcul permettant d'établir quel bloc a le plus grand nombre cumulé de preuves de travail. Pour résoudre le second problème, celui de la centralisation, il faut dépasser le protocole décrit par Sompolinsky et Zohar, et donner une récompense aux blocs caducs : un bloc caduc reçoit 87,5 % de sa récompense de base, et le neveu qui inclut le bloc caduc reçoit les 12,5 % restants. Les frais de transaction, quant à eux, ne sont pas distribués aux oncles.
 
@@ -359,7 +359,7 @@ Ethereum implémente une version simplifiée de GHOST qui ne descend que sur sep
   - Il ne peut pas être un ancêtre de B.
   - Un oncle doit être un en-tête de bloc valide, mais il n'est pas nécessaire qu'il soit un bloc précédemment vérifié ni même valide.
   - Un oncle doit être différent de tous les oncles inclus dans les blocs précédents et de tous les autres oncles inclus dans le même bloc (inclusion non double).
-- Pour chaque oncle U dans le bloc B, le mineur de B obtient 3,125 % supplémentaires ajoutés à sa récompense coinbase et le mineur de `U` obtient 93,75 % d'une récompense standard coinbase.
+- Pour chaque oncle U dans le bloc B, le mineur de B obtient 3,125 % supplémentaires ajoutés à sa récompense coinbase et le mineur de <code>U</code> obtient 93,75 % d'une récompense standard coinbase.
 
 Cette version limitée de GHOST, dont les oncles ne peuvent être inclus que jusqu'à 7 générations, a été utilisée pour deux raisons. Tout d'abord, une version illimitée de GHOST entraînerait trop de complications dans le calcul des oncles valides pour un bloc donné. Deuxièmement, une version illimitée de GHOST avec compensation tel qu'utilisée dans Ethereum supprime l'intérêt pour un mineur de miner sur la chaîne principale et non la chaîne d'un attaquant public.
 
@@ -369,12 +369,12 @@ Cette version limitée de GHOST, dont les oncles ne peuvent être inclus que jus
 
 Il s'avère cependant que lorsqu'on lui donne une hypothèse simplificatrice inexacte particulière, cette faille du mécanisme de marché s'annule comme par magie. L'argument est le suivant. Dans ce scénario imaginaire :
 
-1. Une transaction donne lieu à des `k` opérations, offrant la récompense `kR` à tout mineur qui l'inclut, où `R` est fixé par l'expéditeur et `k` et `R` sont (approximativement) visibles par le mineur au préalable.
-2. Une opération a un coût de traitement `C` pour n'importe quel nœud (c.-à-d. que tous les nœuds ont la même efficacité).
-3. Il existe `N` nœuds de minage, chacun ayant exactement la même puissance de traitement (c.-à-d. `1/N` du total).
+1. Une transaction conduit à `k` opérations, offrant la récompense `kR` à tout mineur qui l'inclut, où `R` est défini par l'expéditeur et `k` et `R` sont (grossièrement) visibles par le mineur au préalable.
+2. Une opération a un coût de traitement de `C` pour tout nœud (c.-à-d. que tous les nœuds ont une efficacité égale)
+3. Il y a `N` nœuds de minage, chacun avec une puissance de traitement exactement égale (c.-à-d. `1/N` du total)
 4. Il n'existe aucun nœud complet non minier.
 
-Un mineur sera prêt à traiter une transaction si la récompense attendue est supérieure au coût. La récompense attendue est donc `kR/N` puisque le mineur a `1/N` chance de traiter le bloc suivant, et le coût de traitement pour le mineur est simplement `kC`. Par conséquent, les mineurs incluront les transactions où `kR/N > kC`, ou `R > NC`. Notez que `R` représente les frais par opération fournis par l'expéditeur, et constitue donc une limite inférieure sur le bénéfice qu'il tire de la transaction, et `NC` est le coût du traitement d'une opération pour l'ensemble du réseau. Les mineurs sont donc incités à n'inclure que les transactions pour lesquelles le bénéfice utilitaire total dépasse le coût.
+Un mineur sera prêt à traiter une transaction si la récompense attendue est supérieure au coût. Ainsi, la récompense attendue est `kR/N` puisque le mineur a une chance de `1/N` de traiter le bloc suivant, et le coût de traitement pour le mineur est simplement `kC`. Par conséquent, les mineurs incluront des transactions où `kR/N > kC`, ou `R > NC`. Notez que `R` est le frais par opération fourni par l'expéditeur, et est donc une borne inférieure du bénéfice que l'expéditeur tire de la transaction, et `NC` est le coût pour l'ensemble du réseau du traitement d'une opération. Les mineurs sont donc incités à n'inclure que les transactions pour lesquelles le bénéfice utilitaire total dépasse le coût.
 
 Il existe cependant plusieurs écarts importants par rapport à ces hypothèses dans la réalité :
 
@@ -383,29 +383,33 @@ Il existe cependant plusieurs écarts importants par rapport à ces hypothèses
 3. La répartition de la puissance de minage peut se révéler radicalement inégalitaire dans la pratique.
 4. Les spéculateurs, les ennemis politiques et les fous dont la fonction utilitaire inclut de causer du tort au réseau existent, et ils peuvent habilement configurer des contrats où leur coût est bien inférieur au coût payé par les autres nœuds de vérification.
 
-(1) génère une tendance où le mineur inclut moins de transactions, et (2) augmente le `NC` ; par conséquent, ces deux effets s'annulent au moins partiellement. <sup>[Comment ?](https://web.archive.org/web/20250427212319/https://github.com/ethereum/wiki/issues/447#issuecomment-316972260#issuecomment-316972260)</sup>. Les points (3) et (4) constituent les problèmes majeurs. Pour les résoudre, nous instituons simplement un plafond flottant : aucun bloc ne peut avoir plus d'opérations que `BLK_LIMIT_FACTOR` fois la moyenne exponentielle variable à long terme. Spécifiquement :
+(1) tend à inciter le mineur à inclure moins de transactions, et
+(2) augmente `NC` ; par conséquent, ces deux effets s'annulent au moins partiellement
+l'un l'autre.<sup>[Comment ?](https://web.archive.org/web/20250427212319/https://github.com/ethereum/wiki/issues/447#issuecomment-316972260#issuecomment-316972260)</sup>
+(3) et (4) sont le problème majeur ; pour les résoudre, nous instituons simplement un plafond flottant : aucun bloc ne peut avoir plus d'opérations que `BLK_LIMIT_FACTOR` fois la moyenne mobile exponentielle à long terme.
+Spécifiquement :
 
 ```js
 blk.oplimit = floor((blk.parent.oplimit \* (EMAFACTOR - 1) +
 floor(parent.opcount \* BLK\_LIMIT\_FACTOR)) / EMA\_FACTOR)
 ```
 
-`BLK_LIMIT_FACTOR` et `EMA_FACTOR` sont des constantes qui seront définies à 65 536 et 1,5 pour le moment, mais qui seront probablement modifiées après une analyse approfondie.
+`BLK_LIMIT_FACTOR` et `EMA_FACTOR` sont des constantes qui seront définies à 65536 et 1,5 pour le moment, mais seront probablement modifiées après une analyse plus approfondie.
 
 Il existe un autre facteur qui dissuade les mineurs d'ajouter des blocs de grande taille dans Bitcoin : cela prend plus de temps de les propager et le risque qu'ils deviennent caducs est plus élevé. Dans Ethereum, les blocs consommant beaucoup de gaz peuvent également prendre plus de temps à se propager, à la fois car ils sont physiquement plus grands, mais aussi car ils requièrent plus de temps pour traiter les transitions d'état des transactions à valider. L'effet dissuasif associé aux délais est un facteur important chez Bitcoin, mais moindre chez Ethereum en raison du protocole GHOST, le recours à des limites de blocs réglementées offrant une base de référence plus stable.
 
 ### Calcul et Turing-complétude {#computation-and-turing-completeness}
 
-Il est important de noter que la machine virtuelle Ethereum est Turing-complète, ce qui signifie que le code de l'EVM peut coder tout calcul pouvant être effectué, y compris les boucles infinies. Le code EVM permet la création de boucles de deux façons. Il y a d'abord l'instruction `JUMP` qui permet au programme de revenir à un endroit précédent du code, puis l'instruction `JUMPI` qui permet de faire des sauts conditionnels, ce qui permet des déclarations comme `while x < 27: x = x * 2`. Ensuite, les contrats peuvent appeler d'autres contrats, ce qui permet potentiellement de créer des boucles par récursion. Cela conduit naturellement à la question suivante : les utilisateurs malveillants peuvent-ils arrêter les mineurs et les nœuds complets en les forçant à entrer dans une boucle infinie ? Cette question se pose en raison d'un problème informatique connu sous le nom de « problème de l'arrêt » : il n'existe généralement aucun moyen de savoir si un programme donné s'arrêtera un jour ou non.
+Il est important de noter que la machine virtuelle Ethereum est Turing-complète, ce qui signifie que le code de l'EVM peut coder tout calcul pouvant être effectué, y compris les boucles infinies. Le code EVM permet la création de boucles de deux façons. Premièrement, il y a une instruction `JUMP` qui permet au programme de revenir à un point précédent dans le code, et une instruction `JUMPI` pour faire des sauts conditionnels, permettant des déclarations comme `while x < 27: x = x * 2`. Ensuite, les contrats peuvent appeler d'autres contrats, ce qui permet potentiellement de créer des boucles par récursion. Cela conduit naturellement à la question suivante : les utilisateurs malveillants peuvent-ils arrêter les mineurs et les nœuds complets en les forçant à entrer dans une boucle infinie ? Cette question se pose en raison d'un problème informatique connu sous le nom de « problème de l'arrêt » : il n'existe généralement aucun moyen de savoir si un programme donné s'arrêtera un jour ou non.
 
 Comme décrit dans la section sur la transition d'état, notre solution fonctionne en demandant à une transaction de fixer le nombre maximum d'étapes de calcul qu'elle est autorisée à effectuer. Si l'exécution prend plus de temps, le calcul est annulé, mais les frais sont néanmoins payés. Les messages fonctionnent de la même façon. Pour montrer la motivation derrière notre solution, considérons les exemples suivants :
 
 - Un attaquant crée un contrat qui exécute une boucle infinie, puis envoie une transaction activant cette boucle au mineur. Le mineur traitera la transaction en exécutant la boucle infinie et attendra qu'elle soit à court de gaz. Même si l'exécution tombe en panne sèche et s'arrête à mi-chemin, la transaction reste valide et le mineur continue à réclamer les frais à l'attaquant pour chaque étape de calcul.
-- Un attaquant crée une très longue boucle infinie dans l'intention de forcer le mineur à continuer de calculer pendant un temps si long qu'au moment où le calcul se terminera, quelques blocs supplémentaires seront sortis et il sera impossible pour le mineur d'inclure la transaction pour réclamer les frais. L'attaquant devra cependant soumettre une valeur pour `STARTGAS` limitant le nombre d'étapes de calcul que l'exécution peut effectuer, de sorte que le mineur saura à l'avance que le calcul prendra un nombre d'étapes excessif.
-- Un attaquant voit un contrat avec un code de type `send(A,contract.storage[A]); contract.storage[A] = 0` et envoie une transaction avec juste assez de gaz pour exécuter la première étape, mais pas la seconde (c.-à-d. effectuer un retrait sans défalquer le montant correspondant du solde). L'auteur du contrat n'a pas à se préoccuper de se protéger contre de telles attaques, car si l'exécution s'arrête à mi-chemin des modifications, celles-ci sont annulées.
+- Un attaquant crée une très longue boucle infinie dans l'intention de forcer le mineur à continuer de calculer pendant un temps si long qu'au moment où le calcul se terminera, quelques blocs supplémentaires seront sortis et il sera impossible pour le mineur d'inclure la transaction pour réclamer les frais. Cependant, l'attaquant devra soumettre une valeur pour `STARTGAS` limitant le nombre d'étapes de calcul que l'exécution peut prendre, de sorte que le mineur saura à l'avance que le calcul prendra un nombre d'étapes excessivement grand.
+- Un attaquant voit un contrat avec un code de la forme `send(A,contract.storage[A]); contract.storage[A] = 0`, et envoie une transaction avec juste assez de gaz pour exécuter la première étape mais pas la seconde (c.-à-d. effectuer un retrait mais ne pas laisser le solde diminuer). L'auteur du contrat n'a pas à se préoccuper de se protéger contre de telles attaques, car si l'exécution s'arrête à mi-chemin des modifications, celles-ci sont annulées.
 - Un contrat financier fonctionne en prenant la médiane de neuf flux de données exclusifs afin de minimiser le risque. Un attaquant prend le contrôle de l'un des flux de données, qui est conçu pour être modifiable via le mécanisme d'appel d'adresse variable décrit dans la section sur les DAO, et le convertit pour qu'il exécute une boucle infinie, essayant ainsi de forcer toute tentative de réclamation des fonds du contrat financier à tomber en panne de gaz. Le contrat financier peut toutefois fixer une limite de gaz sur le message pour éviter ce problème.
 
-L'alternative à la Turing-complétude est la Turing-incomplétude, où `JUMP` et `JUMPI` n'existent pas et où une seule copie de chaque contrat est autorisée dans la pile d'appels à un moment donné. Avec ce système, le système de frais décrit et les incertitudes entourant l'efficacité de notre solution pourraient disparaître, puisque le coût d'exécution d'un contrat serait limité au-dessus par sa taille. De plus, la Turing-incomplétude n'est même pas une limitation si importante. Parmi tous nos exemples de contrats conçus en interne, un seul nécessitait une boucle, et même celle-ci pouvait être supprimée en effectuant 26 répétitions d'un morceau de code d'une ligne. Étant donné les sérieuses implications de la Turing-complétude, et des bénéfices limités, pourquoi ne pas simplement utiliser un langage Turing-incomplet ? En réalité, la Turing-incomplétude est loin d'être une parfaite solution au problème. Pour comprendre pourquoi, il suffit de considérer les contrats suivants :
+L'alternative à la Turing-complétude est la Turing-incomplétude, où `JUMP` et `JUMPI` n'existent pas et où une seule copie de chaque contrat est autorisée à exister dans la pile d'appels à un moment donné. Avec ce système, le système de frais décrit et les incertitudes entourant l'efficacité de notre solution pourraient disparaître, puisque le coût d'exécution d'un contrat serait limité au-dessus par sa taille. De plus, la Turing-incomplétude n'est même pas une limitation si importante. Parmi tous nos exemples de contrats conçus en interne, un seul nécessitait une boucle, et même celle-ci pouvait être supprimée en effectuant 26 répétitions d'un morceau de code d'une ligne. Étant donné les sérieuses implications de la Turing-complétude, et des bénéfices limités, pourquoi ne pas simplement utiliser un langage Turing-incomplet ? En réalité, la Turing-incomplétude est loin d'être une parfaite solution au problème. Pour comprendre pourquoi, il suffit de considérer les contrats suivants :
 
 ```sh
 C0: call(C1); call(C1);
@@ -413,7 +417,7 @@ C1: call(C2); call(C2);
 C2: call(C3); call(C3);
 ...
 C49: call(C50); call(C50);
-C50: (run one step of a program and record the change in storage)
+C50: (exécuter une étape d'un programme et enregistrer le changement dans le stockage)
 ```
 
 Envoyez maintenant une transaction à A. Ainsi, en 51 transactions, nous avons un contrat qui effectue jusqu'à 2<sup>50</sup> étapes de calcul. Les mineurs pourraient essayer de détecter ces bombes logiques à l'avance en maintenant pour chaque contrat une valeur spécifiant le nombre maximum d'étapes de calcul autorisé, et en calculant cette valeur pour les contrats appelant d'autres contrats de manière récursive, mais cela nécessiterait que les mineurs interdisent les contrats qui créent d'autres contrats (puisque la création et l'exécution des 26 contrats ci-dessus pourraient facilement être regroupées en un seul contrat). Un autre point problématique est que le champ d'adresse d'un message est une variable, de sorte qu'en général, il n'est même pas possible de savoir à l'avance quels autres contrats un contrat donné va appeler. Au final, nous arrivons donc à une conclusion surprenante : la Turing-complétude est étonnamment facile à gérer, tout comme son absence est tout aussi étonnamment difficile à gérer, à moins que les mêmes contrôles soient en place. Mais dans ce cas, pourquoi ne pas laisser le protocole être Turing-complet ?
@@ -442,25 +446,25 @@ Le modèle d'émission sera le suivant :
 | Acheteurs                    | 83,5 %       | 68,6 %     | 40,0 %      |
 | Réserve dépensée avant vente | 8,26 %       | 6,79 %     | 3,96 %      |
 | Réserve utilisée après vente | 8,26 %       | 6,79 %     | 3,96 %      |
-| Mineurs                      | 0 %          | 17,8 %     | 52,0 %      |
+| Mineurs                      | 0 %          | 17,8 %     | 52,0 %      |
 
 #### Taux de croissance de l'offre à long terme (en pourcentage)
 
-![Inflation Ethereum](./ethereum-inflation.png)
+![Inflation d'Ethereum](./ethereum-inflation.png)
 
 _Malgré l'émission linéaire de monnaie, tout comme pour le Bitcoin, le taux de croissance de l'offre tend néanmoins vers zéro au fil du temps._
 
-Les deux principaux choix du modèle ci-dessus sont (1) l'existence et la taille d'un fonds de dotation et (2) l'existence d'une offre linéaire à la croissance permanente, par opposition à une offre plafonnée comme dans le cas du Bitcoin. La justification du fonds de dotation est la suivante. Si le fonds de dotation n'existait pas et que l'émission linéaire était réduite à 0,217 x pour obtenir le même taux d'inflation, la quantité totale d'ETH serait inférieure de 16,5 % et chaque unité aurait donc une valeur supérieure de 19,8 %. Par conséquent, à l'équilibre, 19,8 % d'ETH supplémentaires seraient achetés lors de la vente, de sorte que chaque unité aurait à nouveau exactement la même valeur qu'auparavant. L'organisation disposerait alors de 1,198 x plus de BTC, que l'on peut considérer comme divisés en deux tranches : les BTC initiaux et les 0,198 x supplémentaires. Cette situation est donc _exactement équivalente_ à la dotation, mais avec une différence importante : l'organisation détient uniquement des BTC, et n'est donc pas incitée à soutenir la valeur de l'unité d'ETH.
+Les deux principaux choix du modèle ci-dessus sont (1) l'existence et la taille d'un fonds de dotation et (2) l'existence d'une offre linéaire à la croissance permanente, par opposition à une offre plafonnée comme dans le cas du Bitcoin. La justification du fonds de dotation est la suivante. Si le fonds de dotation n'existait pas et que l'émission linéaire était réduite à 0,217 x pour obtenir le même taux d'inflation, la quantité totale d'ETH serait inférieure de 16,5 % et chaque unité aurait donc une valeur supérieure de 19,8 %. Par conséquent, à l'équilibre, 19,8 % d'ETH supplémentaires seraient achetés lors de la vente, de sorte que chaque unité aurait à nouveau exactement la même valeur qu'auparavant. L'organisation disposerait alors de 1,198 x plus de BTC, que l'on peut considérer comme divisés en deux tranches : les BTC initiaux et les 0,198 x supplémentaires. Par conséquent, cette situation est _exactement équivalente_ à la dotation, mais avec une différence importante : l'organisation détient uniquement des BTC, et n'est donc pas incitée à soutenir la valeur de l'unité d'ether.
 
-Le modèle de croissance linéaire permanente de l'offre réduit le risque de ce que certains considèrent comme une concentration excessive de la richesse en Bitcoins. Il offre aux individus vivant dans les époques actuelles et futures une chance équitable d'acquérir des unités monétaires, tout en maintenant une forte incitation à obtenir et conserver des ETH, car le « taux de croissance de l'offre » en pourcentage tend toujours vers zéro au fil du temps. Nous pensons aussi que, comme des pièces sont toujours perdues au fil du temps en raison de la négligence, de la mort, etc., et que cette perte peut être modélisée comme un pourcentage de l'offre totale par an, l'offre totale de monnaie en circulation finira par se stabiliser à une valeur égale à l'émission annuelle divisée par le taux de perte (par ex., à un taux de perte de 1 %, une fois que l'offre atteint 26 X, 0,26 X sera extrait et 0,26 X sera perdu chaque année, créant ainsi un équilibre).
+Le modèle de croissance linéaire permanente de l'offre réduit le risque de ce que certains considèrent comme une concentration excessive de la richesse en Bitcoins. Il offre aux individus vivant dans les époques actuelles et futures une chance équitable d'acquérir des unités monétaires, tout en maintenant une forte incitation à obtenir et conserver des ETH, car le « taux de croissance de l'offre » en pourcentage tend toujours vers zéro au fil du temps. Nous émettons également l'hypothèse que, comme des pièces sont toujours perdues au fil du temps en raison de la négligence, du décès, etc., et que la perte de pièces peut être modélisée comme un pourcentage de l'offre totale par an, l'offre totale de monnaie en circulation finira par se stabiliser à une valeur égale à l'émission annuelle divisée par le taux de perte (par ex., à un taux de perte de 1 %, une fois que l'offre atteint 26X, alors 0,26X sera miné et 0,26X perdu chaque année, créant un équilibre).
 
-Notez qu'à l'avenir, il est probable qu'Ethereum passe à un modèle de preuve d'enjeu pour la sécurité, réduisant l'exigence d'émission à quelque chose entre zéro et 0,05 X par an. Dans le cas où l'organisation Ethereum perdrait son financement ou disparaîtrait pour toute autre raison, nous laissons ouvert un « contrat social » : n'importe qui a le droit de créer une future version candidate d'Ethereum, à la seule condition que la quantité d'ETH soit au plus égale à `60102216 * (1.198 + 0.26 * n)` où `n` est le nombre d'années après le bloc d'origine. Les créateurs sont libres de vendre au public ou de céder d'une autre manière une partie ou la totalité de la différence entre l'expansion de l'offre induite par la preuve d'enjeu (PoS) et l'expansion maximale autorisée de l'offre pour payer le développement. Les mises à niveau candidates non conformes au contrat social peuvent, à juste titre, faire l'objet d'une fourche vers des versions conformes.
+Notez qu'à l'avenir, il est probable qu'Ethereum passe à un modèle de preuve d'enjeu pour la sécurité, réduisant l'exigence d'émission à quelque chose entre zéro et 0,05 X par an. Dans le cas où l'organisation Ethereum perdrait son financement ou disparaîtrait pour toute autre raison, nous laissons ouvert un « contrat social » : quiconque a le droit de créer une future version candidate d'Ethereum, à la seule condition que la quantité d'ether soit au plus égale à `60102216 * (1.198 + 0.26 * n)` où `n` est le nombre d'années après le bloc de genèse. Les créateurs sont libres de vendre au public ou de céder d'une autre manière une partie ou la totalité de la différence entre l'expansion de l'offre induite par la preuve d'enjeu (PoS) et l'expansion maximale autorisée de l'offre pour payer le développement. Les mises à niveau candidates non conformes au contrat social peuvent, à juste titre, faire l'objet d'une fourche vers des versions conformes.
 
 ### Centralisation du minage {#mining-centralization}
 
 L'algorithme de minage du Bitcoin fonctionne en demandant aux mineurs de calculer SHA256 des millions de fois sur des versions légèrement modifiées de l'en-tête du bloc, jusqu'à ce qu'un nœud finisse par proposer une version dont le hachage est inférieur à la cible (actuellement autour de 2<sup>192</sup>). Cependant, cet algorithme de minage est vulnérable à deux formes de centralisation. Pour commencer, l'écosystème de minage est désormais dominé par les circuits intégrés spécifiques aux applications (ASIC), des puces informatiques conçues pour la tâche spécifique du minage de Bitcoins, et donc des milliers de fois plus efficaces. Cela signifie que l'extraction de Bitcoins n'est plus une activité hautement décentralisée et égalitaire, puisqu'elle nécessite des millions de dollars de capital pour y participer efficacement. Deuxièmement, la plupart des mineurs de Bitcoins n'effectuent pas réellement la validation des blocs au niveau local. Ils s'appuient plutôt sur un groupe de minage centralisé pour fournir les en-têtes de bloc. Ce problème est sans doute le plus grave : à la rédaction de cet article, les trois principaux groupes de minage contrôlent indirectement environ 50 % de la puissance de traitement du réseau Bitcoin, même si cette situation est atténuée par le fait que les mineurs peuvent intégrer d'autres groupes de minage si l'un d'eux ou une coalition tentent une attaque de 51 %.
 
-L'intention actuelle d'Ethereum est d'utiliser un algorithme de minage dans lequel les mineurs sont tenus d'extraire des données aléatoires de l'état, de calculer certaines transactions choisies au hasard dans les N derniers blocs de la blockchain et de renvoyer le hash du résultat. Ceci a deux avantages importants : d'abord, les contrats Ethereum peuvent inclure n'importe quel type de calcul, de sorte qu'un ASIC Ethereum serait essentiellement un ASIC pour le calcul général, c'est-à-dire un meilleur CPU. Deuxièmement, le minage nécessite l'accès à l'ensemble de la blockchain, ce qui oblige les mineurs à la stocker dans son intégralité et d'être au moins capables de vérifier chaque transaction. Ceci supprime le besoin de groupes de minage centralisés. Bien que ceux-ci puissent toujours jouer le rôle légitime d'équilibrer le caractère aléatoire de la distribution des récompenses, cette fonction peut être tout aussi bien remplie par des groupes P2P sans contrôle central.
+L'intention actuelle d'Ethereum est d'utiliser un algorithme de minage dans lequel les mineurs sont tenus d'extraire des données aléatoires de l'état, de calculer certaines transactions choisies au hasard dans les N derniers blocs de la blockchain et de renvoyer le hash du résultat. Ceci a deux avantages importants : Premièrement, les contrats Ethereum peuvent inclure n'importe quel type de calcul, donc un ASIC Ethereum serait essentiellement un ASIC pour le calcul général - c.-à-d. un meilleur CPU. Deuxièmement, le minage nécessite l'accès à l'ensemble de la blockchain, ce qui oblige les mineurs à la stocker dans son intégralité et d'être au moins capables de vérifier chaque transaction. Ceci supprime le besoin de groupes de minage centralisés. Bien que ceux-ci puissent toujours jouer le rôle légitime d'équilibrer le caractère aléatoire de la distribution des récompenses, cette fonction peut être tout aussi bien remplie par des groupes P2P sans contrôle central.
 
 Ce modèle n'est pas testé, et des difficultés peuvent survenir en cours de route si l'on évite certaines optimisations astucieuses quand l'exécution du contrat est utilisée comme algorithme de minage. Toutefois, cet algorithme possède une fonctionnalité particulièrement intéressante qui permet à n'importe qui d'« empoisonner le puits » en introduisant dans la blockchain un grand nombre de contrats spécialement conçus pour contrecarrer certains ASIC. Des incitations économiques existent pour que les fabricants d'ASIC utilisent cette astuce pour s'attaquer mutuellement. La solution que nous développons est donc, en définitive, une solution humaine économique adaptative plutôt qu'une solution purement technique.
 
@@ -468,9 +472,9 @@ Ce modèle n'est pas testé, et des difficultés peuvent survenir en cours de ro
 
 La question de l'évolutivité est l'une des préoccupations les plus courantes concernant Ethereum. Comme Bitcoin, Ethereum présente le défaut que chaque transaction doit être traitée par chaque nœud du réseau. Pour Bitcoin, la taille actuelle de la blockchain est d'environ 15 Go et elle augmente d'environ 1 Mo par heure. Si le réseau Bitcoin devait traiter les 2 000 transactions par seconde de Visa, il croîtrait de 1 Mo toutes les trois secondes (1 Go par heure, 8 To par an). Ethereum est susceptible de subir un modèle de croissance similaire, aggravé par le fait qu'il y aura de nombreuses applications sur sa blockchain, et pas seulement une monnaie comme c'est le cas avec Bitcoin, mais amélioré par le fait que les nœuds complets Ethereum n'ont besoin de stocker que l'état de la blockchain et non son historique complet.
 
-Avec une blockchain d'une telle taille, le risque de centralisation constitue un problème. Par exemple, si la taille de la blockchain atteint 100 To, le scénario probable serait que seul un très petit nombre de grandes entreprises exécuterait des nœuds complets, tous les utilisateurs réguliers utilisant des nœuds légers de vérification simplifiée de paiement (SPV). Dans ce cas, tous les nœuds complets pourraient se regrouper et se mettre d'accord pour tricher d'une manière profitable (p. ex., en modifiant la récompense du bloc, ou en s'offrant des BTC). Les nœuds légers ne pourraient pas détecter cela tout de suite. Bien sûr, il existerait probablement au moins un nœud complet honnête, et après quelques heures, des informations sur la fraude seraient diffusées via des canaux comme Reddit. Mais à ce moment-là, il serait déjà trop tard : il incomberait aux utilisateurs ordinaires d'organiser une action pour mettre sur liste noire les blocs donnés. Cela poserait un problème de coordination massif et serait probablement infaisable à une échelle similaire à celle d'une attaque à 51 % réussie. Dans le cas de Bitcoin, c'est actuellement un problème, mais il existe une modification de la blockchain [suggérée par Peter Todd](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/) qui atténuera ce problème.
+Avec une blockchain d'une telle taille, le risque de centralisation constitue un problème. Par exemple, si la taille de la blockchain atteint 100 To, le scénario probable serait que seul un très petit nombre de grandes entreprises exécuterait des nœuds complets, tous les utilisateurs réguliers utilisant des nœuds légers de vérification simplifiée de paiement (SPV). Dans une telle situation, il y a le risque que les nœuds complets se regroupent et s'accordent tous pour tricher d'une manière rentable (par ex., changer la récompense de bloc, s'attribuer des BTC). Les nœuds légers ne pourraient pas détecter cela tout de suite. Bien sûr, il existerait probablement au moins un nœud complet honnête, et après quelques heures, des informations sur la fraude seraient diffusées via des canaux comme Reddit. Mais à ce moment-là, il serait déjà trop tard : il incomberait aux utilisateurs ordinaires d'organiser une action pour mettre sur liste noire les blocs donnés. Cela poserait un problème de coordination massif et serait probablement infaisable à une échelle similaire à celle d'une attaque à 51 % réussie. Dans le cas de Bitcoin, c'est actuellement un problème, mais il existe une modification de la blockchain [suggérée par Peter Todd](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/) qui atténuera ce problème.
 
-À court terme, Ethereum utilisera deux stratégies supplémentaires pour faire face à ce problème. Tout d'abord, en raison des algorithmes de minage basés sur la blockchain, chaque mineur sera obligé d'être un nœud complet, créant ainsi une limite inférieure du nombre de nœuds complets. Ensuite, nous inclurons surtout une racine d'arbre d'état intermédiaire dans la blockchain après le traitement de chaque transaction. Même si la validation des blocs est centralisée, tant qu'il existe un nœud vérificateur honnête, le problème de centralisation peut être contourné via un protocole de vérification. Quand un mineur publie un bloc non valide, c'est qu'il doit être soit mal formaté, ou que l'état `S[n]` est incorrect. Puisque l'on sait que `S[0]` est correct, il doit exister un premier état `S[i]` incorrect où `S[i-1]` est correct. Le nœud vérificateur fournirait l'index `i`, ainsi qu'une « preuve de non validité » consistant en un sous-ensemble de nœuds de l'arbre Patricia devant traiter `APPLY(S[i-1],TX[i]) -> S[i]`. Les nœuds pourraient utiliser ces nœuds Patricia pour exécuter cette partie du calcul, et voir que le `S[i]` généré ne correspond pas au `S[i]` fourni.
+À court terme, Ethereum utilisera deux stratégies supplémentaires pour faire face à ce problème. Tout d'abord, en raison des algorithmes de minage basés sur la blockchain, chaque mineur sera obligé d'être un nœud complet, créant ainsi une limite inférieure du nombre de nœuds complets. Ensuite, nous inclurons surtout une racine d'arbre d'état intermédiaire dans la blockchain après le traitement de chaque transaction. Même si la validation des blocs est centralisée, tant qu'il existe un nœud vérificateur honnête, le problème de centralisation peut être contourné via un protocole de vérification. Si un mineur publie un bloc invalide, ce bloc doit être soit mal formaté, soit l'état `S[n]` est incorrect. Puisque `S[0]` est connu pour être correct, il doit y avoir un premier état `S[i]` qui est incorrect alors que `S[i-1]` est correct. Le nœud de vérification fournirait l'index `i`, ainsi qu'une « preuve d'invalidité » consistant en un sous-ensemble de nœuds de l'arbre Patricia nécessaires pour traiter `APPLY(S[i-1],TX[i]) -> S[i]`. Les nœuds pourraient utiliser ces nœuds pour exécuter cette partie du calcul, et voir que le `S[i]` généré ne correspond pas au `S[i]` fourni.
 
 Une autre attaque, plus sophistiquée, impliquerait que des mineurs malveillants publient des blocs incomplets, de sorte que l'information complète n'existe même pas pour déterminer si les blocs sont valides ou non. La solution à ce problème est un protocole de défi-réponse : les nœuds vérificateurs émettent des « défis » sous la forme d'indices de transaction cible, et à la réception d'un nœud, un nœud léger traite le bloc comme non fiable jusqu'à ce qu'un autre nœud, que ce soit le mineur ou un autre vérificateur, fournisse un sous-ensemble de nœuds Patricia comme preuve de validité.
 
@@ -480,7 +484,7 @@ Le protocole Ethereum a été initialement conçu comme une version améliorée
 
 Le concept d'une fonction de transition d'état arbitraire telle qu'implémentée par le protocole Ethereum offre une plateforme au potentiel unique. Au lieu d'être un protocole fermé, à usage unique et destiné à une gamme spécifique d'applications dans les domaines du stockage de données, des jeux d'argent ou de la finance, Ethereum est ouvert par conception. Nous pensons qu'il est parfaitement adapté pour servir de couche de base à un très grand nombre de protocoles financiers et non financiers dans les années à venir.
 
-## Notes et complément d'information {#notes-and-further-reading}
+## Notes et lectures complémentaires {#notes-and-further-reading}
 
 ### Notes {#notes}
 
@@ -488,30 +492,30 @@ Le concept d'une fonction de transition d'état arbitraire telle qu'implémenté
 2. Techniquement, la médiane des 11 blocs précédents.
 3. En interne, 2 et « CHARLIE » sont des nombres<sup>[fn3](#notes)</sup>, le dernier étant en représentation gros-boutiste une base 256. Les nombres peuvent être au minimum de 0 et au maximum de 2<sup>256</sup>-1.
 
-### Complément d'information {#further-reading}
+### En savoir plus {#further-reading}
 
-1. [Valeur intrinsèque](http://bitcoinmagazine.com/8640/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it/)
+1. [Valeur intrinsèque](https://bitcoinmagazine.com/culture/an-exploration-of-intrinsic-value-what-it-is-why-bitcoin-doesnt-have-it-and-why-bitcoin-does-have-it)
 2. [Propriété intelligente](https://en.bitcoin.it/wiki/Smart_Property)
 3. [Contrats intelligents](https://en.bitcoin.it/wiki/Contracts)
 4. [B-money](http://www.weidai.com/bmoney.txt)
 5. [Preuves de travail réutilisables](https://nakamotoinstitute.org/finney/rpow/)
-6. [Titres de propriété sécurisés avec preuve de possession](https://nakamotoinstitute.org/secure-property-titles/)
-7. [Livre blanc Bitcoin](http://bitcoin.org/bitcoin.pdf)
+6. [Titres de propriété sécurisés avec autorité du propriétaire](https://nakamotoinstitute.org/library/secure-property-titles/)
+7. [Livre blanc de Bitcoin](http://bitcoin.org/bitcoin.pdf)
 8. [Namecoin](https://namecoin.org/)
 9. [Triangle de Zooko](https://wikipedia.org/wiki/Zooko's_triangle)
-10. [Livre blanc sur les pièces de couleur](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)
-11. [Livre blanc Mastercoin](https://github.com/mastercoin-MSC/spec)
-12. [Organisations autonomes décentralisées, Bitcoin Magazine](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/)
+10. [Livre blanc des pièces colorées](https://docs.google.com/a/buterin.com/document/d/1AnkP_cVZTCMLIzw4DvsW6M8Q2JC0lIzrTLuoWu2z1BE/edit)
+11. [Livre blanc de Mastercoin](https://github.com/mastercoin-MSC/spec)
+12. [Sociétés autonomes décentralisées, Bitcoin Magazine](http://bitcoinmagazine.com/7050/bootstrapping-a-decentralized-autonomous-corporation-part-i/)
 13. [Vérification de paiement simplifiée](https://en.bitcoin.it/wiki/Scalability#Simplified_payment_verification)
 14. [Arbres de Merkle](https://wikipedia.org/wiki/Merkle_tree)
 15. [Arbres Patricia](https://wikipedia.org/wiki/Patricia_tree)
 16. [GHOST](https://eprint.iacr.org/2013/881.pdf)
 17. [StorJ et agents autonomes, Jeff Garzik](http://garzikrants.blogspot.ca/2013/01/storj-and-bitcoin-autonomous-agents.html)
-18. [Mike Hearn, Smart Property, Turing Festival](https://www.youtube.com/watch?v=MVyv4t0OKe4)
-19. [RLP Ethereum](https://web.archive.org/web/20250427212320/https://ethereum.org/whitepaper//%5BEnglish%5D-RLP)
-20. [Arbres de Merkle dans Ethereum](https://web.archive.org/web/20250427212320/https://ethereum.org/whitepaper//%5BEnglish%5D-Patricia-Tree)
-21. [Peter Todd à propos des arbres de Merkle additifs](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/)
+18. [Mike Hearn sur la propriété intelligente au Turing Festival](https://www.youtube.com/watch?v=MVyv4t0OKe4)
+19. [RLP d'Ethereum](/developers/docs/data-structures-and-encoding/rlp/)
+20. [Arbres de Merkle Patricia d'Ethereum](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/)
+21. [Peter Todd sur les arbres de somme de Merkle](https://web.archive.org/web/20140623061815/http://sourceforge.net/p/bitcoin/mailman/message/31709140/)
 
-_Pour en savoir plus sur l'historique du livre blanc, consultez [ce wiki](https://web.archive.org/web/20250427212319/https://ethereum.org/whitepaper/)._
+_Pour l'historique du livre blanc, voir [ce wiki](https://web.archive.org/web/20250427212319/https://ethereum.org/whitepaper/)._
 
-_Comme de nombreux projets open source communautaires, Ethereum a évolué depuis sa création. Pour plus d'infos sur les derniers développements d'Ethereum et la façon dont les modifications du protocole sont mises en œuvre, nous vous recommandons de lire [ce guide](/learn/)._
+_Comme de nombreux projets open source communautaires, Ethereum a évolué depuis sa création. Pour en savoir plus sur les derniers développements d'Ethereum et sur la manière dont les modifications du protocole sont apportées, nous vous recommandons [ce guide](/learn/)._
diff --git a/public/content/translations/fr/wrapped-eth/index.md b/public/content/translations/fr/wrapped-eth/index.md
new file mode 100644
index 00000000000..7d9c08d2b9e
--- /dev/null
+++ b/public/content/translations/fr/wrapped-eth/index.md
@@ -0,0 +1,66 @@
+---
+title: Qu'est-ce que l'Ether symbolique (WETH)
+description: "Une introduction à l'Ether symbolique (WETH) — un système compatible ERC20 pour l'ether (ETH)."
+lang: fr
+---
+
+# Ether symbolique (WETH) {#intro-to-weth}
+
+<Alert variant="update">
+<Emoji text="🎁" />
+<div>Connectez votre portefeuille pour envelopper ou déballer des ETH sur n'importe quelle chaîne sur [WrapETH.com](https://www.wrapeth.com/)</div>
+</Alert>
+
+L'Ether (ETH) est la monnaie principale d'Ethereum. Il est utilisé à plusieurs fins, comme la mise en jeu, en tant que monnaie, et pour payer les frais de gaz liés aux calculs. **Le WETH est en réalité une version améliorée de l'ETH dotée de fonctionnalités supplémentaires requises par de nombreuses applications et [jetons ERC-20](/glossary/#erc-20)**, qui sont d'autres types d'actifs numériques sur Ethereum. Pour fonctionner avec ces jetons, l'ETH doit suivre les mêmes règles qu'eux, connues sous le nom de standard ERC-20.
+
+Pour combler cet écart, l'Ether symbolique (WETH) a été créé. **L'Ether symbolique est un contrat intelligent qui vous permet de déposer n'importe quel montant d'ETH dans le contrat et de recevoir le même montant en WETH frappés**, conformément à la norme de jeton ERC-20. Le WETH est une représentation de l'ETH qui vous permet d'interagir avec lui en tant que jeton ERC-20, et non comme l'actif natif ETH. Vous aurez toujours besoin d'ETH natif pour payer les frais de gaz, alors assurez-vous d'en conserver une partie lors du dépôt.
+
+Vous pouvez échanger le WETH contre de l'ETH en utilisant le contrat intelligent WETH. Vous pouvez échanger n'importe quel montant de WETH via le contrat intelligent WETH, et vous recevrez le même montant en ETH. Le WETH déposé est ensuite brûlé et retiré de l'offre en circulation de WETH.
+
+**Environ ~3% de l'offre d'ETH en circulation est verrouillée dans le contrat de WETH**, ce qui en fait l'un des [contrats intelligents](/glossary/#smart-contract) les plus utilisés. Le WETH est particulièrement important pour les utilisateurs interagissant avec des applications relevant de la finance décentralisée (DeFi).
+
+## Pourquoi devons-nous encapsuler l'ETH en tant que jeton ERC-20 ? {#why-do-we-need-to-wrap-eth}
+
+[ERC-20](/developers/docs/standards/tokens/erc-20/) définit une interface standard pour les jetons transférables, permettant à quiconque de créer des jetons qui interagissent parfaitement avec les applications et les autres jetons utilisant ce standard dans l'écosystème Ethereum. Puisque **l'ETH est antérieur à la norme ERC-20**, l'ETH ne respecte pas cette spécification. Cela signifie que **vous ne pouvez pas facilement** échanger des ETH contre d'autres jetons ERC-20 ou **utiliser des ETH dans des applications utilisant le standard ERC-20**. Encapsuler des ETH vous donne l'opportunité de :
+
+- **Échanger des ETH contre des jetons ERC-20** : Vous ne pouvez pas échanger des ETH directement contre d'autres jetons ERC-20. Le WETH est une représentation de l'ether qui est conforme au standard ERC-20 des jetons fongibles et peut être échangé contre d'autres jetons ERC-20.
+
+- **Utiliser des ETH dans les dapps** : Étant donné que les ETH ne sont pas compatibles avec le standard ERC-20, les développeurs doivent créer des interfaces distinctes (une pour les ETH et une autre pour les jetons ERC-20) dans les dapps. Encapsuler des ETH supprime cet obstacle et permet aux développeurs de gérer les ETH et d'autres jetons au sein de la même dapp. De nombreuses applications de finance décentralisée utilisent cette norme et créent des marchés pour échanger ces jetons.
+
+## Ether symbolique (WETH) contre ether (ETH) : quelle est la différence ? {#weth-vs-eth-differences}
+
+|           | **Ether (ETH)**                                                                                                                                                                                                       | **Ether symbolique (WETH)**                                                                                                                                                                                                                                                                                                                    |
+| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Offre     | L'offre d'ETH est gérée par le protocole Ethereum. L'[émission](/roadmap/merge/issuance) d'ETH est gérée par les validateurs d'Ethereum lors du traitement des transactions et de la création des blocs. | Le WETH est un jeton ERC-20 dont l'approvisionnement est géré par un contrat intelligent. De nouvelles unités de WETH sont émises par le contrat intelligent après qu'il a reçu des dépôts d'ETH de la part des utilisateurs, ou des unités de WETH sont brûlées lorsqu'un utilisateur souhaite échanger du WETH contre de l'ETH. |
+| Propriété | La propriété est gérée par le protocole Ethereum via le solde de votre compte.                                                                                                                                           | La propriété du WETH est gérée par le contrat intelligent du jeton WETH, sécurisé par le protocole Ethereum.                                                                                                                                                                                                                                      |
+| Gaz       | L'Ether (ETH) est l'unité de paiement acceptée pour le calcul sur le réseau Ethereum. Les frais de gaz sont libellés en gwei (une unité d'ether).                  | Payer les frais de gaz avec des jetons WETH n'est pas pris en charge de manière native.                                                                                                                                                                                                                                                           |
+
+## Foire aux questions {#faq}
+
+<ExpandableCard title="Paye-t-on pour encapsuler/désencapsuler de l'ETH ?" eventCategory="/wrapped-eth" eventName="clicked Do you pay to wrap/unwrap ETH?">
+
+Vous payez des frais de gas pour encapsuler ou désencapsuler des ETH en utilisant le smart contract WETH.
+</ExpandableCard>
+
+<ExpandableCard title="Le WETH est-il sûr ?" eventCategory="/wrapped-eth" eventName="clicked Is WETH safe?">
+
+Le WETH est généralement considéré comme sûr car il est basé sur un contrat intelligent simple et éprouvé. Le contrat intelligent WETH a également été formellement vérifié, ce qui constitue la norme de sécurité la plus élevée pour les contrats intelligents sur Ethereum.
+</ExpandableCard>
+
+<ExpandableCard title="Pourquoi y a-t-il différents tokens WETH ?" eventCategory="/wrapped-eth" eventName="clicked Why am I seeing different WETH tokens?">
+
+Outre la [version canonique de WETH](https://etherscan.io/token/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2) décrite sur cette page, il existe d'autres variantes en circulation. Il peut s'agir de tokens personnalisés créés par des développeurs d'applications ou de versions émises sur d'autres blockchains, qui peuvent se comporter différemment ou avoir des propriétés de sécurité différentes. **Vérifiez toujours les informations sur le jeton pour savoir avec quelle implémentation de WETH vous interagissez.**
+</ExpandableCard>
+
+<ExpandableCard title="Quels sont les contrats WETH sur les autres réseaux ?" eventCategory="/wrapped-eth" eventName="clicked What are the WETH contracts on other networks?">
+
+- [Réseau principal d'Ethereum](https://etherscan.io/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+- [Arbitrum](https://arbiscan.io/token/0x82af49447d8a07e3bd95bd0d56f35241523fbab1)
+- [Optimism](https://optimistic.etherscan.io/token/0x4200000000000000000000000000000000000006)
+</ExpandableCard>
+
+## En savoir plus {#further-reading}
+
+- [C'est quoi le WETH?](https://weth.tkn.eth.limo/)
+- [Informations sur le jeton WETH sur Blockscout](https://eth.blockscout.com/token/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+- [Vérification formelle du WETH](https://zellic.io/blog/formal-verification-weth)
diff --git a/public/content/translations/fr/zero-knowledge-proofs/index.md b/public/content/translations/fr/zero-knowledge-proofs/index.md
index d0085e0e0c3..a87b499d51a 100644
--- a/public/content/translations/fr/zero-knowledge-proofs/index.md
+++ b/public/content/translations/fr/zero-knowledge-proofs/index.md
@@ -1,6 +1,6 @@
 ---
-title: La preuve à divulgation nulle de connaissance
-description: Une introduction non technique aux preuves à divulgation nulle pour les débutants.
+title: "Preuves à divulgation nulle de connaissance"
+description: "Une introduction non technique aux preuves à divulgation nulle de connaissance pour les débutants."
 lang: fr
 ---
 
@@ -8,9 +8,9 @@ lang: fr
 
 Une preuve à divulgation nulle est un moyen de prouver la validité d'une information sans révéler l'information elle-même. Le « prouveur » est la partie qui tente de prouver une affirmation, tandis que le « vérificateur » est responsable de la validation de l'affirmation.
 
-Les preuves à divulgation nulle sont apparues pour la première fois dans un article publié en 1985, "[La complexité de connaissance des systèmes interactifs de preuve](http://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Proof%20Systems/The_Knowledge_Complexity_Of_Interactive_Proof_Systems.pdf)" qui fournit une définition des preuves à divulgation nulle largement utilisée aujourd'hui :
+Les preuves à divulgation nulle de connaissance sont apparues pour la première fois dans un article de 1985, « [The knowledge complexity of interactive proof systems](http://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Proof%20Systems/The_Knowledge_Complexity_Of_Interactive_Proof_Systems.pdf) », qui fournit une définition des preuves à divulgation nulle de connaissance largement utilisée aujourd'hui :
 
-> Un protocole à divulgation nulle est une méthode par laquelle une partie (le démonstrateur) **peut prouver** à une autre partie (le vérificateur)** qu'une chose est vraie, sans révéler aucune autre information** que la véracité de cette déclaration spécifique.
+> Un protocole à divulgation nulle de connaissance est une méthode par laquelle une partie (le prouveur) **peut prouver** à une autre partie (le vérificateur) **que quelque chose est vrai, sans révéler aucune information** autre que le fait que cette déclaration spécifique est vraie.
 
 Au fil des années, les preuves à divulgation nulle se sont améliorées et sont maintenant utilisées dans plusieurs applications concrètes.
 
@@ -22,7 +22,7 @@ Les preuves à divulgation nulle furent une avancée importante dans l'histoire
 
 Mais cette approche implique un certain nombre de problèmes, notamment le manque de respect de la vie privée. Les informations personnelles identifiables (PII) partagées avec des services tiers sont stockées dans des bases de données centrales, vulnérables aux piratages. Le vol d’identité devenant un problème critique, des voix s'élèvent pour réclamer davantage de moyens de protection de la vie privée dans le partage d'informations sensibles.
 
-Les preuves à divulgation nulle de connaissance résolvent ce problème en **éliminant la nécessité de révéler des informations pour prouver la validité d'une réclamation**. Le protocole à divulgation nulle de connaissance utilise une déclaration (appelée « témoin ») comme base de génération d'une preuve succincte de sa validité. Cette preuve donne de fortes garanties qu'une déclaration est vraie sans révéler les informations utilisées pour la créer.
+Les preuves à divulgation nulle de connaissance résolvent ce problème en **éliminant le besoin de révéler des informations pour prouver la validité des affirmations**. Le protocole à divulgation nulle de connaissance utilise une déclaration (appelée « témoin ») comme base de génération d'une preuve succincte de sa validité. Cette preuve donne de fortes garanties qu'une déclaration est vraie sans révéler les informations utilisées pour la créer.
 
 Pour en revenir à l'exemple précédent, la seule chose dont vous avez besoin pour prouver votre citoyenneté est une preuve à divulgation nulle de connaissance. Le vérificateur doit seulement vérifier si certaines propriétés de la preuve sont vraies pour être convaincu que la déclaration sous-jacente est également vraie.
 
@@ -32,19 +32,42 @@ Pour en revenir à l'exemple précédent, la seule chose dont vous avez besoin p
 
 Les paiements par carte de crédit sont souvent visibles pour plusieurs parties, y compris le fournisseur de paiements, les banques et les autres parties intéressées (par exemple, les autorités gouvernementales). Bien que la surveillance financière ait des avantages à identifier les activités illégales, elle sape également la vie privée des citoyens ordinaires.
 
-Les cryptomonnaies étaient destinées à fournir aux utilisateurs un moyen de réaliser des transactions privées, entre pairs. Mais la plupart des transactions de cryptomonnaies sont ouvertement visibles sur les blockchains publics. Les identités des utilisateurs sont souvent des pseudonymes et se trouvent volontairement liées à des identités du monde réel (par exemple, en incluant des adresses ETH sur des profils Twitter ou GitHub), ou peuvent être associées à des identités du monde réel en utilisant une analyse de base de données à la fois en chaîne et hors chaîne.
+Les cryptomonnaies étaient destinées à fournir aux utilisateurs un moyen de réaliser des transactions privées, entre pairs. Mais la plupart des transactions de cryptomonnaies sont ouvertement visibles sur les blockchains publics. Les identités des utilisateurs sont souvent des pseudonymes et soit volontairement liées à des identités du monde réel (par ex., en incluant des adresses ETH sur des profils Twitter ou GitHub), soit peuvent être associées à des identités du monde réel en utilisant une analyse de données de base en chaîne et hors chaîne.
 
 Il existe des "crypto-monnaies anonymes" spécialement conçues pour des transactions complètement anonymes. Les blockchains axées sur la confidentialité, telles que Zcash et Monero, protègent les détails des transactions, y compris les adresses de l'expéditeur/du destinataire, le type d'actif, la quantité et la chronologie de la transaction.
 
-En injectant dans le protocole une technologie à divulgation nulle de connaissance, les réseaux [blockchain](/glossary/#blockchain) axés sur la confidentialité permettent aux [nœuds](/glossary/#node) de valider les transactions sans avoir besoin d'accéder aux données de transaction.
+En intégrant la technologie à divulgation nulle de connaissance dans le protocole, les réseaux [blockchain](/glossary/#blockchain) axés sur la confidentialité permettent aux [nœuds](/glossary/#node) de valider les transactions sans avoir besoin d'accéder aux données des transactions. [EIP-7503](https://eips.ethereum.org/EIPS/eip-7503) est un exemple de conception proposée qui permettra des transferts de valeur privés natifs sur la blockchain Ethereum. De telles propositions sont toutefois difficiles à mettre en œuvre en raison d’un mélange de préoccupations liées à la sécurité, à la réglementation et à l’expérience utilisateur (UX).
 
-**Les preuves à divulgation nulle de connaissance sont également utilisées pour anonymiser les transactions sur les blockchains publiques**. C'est le cas de Tornado Cash, un service décentralisé et non-custodial (qui n'a pas le contrôle direct sur les fonds ou les actifs de l'utilisateur) qui permet aux utilisateurs d'effectuer des transactions privées sur Ethereum. Tornado Cash utilise des preuves à divulgation nulle pour masquer les détails de la transaction et garantir la confidentialité financière. Malheureusement, étant donné qu'il s'agit d'outils de protection de la vie privée, ils sont associés à des activités illicites. Pour surmonter cela, la confidentialité doit devenir la valeur par défaut sur les blockchains publiques.
+**Les preuves à divulgation nulle de connaissance sont également utilisées pour anonymiser les transactions sur les blockchains publiques**. C'est le cas de Tornado Cash, un service décentralisé et non-custodial (qui n'a pas le contrôle direct sur les fonds ou les actifs de l'utilisateur) qui permet aux utilisateurs d'effectuer des transactions privées sur Ethereum. Tornado Cash utilise des preuves à divulgation nulle pour masquer les détails de la transaction et garantir la confidentialité financière. Malheureusement, étant donné qu'il s'agit d'outils de protection de la vie privée, ils sont associés à des activités illicites. Pour surmonter cela, la confidentialité doit devenir la valeur par défaut sur les blockchains publiques. En savoir plus sur [la confidentialité sur Ethereum](/privacy/).
 
 ### Protection de l'identité {#identity-protection}
 
 Les systèmes actuels de gestion de l'identité mettent en péril les renseignements personnels. Les preuves à divulgation nulle peuvent aider les individus à valider leur identité tout en protégeant leurs données personnelles.
 
-Les preuves à divulgation nulle sont particulièrement utiles dans un contexte de [décentralisation de l'identité](/decentralized-identity/). La décentralisation de l'identité (également appelée "'identité auto-souveraine") donne à l'individu la possibilité de contrôler l'accès à ses données personnelles. Prouver votre citoyenneté sans révéler les détails de vos documents d'identité est un bon exemple de la manière dont la technologie de la preuve à divulgation nulle de connaissance permet une décentralisation de l'identité.
+Les preuves à divulgation nulle de connaissance sont particulièrement utiles dans le contexte de l'[identité décentralisée](/decentralized-identity/). La décentralisation de l'identité (également appelée "'identité auto-souveraine") donne à l'individu la possibilité de contrôler l'accès à ses données personnelles. Prouver votre citoyenneté sans révéler les détails de vos documents d'identité est un bon exemple de la manière dont la technologie de la preuve à divulgation nulle de connaissance permet une décentralisation de l'identité.
+
+<Alert variant="info">
+  <AlertEmoji text="💡" />
+  <AlertContent>
+    <AlertTitle className="mb-2">
+      ZKP + Identité en action : l'Identité Numérique Nationale (NDI) du Bhoutan sur Ethereum
+    </AlertTitle>
+    <AlertDescription>
+      <p>
+        Un exemple concret de l'utilisation de ZKP pour les systèmes de gestion de l'identité est le système d'Identité Numérique Nationale (NDI) du Royaume du Bhoutan, construit sur Ethereum. Le NDI du Bhoutan utilise les ZKP pour permettre aux citoyens de prouver cryptographiquement des faits sur eux-mêmes, comme « Je suis un citoyen » ou « J'ai plus de 18 ans », sans révéler les données personnelles sensibles de leur pièce d'identité.
+      </p>
+      <p>
+        En savoir plus sur le NDI du Bhoutan dans l'<a href="/decentralized-identity/#national-and-government-id">étude de cas sur l'Identité décentralisée</a>.
+      </p>
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+### Proof of Humanity {#proof-of-humanity}
+
+L'un des exemples les plus répandus de preuves à divulgation nulle de connaissance en action aujourd'hui est le [protocole World ID](https://world.org/blog/world/world-id-faqs), qui peut être considéré comme « un passeport numérique mondial pour l'ère de l'IA ». Il permet aux personnes de prouver qu’elles sont des individus uniques sans révéler d’informations personnelles. Cela est rendu possible grâce à un dispositif appelé l’Orb, qui scanne l’iris d’une personne et génère un code d’iris. Le code d’iris est vérifié afin de confirmer que la personne est un être humain biologiquement unique. Après vérification, un engagement d’identité généré sur l’appareil de l’utilisateur (et non lié ni dérivé des données biométriques) est ajouté à une liste sécurisée sur la blockchain. Ensuite, chaque fois que l’utilisateur souhaite prouver qu’il est un humain vérifié — que ce soit pour se connecter, voter ou effectuer d’autres actions — il peut générer une preuve à divulgation nulle de connaissance confirmant son appartenance à la liste. La beauté de l’utilisation d’une preuve à divulgation nulle de connaissance réside dans le fait qu’une seule affirmation est révélée : cette personne est unique. Tout le reste reste privé.
+
+World ID repose sur le [protocole Semaphore](https://docs.semaphore.pse.dev/) développé par l'[équipe PSE](https://pse.dev/) de la Ethereum Foundation. Semaphore est conçu pour être un moyen léger mais puissant de générer et de vérifier des preuves à divulgation nulle de connaissance. Il permet aux utilisateurs de prouver qu’ils font partie d’un groupe (dans ce cas, des humains vérifiés) sans révéler quel membre du groupe ils sont. Semaphore est également très flexible, permettant de créer des groupes selon une large gamme de critères comme la vérification d’identité, la participation à des événements ou la possession de justificatifs.
 
 ### Authentification {#authentication}
 
@@ -56,11 +79,11 @@ Toutefois, les preuves à divulgation nulle permettent de simplifier l'authentif
 
 Le calcul vérifiable est une autre application de la technologie à divulgation nulle destinée à améliorer les conceptions de la blockchain. Le calcul vérifiable nous permet de sous-traiter le calcul à une autre entité tout en maintenant des résultats vérifiables. L'entité soumet le résultat ainsi qu'une preuve attestant que le programme a été exécuté correctement.
 
-Le calcul vérifiable est **essentiel pour améliorer la vitesse de traitement sur les blockchains** sans réduire la sécurité. Pour comprendre cela, il faut connaître les différences entre les différentes solutions proposées pour l'évolutivité d'Ethereum.
+Le calcul vérifiable est **essentiel pour améliorer les vitesses de traitement sur les blockchains** sans réduire la sécurité. Pour comprendre cela, il faut connaître les différences entre les différentes solutions proposées pour l'évolutivité d'Ethereum.
 
-[Les solutions d'évolutivité en chaîne](/developers/docs/scaling/#on-chain-scaling), telles que la fragmentation, nécessitent une modification extensive de la couche de base de la blockchain. Cependant, cette approche est très complexe et les erreurs de mise en œuvre peuvent compromettre le modèle de sécurité d'Ethereum.
+Les [solutions d'évolutivité en chaîne](/developers/docs/scaling/#onchain-scaling), telles que le sharding, nécessitent une modification importante de la couche de base de la blockchain. Cependant, cette approche est très complexe et les erreurs de mise en œuvre peuvent compromettre le modèle de sécurité d'Ethereum.
 
-[Les solutions d'évolutivité hors chaîne](/developers/docs/scaling/#off-chain-scaling) ne nécessitent pas de refonte du protocole Ethereum de base. Elles s'appuient plutôt sur un modèle de calcul externalisé afin d'améliorer le débit sur la couche de base d'Ethereum.
+Les [solutions d'évolutivité hors chaîne](/developers/docs/scaling/#offchain-scaling) ne nécessitent pas de reconcevoir le protocole de base d'Ethereum. Elles s'appuient plutôt sur un modèle de calcul externalisé afin d'améliorer le débit sur la couche de base d'Ethereum.
 
 Voici comment les choses fonctionnent dans la pratique :
 
@@ -72,43 +95,43 @@ Cela a pour avantage d'exonérer Ethereum de toute exécution des tâches. Ether
 
 La chaîne a besoin d'un moyen de valider les transactions hors chaîne sans les ré-exécuter, sans quoi la valeur de l'exécution hors chaîne serait perdue.
 
-C'est ici que le calcul vérifiable entre en jeu. En effet, lorsqu'un nœud exécute une transaction en dehors d'Ethereum, il soumet une preuve à divulgation nulle pour prouver la justesse de l'exécution hors chaîne. Cette preuve (appelée [preuve de validation](/glossary/#validity-proof)) garantit la validité d'une transaction, permettant ainsi à Ethereum d'appliquer le résultat obtenu à son état, cela sans aucune contestation possible.
+C'est ici que le calcul vérifiable entre en jeu. Lorsqu'un nœud exécute une transaction en dehors d'Ethereum, il soumet une preuve à divulgation nulle pour prouver la justesse de l'exécution hors chaîne. Cette preuve (appelée [preuve de validité](/glossary/#validity-proof)) garantit qu'une transaction est valide, permettant à Ethereum d'appliquer le résultat à son état, sans attendre que quelqu'un la conteste.
 
-[Les ZK-Rollups](/developers/docs/scaling/zk-rollups) et [ les validiums](/developers/docs/scaling/validium/) sont deux solutions d'évolutivité hors chaîne qui utilisent des preuves de validité pour fournir une évolutivité sécurisée. Ces protocoles exécutent des milliers de transactions hors chaîne et soumettent des preuves pour vérification sur Ethereum. Ces résultats peuvent être appliqués immédiatement une fois la preuve vérifiée, permettant ainsi à Ethereum de traiter plus de transactions, sans augmenter le calcul sur la couche de base.
+Les [rollups ZK](/developers/docs/scaling/zk-rollups) et les [validiums](/developers/docs/scaling/validium/) sont deux solutions d'évolutivité hors chaîne qui utilisent des preuves de validité pour offrir une évolutivité sécurisée. Ces protocoles exécutent des milliers de transactions hors chaîne et soumettent des preuves pour vérification sur Ethereum. Ces résultats peuvent être appliqués immédiatement une fois la preuve vérifiée, permettant ainsi à Ethereum de traiter plus de transactions, sans augmenter le calcul sur la couche de base.
 
-### Réduire la corruption et la collusion lors du vote en chaîne {#secure-blockchain-voting}
+### Réduire la corruption et la collusion dans le vote en chaîne {#secure-blockchain-voting}
 
-Les systèmes de vote de la blockchain ont de nombreuses caractéristiques favorables : ils sont entièrement auditables, blindés contre les attaques, résistants à la censure et exempts de contraintes géographiques. Mais même les systèmes de vote en chaîne ne sont pas immunisés contre le problème de la **collusion**.
+Les systèmes de vote de la blockchain ont de nombreuses caractéristiques favorables : ils sont entièrement auditables, blindés contre les attaques, résistants à la censure et exempts de contraintes géographiques. Mais même les systèmes de vote en chaîne ne sont pas à l'abri du problème de la **collusion**.
 
-Défini comme "entente visant à limiter la libre concurrence par le trucage, la fraude, et en trompant les autres", la collusion peut prendre la forme d'un individu malveillant influant sur le vote d'autrui en lui offrant des pots-de-vin. Par exemple Alice pourrait recevoir un pot-de-vin de Bob pour voter pour l'`option B` sur un bulletin même si elle préfère l'`option A`.
+Défini comme "entente visant à limiter la libre concurrence par le trucage, la fraude, et en trompant les autres", la collusion peut prendre la forme d'un individu malveillant influant sur le vote d'autrui en lui offrant des pots-de-vin. Par exemple, Alice pourrait recevoir un pot-de-vin de Bob pour voter pour l'`option B` sur un bulletin de vote même si elle préfère l'`option A`.
 
 La corruption et la collusion limitent l'efficacité de tout processus utilisant le système de vote comme mécanisme de positionnement (en particulier lorsque les usagers peuvent révéler comment ils ont voté). Cela peut avoir des conséquences significatives, en particulier lorsque les votes déterminent l'affectation de ressources limitées.
 
-Par exemple, [les mécanismes de financement quadratiques](https://www.radicalxchange.org/concepts/plural-funding/) dépendent des dons pour mesurer la préférence envers certaines options parmi différents projets d'intérêt public. Chaque don compte comme un « vote » pour un projet spécifique, les projets qui reçoivent le plus de votes obtenant plus de fonds de la réserve de correspondance.
+Par exemple, les [mécanismes de financement quadratique](https://www.radicalxchange.org/wiki/plural-funding/) reposent sur des dons pour mesurer la préférence pour certaines options parmi différents projets de biens publics. Chaque don compte comme un « vote » pour un projet spécifique, les projets qui reçoivent le plus de votes obtenant plus de fonds de la réserve de correspondance.
 
-L'utilisation du vote en chaîne rend le financement quadratique vulnérable à la collusion : les transactions blockchain sont publiques, de sorte que les corrupteurs peuvent inspecter les activités en chaîne d'un corrompu pour voir comment il a "voté". De cette façon, le financement quadratique cesse d’être un moyen efficace d’allouer des fonds en fonction des préférences cumulées de la collectivité.
+L'utilisation du vote en chaîne rend le financement quadratique vulnérable à la collusion : les transactions blockchain sont publiques, de sorte que les corrupteurs peuvent inspecter les activités en chaîne d'un corrompu pour voir comment il a « voté ». De cette façon, le financement quadratique cesse d’être un moyen efficace d’allouer des fonds en fonction des préférences cumulées de la collectivité.
 
-Heureusement, de nouvelles solutions telles que MACI (Minimum Anti-Collusion Infrastructure) utilisent des preuves à divulgation nulle pour rendre le vote en chaîne (par ex. Mécanismes de financement quadratiques) résistant à la corruption et à la collusion. MACI est un ensemble de contrats intelligents et de scripts qui permettent à un administrateur central (appelé un "coordinateur") d'agréger les votes et de comptabiliser les résultats _sans_ révéler des détails sur la façon dont chaque personne a voté. Malgré cela, il est toujours possible de vérifier que les votes ont été comptés correctement, ou de confirmer qu'une personne particulière a participé au vote.
+Heureusement, des solutions plus récentes telles que MACI (Minimum Anti-Collusion Infrastructure) utilisent des preuves à divulgation nulle de connaissance pour rendre le vote en chaîne (par ex., les mécanismes de financement quadratique) résistant à la corruption et à la collusion. MACI est un ensemble de contrats intelligents et de scripts qui permettent à un administrateur central (appelé un « coordinateur ») d'agréger les votes et de compter les résultats _sans_ révéler de détails sur la façon dont chaque individu a voté. Malgré cela, il est toujours possible de vérifier que les votes ont été comptés correctement, ou de confirmer qu'une personne particulière a participé au vote.
 
 #### Comment MACI fonctionne-t-il avec la preuve à divulgation nulle ? {#how-maci-works-with-zk-proofs}
 
-Au départ, le coordinateur déploie le contrat MACI sur Ethereum, après quoi les utilisateurs peuvent s'inscrire au vote (en inscrivant leur clé publique dans le contrat intelligent). Les utilisateurs votent en envoyant des messages chiffrés avec leur clé publique au contrat intelligent (un vote valide doit être signé avec la clé publique la plus récente associée à l'identité de l'utilisateur, entre autres). Le coordinateur traite ensuite tous les messages une fois la période de vote terminée, calcule les votes et vérifie les résultats en chaîne.
+Au départ, le coordinateur déploie le contrat MACI sur Ethereum, après quoi les utilisateurs peuvent s'inscrire au vote (en inscrivant leur clé publique dans le contrat intelligent). Les utilisateurs votent en envoyant des messages chiffrés avec leur clé publique au contrat intelligent (un vote valide doit être signé avec la clé publique la plus récente associée à l'identité de l'utilisateur, entre autres). Ensuite, le coordinateur traite tous les messages une fois la période de vote terminée, comptabilise les votes et vérifie les résultats sur la blockchain.
 
-Dans MACI, des preuves à divulgation nulle sont utilisées pour assurer l'exactitude du calcul en empêchant le coordinateur de traiter les votes et de comptabiliser les résultats de manière incorrecte. Pour ce faire, le coordinateur est tenu de produire des preuves ZK-SNARK permettant de vérifier que a) tous les messages ont été traités correctement b) le résultat final correspond à la somme de tous les _votes valides_.
+Dans MACI, des preuves à divulgation nulle sont utilisées pour assurer l'exactitude du calcul en empêchant le coordinateur de traiter les votes et de comptabiliser les résultats de manière incorrecte. Ceci est réalisé en exigeant du coordinateur qu'il génère des preuves ZK-SNARK vérifiant que a) tous les messages ont été traités correctement b) le résultat final correspond à la somme de tous les votes _valides_.
 
 Ainsi, même sans partager une répartition des votes par utilisateur (comme c'est généralement le cas), MACI garantit l'intégrité des résultats calculés au cours du processus de décompte. Cette caractéristique permet de réduire l'efficacité des programmes de collusion de base. Nous pouvons étudier cette possibilité en utilisant l'exemple précédent de Bob soudoyant Alice pour voter pour une option:
 
 - Alice enregistre son vote en envoyant sa clé publique à un contrat intelligent.
-- Alice accepte de voter pour l'`option B` en échange d'un pot-de-vin de Bob.
+- Alice accepte de voter pour l'`option B` en échange d'un pot-de-vin de la part de Bob.
 - Alice vote pour l'`option B`.
 - Alice envoie secrètement une transaction chiffrée pour changer la clé publique associée à son identité.
-- Alice envoie un autre message (chiffré) au contrat intelligent afin de voter pour l'`option A` en utilisant la nouvelle clé publique.
-- Alice montre à Bob une transaction indiquant qu'elle a voté pour l'`option B` (qui est invalide car la clé publique n'est plus associée à l'identité d'Alice dans le système)
-- Lors du traitement des messages, le coordinateur ignore le vote d'Alice pour l'`option B` et ne compte que le vote pour l'`option A`. Ainsi, la tentative de Bob de se joindre à Alice et de manipuler le vote sur la chaîne échoue.
+- Alice envoie un autre message (chiffré) au contrat intelligent, votant pour l'`option A` en utilisant la nouvelle clé publique.
+- Alice montre à Bob une transaction qui indique qu'elle a voté pour l'`option B` (ce qui est invalide puisque la clé publique n'est plus associée à l'identité d'Alice dans le système)
+- Lors du traitement des messages, le coordinateur ignore le vote d'Alice pour l'`option B` et ne compte que le vote pour l'`option A`. Ainsi, la tentative de Bob de se joindre à Alice et de manipuler le vote sur la blockchain échoue.
 
-L'utilisation de MACI _nécessite_ de faire confiance au coordinateur pour ne pas collaborer avec des corrupteurs ou tenter de soudoyer les électeurs eux-mêmes. Le coordinateur peut déchiffrer les messages des utilisateurs (nécessaires à la création de la preuve), afin qu'ils puissent vérifier avec précision comment chaque personne a voté.
+L'utilisation de MACI _nécessite_ de faire confiance au coordinateur pour ne pas être de connivence avec les corrupteurs ou tenter de corrompre les électeurs lui-même. Le coordinateur peut déchiffrer les messages des utilisateurs (nécessaires à la création de la preuve), afin qu'ils puissent vérifier avec précision comment chaque personne a voté.
 
-Mais dans les cas où le coordinateur reste honnête, MACI représente un outil puissant pour garantir le caractère inviolable du vote en chaîne. Ceci explique sa popularité parmi les demandes de financement quadratiques (par exemple, [clr.fund](https://clr.fund/#/about/maci)) qui dépendent fortement de l'intégrité des choix de vote de chaque individu.
+Mais dans les cas où le coordinateur reste honnête, MACI représente un outil puissant pour garantir le caractère inviolable du vote en chaîne. Cela explique sa popularité auprès des applications de financement quadratique (par ex., [clr.fund](https://clr.fund/#/about/maci)) qui dépendent fortement de l'intégrité des choix de vote de chaque individu.
 
 [En savoir plus sur MACI](https://maci.pse.dev/).
 
@@ -118,75 +141,75 @@ Une preuve à divulgation nulle vous permet de prouver la véracité d'une affir
 
 Un protocole à divulgation nulle doit satisfaire aux critères suivants :
 
-1. **Complétude** : Si l'entrée est valide, le protocole à divulgation nulle renvoie toujours « vrai ». Par conséquent, si la déclaration sous-jacente est vraie, et que le prouveur et le vérificateur agissent honnêtement, la preuve peut être acceptée.
+1. **Complétude** : Si l'entrée est valide, le protocole à divulgation nulle de connaissance renvoie toujours « vrai ». Par conséquent, si la déclaration sous-jacente est vraie, et que le prouveur et le vérificateur agissent honnêtement, la preuve peut être acceptée.
 
-2. **Validité** : Si l'entrée est invalide, il est théoriquement impossible de tromper le protocole à divulgation nulle pour qu'il renvoie la valeur 'vrai'. Ainsi, un prouveur malhonnête ne peut tromper un vérificateur honnête en lui faisant croire qu'une déclaration invalide est valide (sauf avec une infime marge de probabilité).
+2. **Fiabilité** : Si l'entrée est invalide, il est théoriquement impossible de tromper le protocole à divulgation nulle de connaissance pour qu'il renvoie « vrai ». Ainsi, un prouveur malhonnête ne peut tromper un vérificateur honnête en lui faisant croire qu'une déclaration invalide est valide (sauf avec une infime marge de probabilité).
 
-3. **Divulgation nulle** : Le vérificateur n'apprend rien de plus concernant une déclaration que sa validité ou sa fausseté (ils ont une "connaissance nulle" de l'affirmation). Cette condition empêche également le vérificateur de déduire l'information originale (le contenu de la déclaration) à partir de la preuve.
+3. **Divulgation nulle de connaissance** : Le vérificateur n'apprend rien sur une déclaration au-delà de sa validité ou de sa fausseté (il a une « connaissance nulle » de la déclaration). Cette condition empêche également le vérificateur de déduire l'information originale (le contenu de la déclaration) à partir de la preuve.
 
-De manière générale, une preuve à divulgation nulle est composée de trois éléments : **le témoin**, **l'interrogatoire**, et **la réponse**.
+Dans sa forme de base, une preuve à divulgation nulle de connaissance est composée de trois éléments : **témoin**, **défi** et **réponse**.
 
-- **Le témoin** : Dans le cas d'une preuve à divulgation nulle de connaissance, le prouveur veut prouver qu'il connaît certaines informations cachées. L'information secrète est le "témoin" de la preuve, et la connaissance supposée du témoin par le prouveur établit un ensemble de questions auxquelles seule une partie connaissant les informations peut répondre. Le prouveur commence donc le processus de preuve en choisissant aléatoirement une question, en calculant la réponse, et en l'envoyant au vérificateur.
+- **Témoin** : Avec une preuve à divulgation nulle de connaissance, le prouveur veut prouver la connaissance de certaines informations cachées. L'information secrète est le "témoin" de la preuve, et la connaissance supposée du témoin par le prouveur établit un ensemble de questions auxquelles seule une partie connaissant les informations peut répondre. Le prouveur commence donc le processus de preuve en choisissant aléatoirement une question, en calculant la réponse, et en l'envoyant au vérificateur.
 
-- **Interrogatoire** : Le vérificateur choisit ensuite aléatoirement une autre question dans l'ensemble et demande au prouveur d'y répondre.
+- **Défi** : Le vérificateur choisit au hasard une autre question dans l'ensemble et demande au prouveur d'y répondre.
 
 - **Réponse** : Le prouveur accepte la question, calcule la réponse et la renvoie au vérificateur. La réponse du prouveur permet au vérificateur de vérifier si le prouveur a réellement accès au témoin. Pour s'assurer que le prouveur ne devine pas à l'aveuglette et n'obtient pas les bonnes réponses par hasard, le vérificateur choisit davantage de questions à poser. En répétant cette interaction de nombreuses fois, la possibilité pour le prouveur de simuler la connaissance du témoin diminue significativement jusqu'à ce que le vérificateur soit satisfait.
 
 La partie ci-dessus décrit la structure d’une ‘preuve à divulgation nulle de connaissance interactive’. Les premiers protocoles à divulgation nulle utilisaient des preuves interactives, où la vérification de la validité d'une déclaration nécessitait une communication réciproque entre prouveurs et vérificateurs.
 
-Un bon exemple qui illustre le fonctionnement des preuves interactives est la célèbre histoire de la caverne d'Ali Baba de Jean-Jacques Quisquater, disponible sur la page Wikipédia suivante : [lien](https://en.wikipedia.org/wiki/Zero-knowledge_proof#The_Ali_Baba_cave). Dans l'histoire, Peggy (la prouveuse) veut prouver à Victor (le vérificateur) qu'elle connaît la phrase secrète pour ouvrir une porte magique sans révéler la phrase.
+Un bon exemple qui illustre le fonctionnement des preuves interactives est la célèbre [histoire de la caverne d'Ali Baba](https://en.wikipedia.org/wiki/Zero-knowledge_proof#The_Ali_Baba_cave) de Jean-Jacques Quisquater. Dans l'histoire, Peggy (la prouveuse) veut prouver à Victor (le vérificateur) qu'elle connaît la phrase secrète pour ouvrir une porte magique sans révéler la phrase.
 
-### Preuves à divulgation nulle non interactives {#non-interactive-zero-knowledge-proofs}
+### Preuves non interactives à divulgation nulle de connaissance {#non-interactive-zero-knowledge-proofs}
 
 Bien que révolutionnaire, les preuves interactives n'avaient qu'une utilité limitée car les deux parties devaient nécessairement être disponibles et interagir de manière répétée. Même si le vérificateur était convaincu de l'honnêteté du prouveur, la preuve était indisponible pour une vérification indépendante (le calcul d'une nouvelle preuve nécessitait un nouvel ensemble de messages entre le prouveur et le vérificateur).
 
-Pour résoudre ce problème, Manuel Blum, Paul Feldman et Silvio Micali ont proposé les premières [preuves à connaissance nulle non interactives](https://dl.acm.org/doi/10.1145/62212.62222) où le prouveur et le vérificateur disposent d'une clé partagée. Cela permet au prouveur de démontrer sa connaissance de certaines informations (c'est-à-dire, le témoin) sans fournir les informations elles-mêmes.
+Pour résoudre ce problème, Manuel Blum, Paul Feldman et Silvio Micali ont suggéré les premières [preuves non interactives à divulgation nulle de connaissance](https://dl.acm.org/doi/10.1145/62212.62222) où le prouveur et le vérificateur ont une clé partagée. Cela permet au prouveur de démontrer sa connaissance de certaines informations (c'est-à-dire, le témoin) sans fournir les informations elles-mêmes.
 
-Contrairement aux preuves interactives, les preuves ** non** interactives ne nécessitent qu'un seul échange entre les participants (le prouveur et le vérificateur). Le prouveur transmet l'information secrète à un algorithme spécial pour calculer une preuve à connaissance nulle. Cette preuve est envoyée au vérificateur, qui vérifie que le prouveur connaît les informations secrètes à l'aide d'un autre algorithme.
+Contrairement aux preuves interactives, les preuves <strong> non</strong> interactives ne nécessitent qu'un seul échange entre les participants (le prouveur et le vérificateur). Le prouveur transmet l'information secrète à un algorithme spécial pour calculer une preuve à connaissance nulle. Cette preuve est envoyée au vérificateur, qui vérifie que le prouveur connaît les informations secrètes à l'aide d'un autre algorithme.
 
 Les preuves non interactives réduisent les communications entre le prouveur et le vérificateur, rendant les preuves à divulgation nulle plus efficaces. De plus, une fois générée, la preuve est disponible à toute personne (ayant accès à la clé partagée et à l'algorithme de vérification) souhaitant effectuer la vérification.
 
 Les preuves non interactives ont constitué une véritable percée dans la technologie de la connaissance nulle et ont encouragé le développement des systèmes de preuve utilisés aujourd'hui. Nous abordons ce type de preuves ci-dessous:
 
-### Types de preuves à divulgation nulle {#types-of-zero-knowledge-proofs}
+### Types de preuves à divulgation nulle de connaissance {#types-of-zero-knowledge-proofs}
 
 #### ZK-SNARKs {#zk-snarks}
 
-ZK-SNARK est l'acronyme de ** "Zero-Knowledge Succinct Non-Interactive Argument of Knowledge"**. En français, on utilise souvent l'acronyme "ZK-SNARK" tel quel, mais on peut également le traduire en "preuve succincte non interactive à divulgation nulle" ou "argument de divulgation nulle succinct non interactif". Le protocole ZK-SNARK possède les qualités suivantes :
+ZK-SNARK est un acronyme pour **Zero-Knowledge Succinct Non-Interactive Argument of Knowledge**. Le protocole ZK-SNARK possède les qualités suivantes :
 
-- **Connaissance nulle** : Un vérificateur peut valider l'intégrité d'une déclaration sans ne rien savoir d'autre de cette déclaration. La seule connaissance que le vérificateur a de la déclaration est celle de savoir si elle est vraie ou fausse.
+- **Divulgation nulle de connaissance** : un vérificateur peut valider l'intégrité d'une déclaration sans rien savoir d'autre sur la déclaration. La seule connaissance que le vérificateur a de la déclaration est celle de savoir si elle est vraie ou fausse.
 
 - **Succinct** : La preuve à divulgation nulle de connaissance est plus petite que le témoin et peut être vérifiée rapidement.
 
-- **Non-interactif** : La preuve est « non interactive » car le prouveur et le vérificateur n'interagissent qu'une seule fois, contrairement aux preuves interactives nécessitant plusieurs étapes de communication.
+- **Non-interactif** : La preuve est « non interactive » car le prouveur et le vérificateur n'interagissent qu'une seule fois, contrairement aux preuves interactives qui nécessitent plusieurs cycles de communication.
 
-- **Argument** : La preuve satisfait à l'exigence de 'crédibilité', de sorte que la triche est extrêmement improbable.
+- **Argument** : La preuve satisfait à l'exigence de « fiabilité », de sorte que la triche est extrêmement improbable.
 
-- **(de) Connaissance**: La preuve à divulgation nulle de connaissance ne peut être construite sans accès aux informations secrètes (témoin). Il est difficile, voire impossible, au prouveur ne disposant pas du témoin, de créer une preuve valable à divulgation nulle.
+- **(de) Connaissance** : La preuve à divulgation nulle de connaissance ne peut être construite sans l'accès à l'information secrète (le témoin). Il est difficile, voire impossible, au prouveur ne disposant pas du témoin, de créer une preuve valable à divulgation nulle.
 
 La « clé partagée » mentionnée précédemment fait référence à des paramètres publics que le prouveur et le vérificateur acceptent d’utiliser pour générer et vérifier les preuves. La génération des paramètres publics (collectivement appelés Common Reference String (CRS)) est une opération sensible en raison de son importance du point de vue de la sécurité du protocole. Si l'entropie (l'aléa) utilisée pour générer le CRS tombe dans les mains d'un prouveur malhonnête, celui-ci peut fabriquer de fausses preuves.
 
-[Le Calcul Sécurisé Multi-parties (CSMP)](https://fr.wikipedia.org/wiki/Calcul_s%C3%A9curis%C3%A9_multi-parties) est une façon de réduire les risques liés à la génération des paramètres publics. Plusieurs parties participent à une [cérémonie de configuration de confiance](https://zkproof.org/2021/06/30/setup-ceremonies/amp/), où chaque personne fournit des valeurs aléatoires pour générer le CRS. Tant qu'une partie honnête détruit sa part d'entropie, le protocole ZK-SNARK conserve sa validité sur le plan du calcul.
+Le [calcul multipartite (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) est un moyen de réduire les risques liés à la génération de paramètres publics. Plusieurs parties participent à une [cérémonie de configuration de confiance](https://zkproof.org/2021/06/30/setup-ceremonies/amp/), où chaque personne contribue avec des valeurs aléatoires pour générer le CRS. Tant qu'une partie honnête détruit sa part d'entropie, le protocole ZK-SNARK conserve sa validité sur le plan du calcul.
 
 Les configurations de confiance nécessitent des utilisateurs qui se fient aux participants dans la génération des paramètres. Cependant, le développement de ZK-STARKs a permis la création de protocoles de preuve qui fonctionnent sans configuration de confiance (ou « setup ») préalable.
 
 #### ZK-STARKs {#zk-starks}
 
-ZK-STARK est un acronyme pour **Zero-Knowledge Scalable Transparent Argument of Knowledge**. ("preuve évolutive transparente à divulgation nulle"). Les ZK-STARKs sont similaires aux ZK-SNARKs, sauf qu'ils sont:
+ZK-STARK est un acronyme pour **Zero-Knowledge Scalable Transparent Argument of Knowledge**. Les ZK-STARKs sont similaires aux ZK-SNARKs, sauf qu'ils sont:
 
-- **Évolutifs** : ZK-STARK est plus rapide que ZK-SNARK pour générer et vérifier des preuves avec un témoin de taille plus importante. Avec les preuves STARK, les temps de preuve et de vérification n'augmentent que légèrement lorsque le témoin (witness) augmente (tandis que pour les SNARK ils augmentent linéairement selon la taille du témoin).
+- **Évolutif** : ZK-STARK est plus rapide que ZK-SNARK pour générer et vérifier des preuves lorsque la taille du témoin est plus grande. Avec les preuves STARK, les temps de preuve et de vérification n'augmentent que légèrement lorsque le témoin (witness) augmente (tandis que pour les SNARK ils augmentent linéairement selon la taille du témoin).
 
-- **Transparents**: Contrairement à ZK-SNARK (qui se base sur une configuration de confiance), ZK-STARK repose sur un aléa publiquement vérifiable pour générer les paramètres publics de preuve et de vérification.  Ainsi, ils sont plus transparents que les ZK-SNARKs.
+- **Transparent** : ZK-STARK s'appuie sur un caractère aléatoire publiquement vérifiable pour générer des paramètres publics pour la preuve et la vérification, au lieu d'une configuration de confiance. Ainsi, ils sont plus transparents que les ZK-SNARKs.
 
 Les ZK-STARKs produisent des preuves plus volumineuses que les ZK-SNARKs, engendrant des frais de vérification généralement plus élevés. Cependant, il y a des cas (comme la preuve de grands ensembles de données) où les ZK-STARKs peuvent être plus intéressants que les ZK-SNARKs.
 
-## Inconvénients à utiliser des preuves à divulgation nulle de connaissance {#drawbacks-of-using-zero-knowledge-proofs}
+## Inconvénients de l'utilisation des preuves à divulgation nulle de connaissance {#drawbacks-of-using-zero-knowledge-proofs}
 
-### Coûts en matériels {#hardware-costs}
+### Coûts matériels {#hardware-costs}
 
 La génération de preuves à divulgation nulle de connaissance implique des calculs très complexes qu'il est préférable d'effectuer sur des machines spécialisées. Comme ces machines coûtent cher, elles sont souvent hors de portée des personnes ordinaires. En outre, les applications qui veulent utiliser une technologie à divulgation nulle de connaissance doivent prendre en compte les coûts matériels, et cela peut augmenter les coûts pour les utilisateurs finaux.
 
-### Coûts de la vérification de la preuve {#proof-verification-costs}
+### Coûts de vérification de la preuve {#proof-verification-costs}
 
 La vérification des preuves nécessite également un calcul complexe et augmente les coûts de mise en œuvre de la technologie à divulgation nulle de connaissance dans les applications. Ce coût est particulièrement pertinent dans le contexte de la preuve du calcul. Par exemple, les rollups ZK paient ~ 500 000 gaz pour vérifier une seule preuve ZK-SNARK sur Ethereum, avec des ZK-STARK nécessitant des frais encore plus élevés.
 
@@ -196,19 +219,20 @@ Dans ZK-SNARK, la chaîne de référence commune (paramètres publics) est gén
 
 Mais il n’y a vraiment aucun moyen pour les utilisateurs d’évaluer l’honnêteté des participants et les utilisateurs doivent croire les développeurs sur parole. Les ZK-STARK sont libres d'hypothèses de confiance, puisque le caractère aléatoire utilisé dans la génération de la chaîne est publiquement vérifiable. En attendant, les chercheurs travaillent sur des installations non fiables pour les ZK-SNARK afin d'accroître la sécurité des mécanismes de preuve.
 
-### Menaces liées à l'informatique quantique {#quantum-computing-threats}
+### Menaces de l'informatique quantique {#quantum-computing-threats}
 
 ZK-SNARK utilise la cryptographie sur les courbes elliptiques pour le chiffrement. Tandis que le problème du logarithme discret sur les courbes elliptiques est présumé être insoluble pour le moment, le développement des ordinateurs quantiques pourrait briser ce modèle de sécurité à l'avenir.
 
 Un ZK-STARK est considéré comme immunisé contre les menaces de l'informatique quantique, car il repose uniquement sur les fonctions de hachage résistantes à la collision pour sa sécurité. Contrairement aux appairages de clés public-privé utilisés dans la cryptographie sur les courbes elliptiques, le hachage résistant aux collisions est plus difficile à briser pour les algorithmes de calcul quantique.
 
-## Complément d'information {#further-reading}
-
-- [Vue d'ensemble des cas d'utilisation des preuves à connaissance nulle](https://pse.dev/projects) - _Privacy and Scaling Explorations Team_
-- [SNARKs vs. STARKS vs SNARKs vs. Récursive SNARKs](https://www.alchemy.com/overviews/snarks-vs-starks) — _Aperçu d’Alchemy_
-- [Une preuve à divulgation nulle : Améliorer la confidentialité sur une Blockchain](https://www.altoros.com/blog/zero-knowledge-proof-improving-privacy-for-a-blockchain/) — _Dmitry Lavrenov_
-- [zk-SNARKs — Un exemple de preuve à divulgation nulle réaliste et une plongée en profondeur](https://medium.com/coinmonks/zk-snarks-a-realistic-zero-knowledge-example-and-deep-dive-c5e6eaa7131c) — _Adam Luciano_
-- [ZK-STARKs – Créez une confiance vérifiable, même contre Quantum Computers](https://medium.com/coinmonks/zk-starks-create-verifiable-trust-even-against-quantum-computers-dd9c6a2bb13d) — _Adam Luciano_
-- [Une brève introduction à la façon dont les zk-SNARK sont possibles](https://vitalik.eth.limo/general/2021/01/26/snarks.html) — _Vitalik Buterin_
-- [Pourquoi la preuve à divulgation nulle de connaissance (ZKP) est un changement majeur pour l'identité numérique auto-souveraine](https://frankiefab.hashnode.dev/why-zero-knowledge-proofs-zkps-is-a-game-changer-for-self-sovereign-identity) - _Franklin Ohaegbulam_
-
+## En savoir plus {#further-reading}
+
+- [Aperçu des cas d'utilisation des preuves à divulgation nulle de connaissance](https://pse.dev/projects) — _Privacy and Scaling Explorations Team_
+- [SNARKs vs. STARKS vs. SNARKs récursifs](https://www.alchemy.com/overviews/snarks-vs-starks) — _Alchemy Overviews_
+- [Une preuve à divulgation nulle de connaissance : améliorer la confidentialité sur une blockchain](https://www.altoros.com/blog/zero-knowledge-proof-improving-privacy-for-a-blockchain/) — _Dmitry Lavrenov_
+- [zk-SNARKs — Un exemple réaliste de divulgation nulle de connaissance et une analyse approfondie](https://medium.com/coinmonks/zk-snarks-a-realistic-zero-knowledge-example-and-deep-dive-c5e6eaa7131c) — _Adam Luciano_
+- [ZK-STARKs — Créez une confiance vérifiable, même contre les ordinateurs quantiques](https://medium.com/coinmonks/zk-starks-create-verifiable-trust-even-against-quantum-computers-dd9c6a2bb13d) — _Adam Luciano_
+- [Une introduction approximative à la façon dont les zk-SNARKs sont possibles](https://vitalik.eth.limo/general/2021/01/26/snarks.html) — _Vitalik Buterin_
+- [Pourquoi les preuves à divulgation nulle de connaissance (ZKP) changent la donne pour l'identité auto-souveraine](https://frankiefab.hashnode.dev/why-zero-knowledge-proofs-zkps-is-a-game-changer-for-self-sovereign-identity) — _Franklin Ohaegbulam_
+- [EIP-7503 expliqué : Activer les transferts privés sur Ethereum avec les preuves ZK](https://research.2077.xyz/eip-7503-zero-knowledge-wormholes-for-private-ethereum-transactions#introduction) — _Emmanuel Awosika_
+- [ZK Card Game : jeu pour apprendre les fondamentaux des ZK et les cas d'utilisation réels](https://github.com/ZK-card/zk-cards) - _ZK-Cards_
diff --git a/src/intl/fr/glossary-tooltip.json b/src/intl/fr/glossary-tooltip.json
index 988c99087f4..e52234c6c5e 100644
--- a/src/intl/fr/glossary-tooltip.json
+++ b/src/intl/fr/glossary-tooltip.json
@@ -58,8 +58,8 @@
   "erc-721-term": "ERC-721",
   "erc-721-definition": "Un ensemble de règles standard utilisé pour créer des NFT (jetons non fongibles).",
   "ether-term": "Ether",
-  "ether-definition": "La cryptomonnaie native d’Ethereum, communément appelée « ETH ». Elle est utilisée pour couvrir les frais de transaction lors de l’utilisation de l’écosystème et des applications Ethereum. <a href=\"/what-is-ether/\">En savoir plus sur ether</a>.",
-  "events-term": "Évènements",
+  "ether-definition": "La cryptomonnaie native d’Ethereum, communément appelée « ETH ». Elle est utilisée pour couvrir les frais de transaction lors de l’utilisation de l’écosystème et des applications Ethereum. <a href=\"/eth/\">En savoir plus sur ether</a>.",
+  "events-term": "Événements",
   "events-definition": "Permet d'utiliser les fonctions de journalisation de l'<a href=\"/glossary/#evm\">EVM</a>. Les <a href=\"/glossary/#dapp\">dApps</a> peuvent écouter les événements et les utiliser pour déclencher des rappels JavaScript dans l'interface utilisateur. <a href=\"/developers/docs/smart-contracts/anatomy/#events-and-logs\">En savoir plus sur les événements et les journaux</a>.",
   "execution-client-term": "Client d'exécution",
   "execution-client-definition": "Les clients d'exécution (anciennement appelés « clients Eth1 »), tels que Besu, Erigon, Go-Ethereum (Geth), Nethermind, sont chargés de traiter et de diffuser les transactions et de gérer l'état d'Ethereum. Ils exécutent les calculs pour chaque transaction en utilisant la <a href=\"/glossary/#evm\">machine virtuelle Ethereum</a> pour s'assurer que les règles du protocole sont respectées.",
@@ -85,7 +85,7 @@
   "index-definition": "Structure réseau destinée à optimiser la sollicitation d'informations à travers la <a href=\"/glossary/#blockchain\">blockchain</a> en fournissant un chemin efficace vers sa source de stockage.",
   "key-term": "Clé",
   "key-definition": "Dans le contexte d'Ethereum, les clés sont des codes numériques : une clé publique pour recevoir des transactions et une clé privée pour accéder aux fonds et les envoyer.",
-  "layer-2-term": "Couche 2",
+  "layer-2-term": "Couche de niveau 2",
   "layer-2-definition": "Les couches de niveau 2 sont d'autres réseaux construits sur le réseau principal d’Ethereum pour rendre les transactions plus rapides et moins chères. <a href=\"/layer-2/\">En savoir plus sur la couche de niveau 2</a>.",
   "liquidity-tokens-term": "Jetons de liquidité",
   "liquidity-tokens-definition": "Les jetons de liquidité (LT) sont des jetons numériques émis à l'intention des participants qui déposent des actifs dans un pool de liquidité, ce dernier étant un ensemble de fonds verrouillés dans un contrat intelligent et utilisés pour faciliter les échanges sur une bourse décentralisée (DEX).",
@@ -125,7 +125,7 @@
   "quadratic-voting-definition": "Il s’agit d’un mode de scrutin où les électeurs expriment leur opinion sur les enjeux. Il permet aux électeurs de montrer non seulement leur préférence, mais aussi l’intensité de leur préférence.",
   "recovery-phrase-term": "Phrase de départ/phrase de récupération",
   "recovery-phrase-definition": "Une liste de mots qui vous sont donnés lorsque vous créez un portefeuille numérique. Elle agit comme un mot de passe qui peut vous aider à revenir dans votre portefeuille si vous en perdez l’accès, vous garantissant ainsi de ne pas perdre votre argent ou vos jetons numériques.",
-  "rollups-term": "Rollups",
+  "rollups-term": "rollups",
   "rollups-definition": "Un type de solution de mise à l'échelle de la <a href=\"/glossary/#layer-2\">couche 2</a> qui regroupe plusieurs transactions et les soumet à <a href=\"/glossary/#mainnet\">la chaîne principale Ethereum</a> en une seule transaction. Cela permet de réduire les coûts de <a href=\"/glossary/#gas\">gaz</a> et d'augmenter le débit des <a href=\"/glossary/#transaction\">transactions</a>. Il existe des rollups optimistes et à connaissance nulle qui utilisent différentes méthodes de sécurité pour offrir ces gains d'évolutivité. <a href=\"/developers/docs/scaling/#rollups\">En savoir plus sur les rollups</a>.",
   "rpc-term": "Appel de procédure distante (RPC)",
   "rpc-definition": "RPC permet à un ordinateur de demander des données ou des actions à un autre via un réseau, à la manière d'une télécommande demandant des informations.",
@@ -135,7 +135,7 @@
   "smart-contract-definition": "Un contrat intelligent est un programme qui exécute automatiquement des accords sur une blockchain, comme un contrat numérique auto-exécutable. <a href=\"/smart-contracts/\">Introduction aux contrats intelligents</a>.",
   "stablecoin-term": "Stablecoin",
   "stablecoin-definition": "Un stablecoin est un type de cryptomonnaie conçu pour avoir une valeur stable, souvent indexée sur une devise ou une marchandise (comme le dollar américain), afin de minimiser la volatilité des prix. <a href=\"/stablecoins/\">En savoir plus sur les stablecoins</a>.",
-  "staking-term": "Staking",
+  "staking-term": "Mise en jeu",
   "staking-definition": "Le dépôt d'une quantité d'<a href=\"/glossary/#ether\">ether</a> (votre mise) pour devenir un validateur et sécuriser le <a href=\"/glossary/#network\">réseau</a>. Un validateur vérifie les <a href=\"/glossary/#transaction\">transactions</a> et propose des <a href=\"/glossary/#block\">blocs</a> sous un modèle de consensus de <a href=\"/glossary/#pos\">preuve d'enjeu</a>. Le staking vous offre une incitation économique à agir dans le meilleur intérêt du réseau. Vous recevrez des récompenses pour l'exécution de vos tâches de <a href=\"/glossary/#validator\">validateur</a>, mais vous perdrez des quantités variables d'ETH si vous ne le faites pas. <a href=\"/staking/\">En savoir plus sur le staking Ethereum</a>.",
   "staking-pool-term": "Pools de mise en jeu",
   "staking-pool-definition": "L'ETH combiné de plus d'un staker Ethereum, utilisé pour atteindre les 32 ETH requis pour activer un ensemble de clés de validation. Un opérateur de nœud utilise ces clés pour participer au consensus et les <a href=\"/glossary/#block-reward\">récompenses du bloc</a> sont réparties entre les stakers qui y contribuent. Les pools de staking ou la délégation de staking ne font pas partie du protocole Ethereum, mais de nombreuses solutions ont été élaborées par la communauté. <a href=\"/staking/pools/\">En savoir plus sur les pools de mise en jeu</a>.",
@@ -150,7 +150,7 @@
   "validator-term": "Validateur",
   "validator-definition": "Un <a href=\"/glossary/#node\">nœud</a> dans un système de <a href=\"/glossary/#pos\">preuve d'enjeu</a> responsable du stockage des données, du traitement des transactions et de l'ajout de nouveaux blocs à la blockchain. Pour activer le logiciel de validation, vous devez être en mesure de <a href=\"/glossary/#staking\">miser</a> 32 ETH. <a href=\"/staking/\">En savoir plus sur la mise en jeu dans Ethereum</a>.",
   "validity-proof-term": "Preuve de validité",
-  "validity-proof-definition": "Un modèle de sécurité pour certaines solutions de <a href=\"/glossary/#layer-2\">couche 2</a> où, pour augmenter la vitesse, les transactions sont regroupées en lots et soumises à Ethereum en une seule transaction. Le calcul des transactions est effectué hors chaîne, puis fourni à la chaîne principale avec une preuve de leur validité. Cette méthode permet d'augmenter le nombre de transactions possibles tout en maintenant la sécurité. Certains <a href=\"/glossary/#rollups\">rollups</a> utilisent des <a href=\"/glossary/#fraud-proof\">preuves de fraude</a>. <a href=\"/developers/docs/scaling/zk-rollups/\">En savoir plus sur les rollups Zk</a>.",
+  "validity-proof-definition": "Un modèle de sécurité pour certaines solutions de <a href=\"/glossary/#layer-2\">couche 2</a> où, pour augmenter la vitesse, les transactions sont regroupées en lots et soumises à Ethereum en une seule transaction. Le calcul des transactions est effectué hors chaîne, puis fourni à la chaîne principale avec une preuve de leur validité. Cette méthode permet d'augmenter le nombre de transactions possibles tout en maintenant la sécurité. Certains <a href=\"/glossary/#rollups\">rollups</a> utilisent des <a href=\"/glossary/#fraud-proof\">preuves de fraude</a>. <a href=\"/developers/docs/scaling/zk-rollups/\">En savoir plus sur les rollups ZK</a>.",
   "wallet-term": "Portefeuille",
   "wallet-definition": "Un portefeuille est un outil numérique permettant de stocker, d'envoyer et de recevoir de la monnaie numérique, comme une bourse virtuelle pour votre argent en ligne. <a href=\"/wallets/\">En savoir plus sur les portefeuilles Ethereum</a>.",
   "web2-term": "Web2",
diff --git a/src/intl/fr/glossary.json b/src/intl/fr/glossary.json
index 815590cc97f..c9a8c5d58f3 100644
--- a/src/intl/fr/glossary.json
+++ b/src/intl/fr/glossary.json
@@ -1,6 +1,6 @@
 {
   "51%-attack-term": "Attaque de 51 %",
-  "51%-attack-definition": "Un type d'attaque où un groupe prend le contrôle de la majorité des <a href=\"/glossary/#node\"> nœuds</a>, leur permettant de corrompre la blockchain en inversant <a href=\"/glossary/#transaction\">les transactions</a> et en dépensant deux fois <a href=\"/glossary/#ether\">l'ether</a> et tout autre jeton.<br /><br />Dans le cas de la preuve d'enjeu d'Ethereum, ce résultat serait obtenu en accumulant plus de la moitié du total des éthers misés. Cela permettrait à un attaquant de décider quels nouveaux blocs sont ajoutés à la blockchain. Toutefois, pour inverser la chaîne ou effectuer une double dépense, l'attaquant devrait disposer d'au moins 66 % du total de l'éther mis en jeu.",
+  "51%-attack-definition": "Un type d'attaque où un groupe prend le contrôle de la majorité des <a href=\"/glossary/#node\">nœuds</a>. Cela leur permettrait de frauder la blockchain en annulant des <a href=\"/glossary/#transaction\">transactions</a> et en effectuant une double dépense d'<a href=\"/glossary/#ether\">ether</a> et d'autres jetons.<br /><br />Dans le système de preuve d'enjeu d'Ethereum, cela serait possible en accumulant plus de la moitié du total d'ether mis en jeu. Cela permettrait à un attaquant de décider quels nouveaux blocs sont ajoutés à la blockchain. Cependant, pour inverser la chaîne ou effectuer une double dépense, un attaquant aurait besoin d'au moins 66 % du total d'ether mis en jeu.",
   "account-term": "Compte",
   "account-definition": "Un compte Ethereum est une identité digitale sur la blockchain Ethereum, permettant aux utilisateurs d'envoyer, de recevoir de l'Ether et d'interagir avec les contrats intelligents.<br /><br /><strong> Technique : </strong><br />il s'agit d'un objet contenant une adresse, un solde, une nonce, un stockage optionnel et du code. Un compte peut être un compte contrat ou un compte externe (EOA en anglais).",
   "address-term": "Adresse",
@@ -62,7 +62,7 @@
   "committee-term": "Comité",
   "committee-definition": "Un groupe d'au moins 128 <a href=\"/glossary/#validator\">validateurs</a> chargés de valider les blocs dans chaque créneau. L'un des validateurs du comité est l'agrégateur, chargé d'agréger les signatures de tous les autres validateurs du comité qui s'accordent sur une attestation. À ne pas confondre avec <a href=\"/glossary/#sync-committee\">le comité de synchronisation</a>.",
   "computational-infeasibility-term": "Infaisabilité informatique",
-  "computational-infeasibility-definition": "Un processus est infaisable sur le plan informatique s'il prenait un temps excessivement long (par exemple, des milliards d'années) pour quiconque pourrait avoir un intérêt à le mettre en œuvre.",
+  "computational-infeasibility-definition": "Un processus est considéré comme infaisable sur le plan informatique si sa réalisation prenait un temps déraisonnablement long (p. ex., des milliards d'années) pour quiconque pourrait avoir un intérêt à l'exécuter.",
   "consensus-term": "Consensus",
   "consensus-definition": "Quand plus de deux tiers des ordinateurs d'un réseau s'accordent sur le même ensemble d'enregistrement, s'assurant que chacun est au même niveau. Cela ne concerne pas les règles qu'ils suivent, mais le fait de s'assurer qu'ils disposent tous des mêmes informations.",
   "consensus-client-term": "Client de consensus",
@@ -88,13 +88,15 @@
   "dag-term": "DAG",
   "dag-definition": "DAG signifie Directed Acyclic Graph (graphe acyclique dirigé). Il s'agit d'une structure de données composée de nœuds et de liens entre eux. Avant la Fusion, Ethereum utilisait un DAG dans son algorithme de <a href=\"/glossary/#pow\">preuve de travail</a>, <a href=\"/glossary/#ethash\">Ethash</a>, mais il n'est plus utilisé dans la <a href=\"/glossary/#pos\">preuve d'enjeu</a>.",
   "dapp-term": "DApp",
-  "dapp-definition": "Une dApp est une application décentralisée qui s’exécute sur un réseau blockchain, offrant des services sans autorité de contrôle centrale. <a href=\"/apps/\">En savoir plus sur les applications décentralisées</a>. <br />Au minimum, une dApp dispose d’un contrat intelligent connecté à une interface Web. En outre, de nombreuses dApps incluent un stockage décentralisé et / ou un protocole de message et une plateforme.",
+  "dapp-definition": "Une dApp est une application décentralisée qui s’exécute sur un réseau blockchain, offrant des services sans autorité de contrôle centrale. <a href=\"/apps/\">En savoir plus sur les applications décentralisées</a>. <br />Au minimum, une dApp dispose d’un contrat intelligent connecté à une interface Web. En outre, de nombreuses dApps incluent un stockage décentralisé et/ou un protocole de message et une plateforme.",
   "data-availability-term": "Disponibilité des données",
   "data-availability-definition": "N'importe quel nœud peut vérifier indépendamment une transaction sur la blockchain afin de maintenir la transparence et la confiance dans le système.",
   "decentralization-term": "Décentralisation",
   "decentralization-definition": "Action de transférer le contrôle et l'exécution des processus en dehors d'une entité centrale.",
   "dao-term": "Organisation autonome décentralisée (DAO)",
   "dao-definition": "Une DAO est une organisation digitale opérée par des règles codées sur une blockchain, où les décisions sont prises via le vote de ses membres et non par une autorité centrale. <a href=\"/dao/\">En savoir plus sur les organisations décentralisées autonomes (DAOs, en anglais)</a>.<br /> Le pouvoir de vote de chaque membre est souvent lié au nombre de jetons qu'il détient. Les DAO visent à démocratiser la prise de décision et les opérations, en se concentrant sur une gouvernance transparente et communautaire.",
+  "desci-term": "DeSci",
+  "desci-definition": "La DeSci, ou science décentralisée, est un mouvement qui applique la technologie <a href='/glossary/#blockchain'>blockchain</a> à la recherche scientifique. Elle s'appuie sur les <a href='/glossary/#dao'>DAO</a>, les <a href='/glossary/#smart-contract'>contrats intelligents</a> et les incitations tokenisées pour créer des écosystèmes de financement et de recherche plus transparents, ouverts et collaboratifs.",
   "dex-term": "Échange décentralisé (DEX)",
   "dex-definition": "Un type d’application Ethereum qui vous permet d’échanger des jetons avec des pairs sur le réseau. Les DEX ne sont pas soumis à des restrictions géographiques comme les échanges centralisés – tout le monde peut participer.",
   "deposit-contract-term": "Contrat de dépôt",
@@ -112,7 +114,7 @@
   "distributed-hash-table-term": "Table d'empreintes numériques distribuée (DHT)",
   "distributed-hash-table-definition": "Une structure de données contenant des paires `(key, value)` utilisées par les nœuds Ethereum pour identifier les pairs auxquels se connecter et déterminer les protocoles à utiliser pour communiquer.",
   "double-spend-term": "Double dépense",
-  "double-spend-definition": "Il s'agit d'un fork délibéré de la blockchain, dans lequel un utilisateur disposant d'une puissance minière ou d'un enjeu suffisamment important envoie une transaction déplaçant une certaine devise hors de la chaîne (par exemple, en sortant en monnaie fiduciaire ou en effectuant un achat hors de la chaîne), puis réorganise la blockchain afin de supprimer cette transaction. Une double dépense réussie laisse l'attaquant avec ses actifs sur la chaîne et hors chaîne.",
+  "double-spend-definition": "Une fourche délibérée de la blockchain, où un utilisateur disposant d'une puissance de minage/mise suffisamment importante envoie une transaction déplaçant une devise hors chaîne (p. ex., en la convertissant en monnaie fiduciaire ou en effectuant un achat hors chaîne), puis réorganise la blockchain pour supprimer cette transaction. Une double dépense réussie laisse à l'attaquant ses actifs sur et hors chaîne.",
   "ecdsa-term": "Algorithme de Signature Numérique à Courbe Elliptique (ECDSA)",
   "ecdsa-definition": "Algorithme cryptographique utilisé par Ethereum pour garantir que les fonds ne peuvent être dépensés que par leurs propriétaires. C'est la méthode préférée pour créer des clés publiques et privées. Pertinent pour la génération d'<a href=\"/glossary/#address\">adresses</a> de compte et la vérification des <a href=\"/glossary/#transaction\">transactions</a>.",
   "encryption-term": "Chiffrement",
@@ -134,7 +136,7 @@
   "erc-1155-term": "ERC-1155",
   "erc-1155-definition": "ERC-1155 est un nouveau type de norme de jeton Ethereum similaire à NFT (comme les objets de collection uniques) qui permet également de créer des objets interchangeables (comme de la monnaie) dans un seul contrat intelligent. <br />Il est ainsi plus facile et plus efficace de gérer différents types d’actifs numériques, en particulier pour des applications telles que les jeux vidéo ou les collections numériques.",
   "erc-20-term": "ERC-20",
-  "erc-20-definition": "ERC-20 est la norme que la plupart des jatons du réseau Ethereum utilisent pour leur création. <br />Les exemples populaires sont les stablecoins comme DAI et USDC ou les jetons d’échange comme UNI d’Uniswap. Semblable à toute autre forme d’argent que nous connaissons dans les systèmes traditionnels… c.-à-d. les points de récompense, les systèmes de crédit, ou même les actions, etc.",
+  "erc-20-definition": "ERC-20 est la norme que la plupart des jetons sur le réseau Ethereum utilisent pour leur création.<br />Les exemples populaires sont les stablecoins comme DAI et USDC ou les jetons d'échange comme UNI d'Uniswap. Semblable à toute forme de monnaie alternative que nous avons dans les systèmes traditionnels… c'est-à-dire les points de récompense, les systèmes de crédit, ou même les actions, etc.",
   "erc-721-term": "ERC-721",
   "erc-721-definition": "Les NFTs (jetons non fongibles) sont créés en utilisant un ensemble standard de règles appelé ERC-721.<br />Les jetons NFT peuvent représenter la propriété de n'importe quoi d'unique, comme des œuvres d'art numériques ou des objets de collection, chaque jeton ayant ses propres caractéristiques et sa valeur spécifiques. Chaque NFT est unique et facilement distinguable de tout autre NFT.",
   "execution-client-term": "Client d'exécution",
@@ -151,7 +153,7 @@
   "ether-definition": "La cryptomonnaie native d’Ethereum, communément appelée « ETH ». Elle est utilisée pour couvrir les frais de transaction lors de l’utilisation de l’écosystème et des applications Ethereum. <a href=\"/what-is-ether/\">En savoir plus sur ether</a>.",
   "events-term": "Évènements",
   "events-definition": "Permet d'utiliser les fonctions de journalisation de l'<a href=\"/glossary/#evm\">EVM</a>. Les <a href=\"/glossary/#dapp\">dApps</a> peuvent écouter les événements et les utiliser pour déclencher des rappels JavaScript dans l'interface utilisateur. <a href=\"/developers/docs/smart-contracts/anatomy/#events-and-logs\">En savoir plus sur les événements et les journaux</a>.",
-  "evm-term": "Machine virtuelle Ethereum (EVM)",
+  "evm-term": "Machine Virtuelle Ethereum (EVM)",
   "evm-definition": "Une machine virtuelle basée sur une pile qui exécute du <a href=\"/glossary/#bytecode\">bytecode</a>. Avec Ethereum, le modèle d'exécution spécifie comment l'état du système est modifié compte tenu d'une série d'instructions bytecode et d'un petit tuple de données environnementales. Ceci est spécifié à travers un modèle formel d'une machine d'état virtuelle. <a href=\"/developers/docs/evm/\">En savoir plus sur la machine virtuelle Ethereum</a>.",
   "evm-assembly-language-term": "Langage d'assemblage de l'EVM",
   "evm-assembly-language-definition": "Forme lisible par l'homme du <a href=\"/glossary/#bytecode\">bytecode de l'EVM.",
@@ -213,7 +215,7 @@
   "key-definition": "Dans le cas d’Ethereum, les clés sont des codes numériques : une clé publique pour recevoir des transactions et une clé privée pour accéder aux fonds et en envoyer. <br />Clés publiques : elles peuvent être partagées ouvertement. <br />Clés privées : elles sont gardées secrètes par le propriétaire.",
   "layer-1-term": "Couche 1",
   "layer-1-definition": "La couche de niveau 1 fait référence à la blockchain principale dans un réseau de blockchain à plusieurs niveaux. Par exemple, Ethereum et Bitcoin sont des blockchains de la couche 1. De nombreuses blockchains de deuxième couche déchargent les transactions à forte intensité de ressources sur leur chaîne de couches distincte, tout en continuant à utiliser la blockchain de première couche d’Ethereum ou de Bitcoin à des fins de sécurité.",
-  "layer-2-term": "Niveau 2",
+  "layer-2-term": "Couche de niveau 2",
   "layer-2-definition": "Les couches de niveau 2 sont d'autres réseaux construits sur le réseau principal d’Ethereum pour rendre les transactions plus rapides et moins chères. <a href=\"/layer-2/\">En savoir plus sur la couche de niveau 2</a>.",
   "library-term": "Bibliothèque",
   "library-definition": "Un type spécial de <a href=\"/glossary/#smart-contract\">contrat</a> qui n'a pas de fonctions payantes, pas de fonction de repli et pas de stockage de données. Il ne peut donc pas recevoir ou conserver de l'éther, ni stocker des données. Une bibliothèque sert de code précédemment déployé que d'autres contrats peuvent appeler pour des calculs en lecture seule. <a href=\"/developers/docs/smart-contracts/libraries/\">En savoir plus sur les bibliothèques de contrats intelligents</a>.",
@@ -223,9 +225,11 @@
   "liquidity-definition": "La liquidité est la rapidité et la facilité avec lesquelles un actif peut être converti en espèces ou en un autre actif. Les bourses décentralisées comme Uniswap ont plusieurs pools de liquidité où les détenteurs d’actifs peuvent déposer leurs actifs et où les traders peuvent les acheter et les vendre de manière décentralisée en échange de récompenses.",
   "liquidity-tokens-term": "Jetons de liquidité",
   "liquidity-tokens-definition": "Les jetons de liquidité (LST en anglais) sont des jetons numériques émis à l'intention des participants qui déposent des actifs dans un pool de liquidité, ce dernier étant un ensemble de fonds verrouillés dans un contrat intelligent et utilisés pour faciliter le trading sur un échange décentralisé (DEX). <br />Ces jetons représentent la part du participant dans le pool et peuvent être échangés ultérieurement contre le dépôt initial plus une partie des frais de trading générés par l’activité du pool. Les jetons de liquidité servent essentiellement de preuve de propriété ou de mise en jeu dans un pool de liquidité, permettant aux détenteurs de gagner des récompenses tout en fournissant la liquidité nécessaire pour que d’autres puissent négocier différentes paires de cryptomonnaies efficacement.",
+  "liquid-staking-tokens-term": "Jetons de mise en jeu liquide",
+  "liquid-staking-tokens-definition": "Un jeton dérivé représente la propriété de la cryptomonnaie verrouillée qu’un utilisateur met en jeu. Lorsqu’un actif est mis en jeu, certaines plateformes permettent la création de jetons de mise en jeu liquide (LST), qui représentent une part équivalente des jetons verrouillés. Ces LST peuvent ensuite être échangés, vendus ou utilisés dans d’autres protocoles DeFi, améliorant ainsi l’efficacité du capital pour l’utilisateur en lui donnant accès à la liquidité de ses fonds, même si ses actifs originaux restent mis en jeu.",
   "lmd-ghost-term": "LMD-GHOST",
   "lmd-ghost-definition": "L'<a href=\"/glossary/#fork-choice-algorithm\">algorithme de choix de fourche</a> utilisé par les clients de consensus d'Ethereum pour identifier la tête de la chaîne. LMD-GHOST est un acronyme signifiant \"Latest Message Driven Greediest Heaviest Observed SubTree\", ce qui signifie que la tête de la chaîne est le bloc qui a accumulé le plus grand nombre d'<a href=\"/glossary/#attestation\">attestations</a> dans son histoire.",
-  "mainnet-term": "Réseau principal",
+  "mainnet-term": "réseau principal",
   "mainnet-definition": "Appelé « mainnet » en anglais (pour « main network »), il s'agit de la <a href=\"/glossary/#blockchain\">blockchain</a> principale du réseau public Ethereum.",
   "max-fee-per-gas-term": "Frais maximum par Gaz",
   "max-fee-per-gas-definition": "Les frais maximaux sont le montant maximal absolu qu’un utilisateur est prêt à payer par unité de gaz (<a href=\"/glossary/#gwei\">gwei</a>) pour qu’une transaction soit incluse dans un bloc.",
@@ -239,7 +243,7 @@
   "message-call-definition": "La transmission d'un <a href=\"/glossary/#message\">message</a> d'un compte à un autre. Si le compte de destination est associé au code <a href=\"/glossary/#evm\">EVM</a>, la VM sera démarrée avec l'état de cet objet et le message sera traité.",
   "mev-term": "Valeur Extractible Maximale (MEV)",
   "mev-definition": "La valeur maximale qui peut être extraite de la production de blocs, en plus de la récompense standard du bloc et des frais de gaz, en incluant, excluant ou modifiant l'ordre des transactions dans un bloc. <a href=\"/developers/docs/mev/\">En savoir plus sur la valeur extractible maximale (MEV)</a>.",
-  "mining-term": "Minage",
+  "mining-term": "Le minage",
   "mining-definition": "Le processus de hachage répété d'un en-tête de bloc tout en incrémentant un <a href=\"/glossary/#nonce\">nonce</a> jusqu'à ce que le résultat contienne un nombre arbitraire de zéros binaires de tête. C'est le processus par lequel de nouveaux <a href=\"/glossary/#block\">blocs</a> sont ajoutés à une blockchain à preuve de travail. C'est ainsi qu'Ethereum était sécurisé avant de passer à la preuve d'enjeu.",
   "miner-term": "Mineur",
   "miner-definition": "Un <a href=\"/glossary/#node\">nœud</a> du réseau qui trouve une <a href=\"/glossary/#pow\">preuve de travail</a> valide pour les nouveaux blocs, par un hachage répété (voir <a href=\"/glossary/#ethash\">Ethash</a>). Les mineurs ne font plus partie d'Ethereum - ils ont été remplacés par des validateurs lorsque Ethereum est passé à la preuve d'enjeu.",
@@ -247,7 +251,7 @@
   "mint-definition": "La frappe de monnaie est le processus qui consiste à créer de nouveaux jetons et à les mettre en circulation pour qu'ils puissent être utilisés. Il s'agit d'un mécanisme décentralisé permettant de créer un nouveau jeton sans l'intervention d'une autorité centrale.",
   "multisig-term": "Multi-signatures",
   "multisig-definition": "Multisig (signature multiple) désigne un portefeuille ou un compte numérique qui nécessite plusieurs signatures ou approbations pour exécuter des transactions, ce qui améliore la sécurité. <br />Cela ajoute une sécurité supplémentaire par rapport aux comptes à signature unique traditionnels où l’approbation d’une seule personne est nécessaire.",
-  "network-term": "Réseau",
+  "network-term": "réseau",
   "network-definition": "En référence au réseau Ethereum, un réseau pair-à-pair qui propage les transactions et les blocs à chaque nœud Ethereum (participant au réseau). <a href=\"/developers/docs/networks/\">En savoir plus sur les réseaux</a>.",
   "network-hashrate-term": "Puissance de hachage du réseau",
   "network-hashrate-definition": "Le hashrate collectif produit par l'ensemble d'un réseau de minage. Le minage sur Ethereum a été désactivé lorsque Ethereum est passé à la preuve d'enjeu.",
@@ -257,12 +261,12 @@
   "node-definition": "Un client logiciel qui participe au réseau. <a href=\"/developers/docs/nodes-and-clients/\">En savoir plus sur les nœuds et les clients</a>.",
   "nonce-term": "Nonce",
   "nonce-definition": "En cryptographie, une valeur qui ne peut être utilisée qu'une seule fois. Un nonce de compte est un compteur de transactions dans chaque compte, qui est utilisé pour empêcher les attaques par rejeu.",
-  "off-chain-term": "Hors-chaine",
-  "off-chain-definition": "Hors-chaine se réfère à toute transaction ou donnée qui existe en dehors de la blockchain. Parce que la validation de chaque transaction sur la chaîne peut être coûteuse et inefficace, des outils tiers tels que des oracles qui gèrent les données de tarification, ou des solutions de couche 2 qui exécutent un débit de transactions plus élevé, gèrent une grande partie du travail de traitement hors chaîne et présentera des renseignements sur la chaîne à des intervalles moins fréquents.",
+  "offchain-term": "Hors chaîne",
+  "offchain-definition": "Hors-chaine se réfère à toute transaction ou donnée qui existe en dehors de la blockchain. Parce que la validation de chaque transaction sur la chaîne peut être coûteuse et inefficace, des outils tiers tels que des oracles qui gèrent les données de tarification, ou des solutions de couche 2 qui exécutent un débit de transactions plus élevé, gèrent une grande partie du travail de traitement hors chaîne et présentera des renseignements sur la chaîne à des intervalles moins fréquents.",
   "ommer-term": "Bloc oncle (ommer)",
   "ommer-definition": "Lorsqu'un <a href=\"/glossary/#miner\">mineur</a> en preuve de travail trouve un <a href=\"/glossary/#block\">bloc</a> valide, un autre mineur peut avoir publié un bloc concurrent qui est ajouté en premier à l'extrémité de la blockchain. Ce bloc valide, mais périmé, peut être inclus par des blocs plus récents en tant qu'<em>ommers</em> et recevoir une récompense de bloc partielle. Le terme « ommer » est le terme de genre neutre préféré pour désigner le frère ou la sœur d'un bloc parent, mais il est parfois également appelé « oncle ». Cela était frequent pour Ethereum lorsqu'il s'agissait d'un réseau basé sur la <a href=\"/glossary/#pow\">preuve de travail</a>. Maintenant qu'Ethereum utilise la <a href=\"/glossary/#pos\">preuve d'enjeu</a>, un seul proposeur de bloc est sélectionné par créneau.",
-  "on-chain-term": "Sur la chaîne",
-  "on-chain-definition": "Fait référence aux actions ou transactions qui se produisent sur la blockchain et sont accessibles au public. <br /><br />Voyez cela comme le fait d'écrire quelque chose dans un carnet partagé que tout le monde peut voir et vérifier, en vous assurant que tout ce qui est écrit (comme envoyer de l’argent numérique ou conclure un contrat) est permanent et ne peut pas être modifié ou effacé.",
+  "onchain-term": "Sur la chaîne",
+  "onchain-definition": "Fait référence aux actions ou transactions qui se produisent sur la blockchain et sont accessibles au public. <br /><br />Voyez cela comme le fait d'écrire quelque chose dans un grand carnet partagé que tout le monde peut voir et vérifier, en vous assurant que tout ce qui est écrit (comme envoyer de l’argent numérique ou conclure un contrat) est permanent et ne peut pas être modifié ou effacé.",
   "optimistic-rollup-term": "Rollup optimisé",
   "optimistic-rollup-definition": "Le rollup optimiste est une solution de couche 2 qui accélère les transactions sur Ethereum, en supposant qu’elles soient valides par défaut, sauf si elles sont contestées. <a href=\"/developers/docs/scaling/optimistic-rollups/\">En savoir plus sur les rollups optimistes</a>.",
   "oracle-term": "Oracle",
@@ -270,7 +274,7 @@
   "peer-term": "Pair",
   "peer-definition": "Ordinateurs connectés exécutant le logiciel client Ethereum qui ont des copies identiques de la <a href=\"/glossary/#blockchain\">blockchain</a>.",
   "peer-to-peer-network-term": "Réseaux Pair-à-Pair",
-  "peer-to-peer-network-definition": "Un réseau d’ordinateurs (<a href=\"/glossary/#peer\">homologues</a>) capables collectivement d’exécuter des fonctionnalités sans avoir besoin de services centralisés basés sur serveur. <br />Cette configuration est souvent utilisée pour le partage de fichiers (comme Bit torrent), d’informations ou de devises numériques, permettant des échanges plus directs et potentiellement plus efficaces entre les utilisateurs.",
+  "peer-to-peer-network-definition": "Un réseau d'ordinateurs (<a href=\"/glossary/#peer\">pairs</a>) qui sont collectivement capables d'exécuter des fonctionnalités sans avoir besoin de services centralisés basés sur des serveurs.<br />Cette configuration est souvent utilisée pour le partage de fichiers (p. ex., BitTorrent), d'informations ou de monnaies numériques, permettant des échanges plus directs et potentiellement plus efficaces entre les utilisateurs.",
   "permissionless-term": "Sans autorisation",
   "permissionless-definition": "\"Sans permission\" signifie que n'importe qui peut rejoindre et utiliser un système comme Ethereum. Sa participation est ouverte à tous et ne nécessite aucune approbation.",
   "plasma-term": "Plasma",
@@ -296,14 +300,14 @@
   "receipt-term": "Reçu",
   "receipt-definition": "Données renvoyées par un client Ethereum pour représenter le résultat d'une <a href=\"/glossary/#transaction\">transaction</a> particulière, y compris un <a href=\"/glossary/#hash\">hachage numérique</a> de la transaction, son numéro de <a href=\"/glossary/#block\">bloc</a>, la quantité de <a href=\"/glossary/#gas\">gaz</a> utilisée et, en cas de déploiement d'un <a href=\"/glossary/#smart-contract\">contrat intelligent</a>, l'<a href=\"/glossary/#address\">adresse</a> du contrat.",
   "recovery-phrase-term": "Phrase de départ/phrase de récupération",
-  "recovery-phrase-definition": "Une liste de mots qui vous sont donnés lorsque vous créez un portefeuille numérique. Elle agit comme un mot de passe qui peut vous aider à revenir dans votre portefeuille si vous en perdez l’accès, vous garantissant ainsi de ne pas perdre votre argent ou vos jetons numériques.",
+  "recovery-phrase-definition": "Une liste de mots qui vous est donnée lorsque vous créez un portefeuille numérique. Elle agit comme un mot de passe qui peut vous aider à récupérer l'accès à votre portefeuille si vous le perdez, vous assurant de ne pas perdre votre argent numérique ou vos jetons.",
   "re-entrancy-attack-term": "Attaque par réentrance",
-  "re-entrancy-attack-definition": "Une attaque qui consiste en un contrat d’attaquant appelant une fonction de contrat de victime de telle sorte que lors de l’exécution, la victime appelle à nouveau le contrat d’attaquant, de manière récursive. Cela peut entraîner, par exemple, le vol de fonds en omettant les parties du contrat de la victime qui mettent à jour les soldes ou comptent les montants de retrait. < href=\"/developers/docs/smart-contracts/security/#reetrancy\">En savoir plus sur la réentrance</a>.",
+  "re-entrancy-attack-definition": "Attaque consistant pour un contrat de l'attaquant à appeler une fonction d'un contrat de la victime de telle sorte qu'au cours de l'exécution, la victime appelle à nouveau le contrat de l'attaquant, de manière récursive. Cela peut entraîner, par exemple, le vol de fonds en sautant les parties du contrat de la victime qui mettent à jour les soldes ou comptent les montants des retraits. <a href=\"/developers/docs/smart-contracts/security/#reentrancy\">En savoir plus sur la réentrance</a>.",
   "reward-term": "Récompense",
   "reward-definition": "Une quantité d'ether <a href=\"/developers/docs/consensus-mechanisms/pos/rewards-and-penalties\">attribuée aux validateurs</a> qui effectuent certaines fonctions, notamment proposer un bloc ou participer à un comité de synchronisation, dans chaque créneau.",
   "rlp-term": "Préfixe de longueur récursive (RLP)",
   "rlp-definition": "<a href=\"/developers/docs/data-structures-and-encoding\">Norme d'encodage</a> conçue par les développeurs Ethereum pour encoder et sérialiser des objets (structure de données) de complexité et de longueur arbitraires.",
-  "rollups-term": "Rollups",
+  "rollups-term": "rollups",
   "rollups-definition": "Un type de solution de mise à l'échelle de la <a href=\"/glossary/#layer-2\">couche 2</a> qui regroupe plusieurs transactions et les soumet à <a href=\"/glossary/#mainnet\">la chaîne principale Ethereum</a> en une seule transaction. Cela permet de réduire les coûts de <a href=\"/glossary/#gas\">gaz</a> et d'augmenter le débit des <a href=\"/glossary/#transaction\">transactions</a>. Il existe des rollups optimistes et à connaissance nulle qui utilisent différentes méthodes de sécurité pour offrir ces gains d'évolutivité. <a href=\"/developers/docs/scaling/#rollups\">En savoir plus sur les rollups</a>.",
   "rpc-term": "Appel de procédure distante (RPC)",
   "rpc-definition": "RPC permet à un ordinateur de demander des données ou des actions à un autre via un réseau, à la manière d'une télécommande demandant des informations.",
@@ -323,7 +327,7 @@
   "singleton-definition": "Terme de programmation informatique décrivant un objet dont il ne peut exister qu'une seule instance.",
   "slasher-term": "Exclure",
   "slasher-definition": "Un slasher est une entité qui analyse les attestations à la recherche d'infractions pouvant faire l'objet d'un slash. Les slashs sont diffusés sur le réseau et le prochain proposant de bloc ajoute la preuve au bloc. L'auteur de la proposition de bloc reçoit alors une récompense pour la suppression du validateur malveillant.",
-  "slot-term": "Créneau",
+  "slot-term": "créneau",
   "slot-definition": "Période de temps (12 secondes) pendant laquelle de nouveaux blocs peuvent être proposés par un <a href=\"/glossary/#validator\">validateur</a> dans le système de <a href=\"/glossary/#pos\">preuve d'enjeu</a>. Un slot peut être vide. 32 slots constituent une <a href=\"/glossary/#epoch\">époque</a>. <a href=\"/developers/docs/consensus-mechanisms/pos/#how-does-validation-work\">En savoir plus sur la preuve d'enjeu</a>.",
   "smart-contract-term": "Contrat intelligent",
   "smart-contract-definition": "Un contrat intelligent est un programme qui exécute automatiquement des accords sur une blockchain, comme un contrat numérique auto-exécutable. <a href=\"/smart-contracts/\">Introduction aux contrats intelligents</a>.",
@@ -331,13 +335,13 @@
   "snark-definition": "Abréviation de « succinct non-interactive argument of knowledge », un SNARK est un type de <a href=\"/glossary/#zk-proof\">preuve à connaissance nulle</a>. <a href=\"/developers/docs/scaling/zk-rollups/\">En savoir plus sur les rollups ZK</a>.",
   "soft-fork-term": "Fourche mineure",
   "soft-fork-definition": "Une divergence dans une <a href=\"/glossary/#blockchain\">blockchain</a> qui se produit lorsque les <a href=\"/glossary/#consensus-rules\">règles de consensus</a> changent. Contrairement à <a href=\"/glossary/#hard-fork\">un hard fork</a>, un soft fork est rétrocompatible ; les nœuds mis à niveau peuvent valider les blocs créés par des nœuds non mis à niveau tant qu'ils respectent les nouvelles règles de consensus.",
-  "solidity-term": "Solidity",
+  "solidity-term": "solidity",
   "solidity-definition": "Langage de programmation procédural (impératif) dont la syntaxe est similaire à JavaScript, C++ ou Java. Le langage le plus populaire et le plus fréquemment utilisé pour les <a href=\"/glossary/#smart-contract\">contrats intelligents</a> Ethereum. Créé par Gavin Wood. <a href=\"/developers/docs/smart-contracts/languages/#solidity\">En savoir plus sur Solidity</a>.",
   "solidity-inline-assembly-term": "Assemblage en ligne Solidity",
   "solidity-inline-assembly-definition": "Le langage d'assemblage <a href=\"/glossary/#evm\">EVM</a> dans un programme <a href=\"/glossary/#solidity\">Solidity</a>. La prise en charge de l'assemblage en ligne par Solidity facilite l'écriture de certaines opérations.",
   "stablecoin-term": "Stablecoin",
   "stablecoin-definition": "Un stablecoin est un type de cryptomonnaie conçu pour avoir une valeur stable, souvent indexée sur une devise ou une marchandise (comme le dollar américain), afin de minimiser la volatilité des prix. <a href=\"/stablecoins/\">En savoir plus sur les stablecoins</a>.",
-  "staking-term": "Staking",
+  "staking-term": "Mise en jeu",
   "staking-definition": "Le dépôt d'une quantité d'<a href=\"/glossary/#ether\">ether</a> (votre mise) pour devenir un validateur et sécuriser le <a href=\"/glossary/#network\">réseau</a>. Un validateur vérifie les <a href=\"/glossary/#transaction\">transactions</a> et propose des <a href=\"/glossary/#block\">blocs</a> sous un modèle de consensus de <a href=\"/glossary/#pos\">preuve d'enjeu</a>. Le staking vous offre une incitation économique à agir dans le meilleur intérêt du réseau. Vous recevrez des récompenses pour l'exécution de vos tâches de <a href=\"/glossary/#validator\">validateur</a>, mais vous perdrez des quantités variables d'ETH si vous ne le faites pas. <a href=\"/staking/\">En savoir plus sur le staking Ethereum</a>.",
   "staking-pool-term": "Pools de mise en jeu",
   "staking-pool-definition": "L'ETH combiné de plus d'un staker Ethereum, utilisé pour atteindre les 32 ETH requis pour activer un ensemble de clés de validation. Un opérateur de nœud utilise ces clés pour participer au consensus et les <a href=\"/glossary/#block-reward\">récompenses du bloc</a> sont réparties entre les stakers qui y contribuent. Les pools de staking ou la délégation de staking ne font pas partie du protocole Ethereum, mais de nombreuses solutions ont été élaborées par la communauté. <a href=\"/staking/pools/\">En savoir plus sur les pools de mise en jeu</a>.",
@@ -345,7 +349,7 @@
   "stark-definition": "Abréviation de « scalable transparent argument of knowledge », un STARK est un type de <a href=\"/glossary/#zk-proof\">preuve à connaissance nulle</a>. <a href=\"/developers/docs/scaling/zk-rollups/\">En savoir plus sur les rollups ZK</a>.",
   "state-term": "État",
   "state-definition": "Image instantanée de tous les soldes et métadonnées présents à un moment donné sur la blockchain, qui renvoie normalement à la condition d'un bloc particulier.",
-  "state-channels-term": "Canaux d'état",
+  "state-channels-term": "canaux d'état",
   "state-channels-definition": "Une solution de <a href=\"/glossary/#layer-2\">couche 2</a> où un canal est mis en place entre les participants, où ils peuvent effectuer des <a href=\"/glossary/#transaction\">transactions</a> librement et à moindre coût. Seule une <a href=\"/glossary/#transaction\">transaction</a> pour établir le canal et le fermer est envoyée au réseau principal. Cela permet un débit de transaction très élevé, mais nécessite de connaître le nombre de participants à l'avance et de bloquer les fonds. <a href=\"/developers/docs/scaling/state-channels/#state-channels\">En savoir plus sur les canaux d'État</a>.",
   "supermajority-term": "Supermajorité",
   "supermajority-definition": "La supermajorité est le terme utilisé pour désigner un montant dépassant les 2/3 (66 %) du nombre total d'Ether mis en jeu pour sécuriser Ethereum. Un vote à la supermajorité est nécessaire pour que les blocs soient <a href=\"/glossary/#finality\">finalisés</a> sur la chaîne phare.",
@@ -363,6 +367,8 @@
   "testnet-definition": "Aussi appelé « testnet », il s'agit d'un réseau utilisé pour simuler le comportement du réseau principal Ethereum.",
   "token-term": "Jeton",
   "token-definition": "Bien virtuel négociable défini dans les contrats intelligents sur la blockchain Ethereum.",
+  "token-factory-term": "Fabrique de jetons",
+  "token-factory-definition": "Une fabrique de jetons est un contrat intelligent qui facilite la création de jetons dans le respect d'une norme spécifique, telle que <a href=\"#erc-20\">ERC-20</a>, <a href=\"#erc-721\">ERC-721</a> ou <a href=\"#erc-1155\">ERC-1155</a>. Le contrat intelligent agit comme un modèle, permettant aux utilisateurs de déployer de nouveaux jetons avec des paramètres personnalisés tels que le nom, le symbole, l'offre et des fonctionnalités supplémentaires sans avoir à créer un nouveau contrat intelligent à partir de zéro.",
   "transaction-term": "Transaction",
   "transaction-definition": "Données engagées dans la blockchain Ethereum, signées par un <a href=\"/glossary/#account\">compte</a> d'origine, ciblant une <a href=\"/glossary/#address\">adresse</a> spécifique. La transaction contient des métadonnées telles que la <a href=\"/glossary/#gas-limit\">limite de gaz</a> pour cette transaction. <a href=\"/developers/docs/transactions/\">En savoir plus sur les transactions</a>.",
   "transaction-fee-term": "Frais de transaction",
@@ -378,9 +384,9 @@
   "validator-lifecycle-term": "Cycle de vie du validateur",
   "validator-lifecycle-definition": "La séquence d'états dans laquelle un validateur peut exister. Cela inclut : <br/><br/><ul><li>déposé : Au moins 32 ETH ont été déposés dans le <a href=\"/glossary/#deposit-contract\">contrat de dépôt</a> par le validateur</li><li>en attente : le validateur est dans la file d'attente d'activation en attendant d'être voté dans le réseau par les validateurs existants</li><li>actif : atteste et propose actuellement des blocs</li><li>puni : le validateur a mal agi et est en train d'être pénalisé</li><li>sortie : le validateur a été signalé pour quitter le réseau, soit volontairement, soit parce qu'il a été éjecté.</li></ul>",
   "validity-proof-term": "Preuve de validité",
-  "validity-proof-definition": "Un modèle de sécurité pour certaines solutions de <a href=\"/glossary/#layer-2\">couche 2</a> où, pour augmenter la vitesse, les transactions sont regroupées en lots et soumises à Ethereum en une seule transaction. Le calcul des transactions est effectué en hors chaîne, puis fourni à la chaîne principale avec une preuve de leur validité. Cette méthode permet d'augmenter le nombre de transactions possibles tout en maintenant la sécurité. Certains <a href=\"/glossary/#rollups\">rollups</a> utilisent des <a href=\"/glossary/#fraud-proof\">preuves de fraude</a>. <a href=\"/developers/docs/scaling/zk-rollups/\">En savoir plus sur les rollups à connaissance nulle</a>.",
-  "validium-term": "Validium",
-  "validium-definition": "Une solution hors chaîne qui utilise des <a href=\"/glossary/#validity-proof\">preuves de validité</a> pour améliorer le débit des transactions. Contrairement aux <a href=\"/glossary/#zk-rollup\">rollups ZK</a>, les données de validium ne sont pas stockées sur la couche 1 du réseau principal. <a href=\"/developers/docs/scaling/validium/\">En savoir plus sur le validium</a>.",
+  "validity-proof-definition": "Un modèle de sécurité pour certaines solutions de <a href=\"/glossary/#layer-2\">couche 2</a> où, pour augmenter la vitesse, les transactions sont regroupées en lots et soumises à Ethereum en une seule transaction. Le calcul des transactions est effectué hors chaîne, puis fourni à la chaîne principale avec une preuve de leur validité. Cette méthode permet d'augmenter le nombre de transactions possibles tout en maintenant la sécurité. Certains <a href=\"/glossary/#rollups\">rollups</a> utilisent des <a href=\"/glossary/#fraud-proof\">preuves de fraude</a>. <a href=\"/developers/docs/scaling/zk-rollups/\">En savoir plus sur les rollups ZK</a>.",
+  "validium-term": "Validité",
+  "validium-definition": "Une solution hors chaîne qui utilise des <a href=\"/glossary/#validity-proof\">preuves de validité</a> pour améliorer le débit des transactions. Contrairement aux <a href=\"/glossary/#zk-rollup\">rollups Zk</a>, les données de validium ne sont pas stockées sur la couche 1 du réseau principal. <a href=\"/developers/docs/scaling/validium/\">En savoir plus sur le validium</a>.",
   "vyper-term": "Vyper",
   "vyper-definition": "Un langage de programmation de haut niveau avec une syntaxe semblable à celle de Python. Destiné à se rapprocher d'un langage fonctionnel pur. Créé par Vitalik Buterin. <a href=\"/developers/docs/smart-contracts/languages/#vyper\">En savoir plus sur Vyper</a>.",
   "wallet-term": "Portefeuille",
@@ -391,6 +397,8 @@
   "web3-definition": "Le Web3 est le nouvel internet basé sur la blockchain, où les utilisateurs contrôlent leurs données et transactions, plutôt que les entreprises. Il n'est pas nécessaire de partager des informations personnelles. <a href=\"/web3/\">En savoir plus sur le Web3</a>.",
   "wei-term": "Wei",
   "wei-definition": "La plus petite dénomination d'ether. 10<sup>18</sup> wei = 1 ether.",
+  "wrapped-token-term": "Jeton symbolique",
+  "wrapped-token-definition": "Un jeton basé sur la blockchain qui représente une autre cryptomonnaie ou un actif sur un réseau différent. Par exemple, <a href=\"/wrapped-eth/#intro-to-weth\">Wrapped Ether (WETH)</a> représente l’Ether (ETH) dans un format conforme au standard de jeton <a href=\"/glossary/#erc-20\">ERC-20</a> d’Ethereum. L’actif original est verrouillé de manière sécurisée par un <a href=\"/glossary/#smart-contract\">contrat intelligent</a>, et un jeton équivalent est émis. Ce mécanisme permet l’interopérabilité au sein des blockchains et entre elles, permettant à des actifs comme l’ETH d’être utilisés de manière fluide dans des applications décentralisées tout en conservant leur valeur.",
   "zero-address-term": "Adresse zéro",
   "zero-address-definition": "Une adresse Ethereum, composée entièrement de zéros, qui est fréquemment utilisée comme adresse pour retirer les jetons de la circulation. Une distinction est faite entre les jetons officiellement retirés de l'index d'un contrat intelligent via la méthode burn() et ceux envoyés à cette adresse.",
   "zk-proof-term": "Preuve de connaissance zéro",
diff --git a/src/intl/fr/learn-quizzes.json b/src/intl/fr/learn-quizzes.json
index 49149a3c0b0..be86b27b109 100644
--- a/src/intl/fr/learn-quizzes.json
+++ b/src/intl/fr/learn-quizzes.json
@@ -64,13 +64,13 @@
   "what-is-ethereum-4-d-label": "Plus de dix fois",
   "what-is-ethereum-5-prompt": "Ethereum consomme plus d'électricité que :",
   "what-is-ethereum-5-a-label": "Extraction d'or",
-  "what-is-ethereum-5-a-explanation": "L'extraction d'or utilise environ 131 térawatt-heures par an. Ethereum consomme environ 0,0026 térawatt-heures par an.",
+  "what-is-ethereum-5-a-explanation": "L'extraction d'or utilise environ 131 térawattheures par an. Ethereum consomme environ 0,0026 térawattheure par an.",
   "what-is-ethereum-5-b-label": "Netflix",
-  "what-is-ethereum-5-b-explanation": "Netflix utilise environ 0,451 térawatt-heures par an, tandis qu'Ethereum consomme environ 0,0026 térawatt-heures par an.",
+  "what-is-ethereum-5-b-explanation": "Netflix utilise environ 0,451 térawattheure par an. Ethereum consomme environ 0,0026 térawattheure par an.",
   "what-is-ethereum-5-c-label": "PayPal",
-  "what-is-ethereum-5-c-explanation": "PayPal utilise environ 0,26 térawatt-heures par an, tandis qu'Ethereum consomme environ 0,0026 térawatt-heures par an.",
+  "what-is-ethereum-5-c-explanation": "PayPal utilise environ 0,26 térawattheure par an. Ethereum consomme environ 0,0026 térawattheure par an.",
   "what-is-ethereum-5-d-label": "Aucune de ces réponses",
-  "what-is-ethereum-5-d-explanation": "Ethereum consomme environ 0,0026 térawatt-heures par an, soit moins que l'exploitation aurifère (~131 TWh/an), Netflix (~0,451 TWh/an) et PayPal (~0,26 TWh/an).",
+  "what-is-ethereum-5-d-explanation": "Ethereum consomme environ 0,0026 térawattheures par an. Moins que l'extraction aurifère (~131 TWh/an), Netflix (~0,451 TWh/an) et PayPal (~0,26 TWh/an).",
   "what-is-ether-1-prompt": "L'Ether est également connu sous le nom de :",
   "what-is-ether-1-a-label": "ETC",
   "what-is-ether-1-a-explanation": "ETC est le symbole d'Ethereum Classic.",
@@ -259,7 +259,7 @@
   "rollups-1-d-label": "Décentraliser Ethereum",
   "rollups-1-d-explanation": "Le but principal des rollups et autres solutions de seconde couche est d'augmenter la capacité d'Ethereum.",
   "rollups-2-prompt": "Pour évoluer, la plupart des réseaux alternatifs de couche 1 ont principalement sacrifié :",
-  "rollups-2-a-label": "Sécurité",
+  "rollups-2-a-label": "sécurité",
   "rollups-2-a-explanation": "La plupart des réseaux alternatifs de couche 1 sacrifient la sécurité et quelque chose d'autre pour évoluer.",
   "rollups-2-b-label": "Décentralisation",
   "rollups-2-b-explanation": "La plupart des réseaux alternatifs de couche 1 sacrifient la décentralisation et quelque chose d'autre pour évoluer.",
@@ -324,8 +324,53 @@
   "merge-5-b-explanation": "Avant d'être rebaptisée couche de consensus, elle s'appelait à l'origine « Eth2 ».",
   "merge-5-c-label": "Eth1",
   "merge-5-c-explanation": "Eth1 était le nom donné à l'origine à la couche d'exécution, et non à la couche de consensus.",
-  "merge-5-d-label": "Staking",
+  "merge-5-d-label": "Mise en jeu",
   "merge-5-d-explanation": "La mise en jeu consiste à déposer de l'ETH dans un contrat intelligent pour aider à sécuriser la chaîne.",
+  "gas-1-prompt": "Que sont les frais de gaz ?",
+  "gas-1-a-label": "Un frais associé aux transactions et aux opérations des contrats intelligents",
+  "gas-1-a-explanation": "Partiellement correct : les frais de gaz représentent le coût des transactions ainsi que des opérations effectuées par les contrats intelligents.",
+  "gas-1-b-label": "La quantité de gas utilisée pour exécuter une opération, multipliée par le coût par unité de gas",
+  "gas-1-b-explanation": "Partiellement correct. Bien que ce soit vrai, ce n’est pas la meilleure réponse parmi les choix proposés.",
+  "gas-1-c-label": "Un paiement incluant des frais de priorité afin d’accélérer potentiellement le traitement de la transaction",
+  "gas-1-c-explanation": "C’est partiellement correct : le coût total en gaz comprend des frais de base et des frais de priorité, ces derniers pouvant influencer la rapidité de traitement de la transaction",
+  "gas-1-d-label": "Toutes ces réponses",
+  "gas-1-d-explanation": "Les frais de gaz englobent tous ces aspects : ils rémunèrent la puissance de calcul, s’appliquent aussi bien aux transactions qu’aux contrats intelligents, et peuvent inclure des frais de priorité pour une inclusion plus rapide.",
+  "gas-2-prompt": "Quelle est, parmi les options suivantes, la stratégie la moins efficace pour réduire le coût du gaz ?",
+  "gas-2-a-label": "Exécuter des transactions pendant les périodes de faible congestion",
+  "gas-2-a-explanation": "Programmer ses transactions en dehors des heures de pointe peut réduire les frais de gaz.",
+  "gas-2-b-label": "Attendre que les prix du gaz baissent",
+  "gas-2-b-explanation": "Attendre une baisse des prix du gaz est une stratégie valable, car les frais fluctuent en fonction de la congestion du réseau.",
+  "gas-2-c-label": "Utiliser des chaînes de seconde couche pour des frais réduits",
+  "gas-2-c-explanation": "Les solutions de seconde couche réduisent les frais et constituent un moyen efficace d’économiser sur le gaz.",
+  "gas-2-d-label": "Utiliser une logique de contrat intelligent complexe qui augmente les besoins en calcul",
+  "gas-2-d-explanation": "Une logique complexe de contrat intelligent augmente les frais de gaz en exigeant davantage de calcul. Une conception efficace minimise les étapes, le stockage et les opérations redondantes afin de réduire les coûts.",
+  "gas-3-prompt": "Qu’est-ce qui provoque des frais de gaz élevés ?",
+  "gas-3-a-label": "Calcul réseau dépassant un seuil spécifique",
+  "gas-3-a-explanation": "Lorsque la puissance de calcul sur Ethereum dépasse un certain seuil, les frais de gaz augmentent, en particulier lors de périodes d’activité intense comme les lancements de dApps ou de collections NFT.",
+  "gas-3-b-label": "Les validateurs augmentant manuellement les frais de base",
+  "gas-3-b-explanation": "Les validateurs ne définissent pas manuellement les frais de base ; ceux-ci sont ajustés par le protocole en fonction de la demande observée dans le bloc précédent.",
+  "gas-3-c-label": "Contrats intelligents bien écrits et optimisés",
+  "gas-3-c-explanation": "Une logique de contrat intelligent bien conçue, comme une utilisation efficace du stockage et des boucles, peut entraîner une consommation de gaz réduite.",
+  "gas-3-d-label": "Un manque d’ETH disponible sur le réseau",
+  "gas-3-d-explanation": "Les frais de gaz ne sont pas influencés par la quantité d’ETH disponible sur le réseau.",
+  "gas-4-prompt": "Comment les frais de gaz contribuent-ils à la sécurité d’Ethereum ?",
+  "gas-4-a-label": "En incitant les validateurs à agir de manière honnête",
+  "gas-4-a-explanation": "Les validateurs sont rémunérés de plusieurs façons, mais les frais de gaz servent principalement à décourager le spam et l’utilisation excessive des ressources.",
+  "gas-4-b-label": "En décourageant le spam et les activités malveillantes par des coûts financiers",
+  "gas-4-b-explanation": "Les frais de gaz rendent les activités de spam ou malveillantes coûteuses, ce qui empêche les abus et contribue à maintenir la stabilité du réseau.",
+  "gas-4-c-label": "En s’assurant que les transactions sont traitées par ordre de priorité",
+  "gas-4-c-explanation": "La priorité peut être déterminée par le pourboire, et non par les frais de gaz eux-mêmes.",
+  "gas-4-d-label": "En augmentant la quantité totale d’ETH en circulation",
+  "gas-4-d-explanation": "Les frais de base (composante du coût total en gaz) est brûlée, ce qui réduit la quantité d’ETH en circulation au lieu de l’augmenter",
+  "gas-5-prompt": "Comment sont calculées les frais de gaz ?",
+  "gas-5-a-label": "Prix du gaz × taille de la transaction",
+  "gas-5-a-explanation": "Les frais de gaz sont basés sur la puissance de calcul requise, et non sur la taille de la transaction.",
+  "gas-5-b-label": "Unités de gaz utilisées × ( frais de base + frais de priorité)",
+  "gas-5-b-explanation": "Les frais de gaz sont déterminés selon la formule : unités de gaz utilisées × (frais de base + frais de priorité).",
+  "gas-5-c-label": "Taille du bloc × plafond du pourboire au validateur",
+  "gas-5-c-explanation": "La taille du bloc n’entre pas directement en compte dans cette formule.",
+  "gas-5-d-label": "Frais de base + frais de priorité + pourboire",
+  "gas-5-d-explanation": "Les frais de base et les frais de priorité font partie de la formule ; le pourboire correspond aux frais de priorité.",
   "daos-1-prompt": "Qu'est-ce qui est vrai à propos des DAO ?",
   "daos-1-a-label": "Les DAO sont collectivement possédées via des jetons de gouvernance",
   "daos-1-a-explanation": "Les DAO sont collectivement possédées, mais ce n'est pas la seule affirmation correcte.",
@@ -384,7 +429,7 @@
   "staking-solo-2-a-label": "Aucune incidence sur les récompenses",
   "staking-solo-2-a-explanation": "Des pénalités sont infligées lorsqu'un validateur n'est pas disponible pour attester de l'état de la chaîne pour une époque donnée. Le montant de ces pénalités est d'environ 75 % de ce qu'aurait été la récompense pour une attestation correcte. Les récompenses reprennent lorsque le validateur se reconnecte, et AUCUN slashing n'a lieu.",
   "staking-solo-2-b-label": "Les pénalités d'inactivité ne sont encourues que pendant l'indisponibilité",
-  "staking-solo-2-b-explanation": "Pendant son absence, un validateur subira de petites pénalités d'inactivité, environ égales à 75 % de ce que la récompense aurait été pour une attestation correcte. Dans des cas rares ou extrêmes où le réseau n'est pas en cours de finalisation (c'est-à-dire lorsque plus d'un tiers du réseau est également hors ligne), ces pénalités sont nettement plus importantes. Les récompenses reprennent lorsque le validateur revient en ligne, et aucun slashing n'a lieu.",
+  "staking-solo-2-b-explanation": "Pendant son indisponibilité, un validateur subira de petites pénalités d'inactivité, équivalentes à environ 75 % de ce qu'aurait été la récompense pour une attestation en bonne et due forme. Dans des cas rares ou extrêmes où le réseau n'est pas finalisé (c'est-à-dire que plus de 1/3 du réseau est également hors ligne), ces pénalités sont nettement plus importantes. Les récompenses reprennent lorsque le validateur revient en ligne et aucun slashing n'a lieu.",
   "staking-solo-2-c-label": "Slashing immédiat et suppression du réseau",
   "staking-solo-2-c-explanation": "Il s'agit d'une idée fausse courante, mais le fait de passer hors ligne ne conduit PAS au slashing ! Le slashing est un type spécifique de pénalité pour une infraction plus grave, avec des pénalités plus importantes et entraîne également le retrait de l'ensemble des validateurs.",
   "staking-solo-2-d-label": "Il y a un délai d'une semaine avant le slashing et l'expulsion",
@@ -613,5 +658,41 @@
   "defi-5-c-label": "Bitcoin",
   "defi-5-c-explanation": "C'est incorrect. Bitcoin est un réseau simple pour stocker de la valeur, pas pour exécuter des programmes avancés. La finance décentralisée nécessite un système plus flexible, comme Ethereum, qui peut exécuter des programmes complexes pour gérer automatiquement les prêts et les échanges.",
   "defi-5-d-label": "Institutions financières traditionnelles",
-  "defi-5-d-explanation": "C'est incorrect. Les applications DeFi n'ont pas besoin des institutions financières traditionnelles. Elles utilisent des programmes sur la blockchain appelés contrats intelligents pour gérer les transactions automatiquement."
+  "defi-5-d-explanation": "C'est incorrect. Les applications DeFi n'ont pas besoin des institutions financières traditionnelles. Elles utilisent des programmes sur la blockchain appelés contrats intelligents pour gérer les transactions automatiquement.",
+  "smart-contracts-1-prompt": "Comment les contrats intelligents sont-ils caractérisés ?",
+  "smart-contracts-1-a-label": "Les contrats intelligents sont comme des contrats légaux, mais stockés numériquement sur la blockchain pour sauvegarder le contenu en toute sécurité.",
+  "smart-contracts-1-a-explanation": "Les contrats intelligents utilisent une logique similaire à celle des contrats traditionnels, mais n'ont autrement que peu de choses en commun.",
+  "smart-contracts-1-b-label": "Liés à des systèmes d’IA autonomes qui exécutent des transactions",
+  "smart-contracts-1-b-explanation": "Les contrats intelligents exécutent les transactions de manière prévisible selon une logique « si ceci, alors cela » prescrite dans le code — ils n’utilisent pas d’IA",
+  "smart-contracts-1-c-label": "Des programmes sur la blockchain suivant une logique « si ceci, alors cela », garantis d’exécuter selon leurs propres règles",
+  "smart-contracts-1-c-explanation": "Un contrat intelligent est un compte Ethereum déployé avec un code immuable qui détermine sa fonctionnalité.",
+  "smart-contracts-1-d-label": "Ce sont les règles derrière la blockchain Ethereum, développées en collaboration avec des avocats pour garantir la conformité légale.",
+  "smart-contracts-1-d-explanation": "Les contrats intelligents sont des morceaux de code qui peuvent être créés par des développeurs et déployés sur une blockchain.",
+  "smart-contracts-2-prompt": "Quelle est la métaphore qui caractérise le plus précisément le fonctionnement des contrats intelligents ?",
+  "smart-contracts-2-a-label": "Une banque",
+  "smart-contracts-2-a-explanation": "Les banques nécessitent une exécution manuelle et sont structurées comme des entités hiérarchiques, tandis que les contrats intelligents sont exécutés de manière prévisible par des ordinateurs selon des règles immuables.",
+  "smart-contracts-2-b-label": "Distributeur automatique numérique",
+  "smart-contracts-2-b-explanation": "Le distributeur automatique ne délivrera votre produit désiré qu'une fois que toutes les conditions seront remplies : des entrées spécifiques garantissent des sorties déterministes. Cela est similaire à la logique des contrats intelligents.",
+  "smart-contracts-2-c-label": "Une calculatrice",
+  "smart-contracts-2-c-explanation": "Le code des contrats intelligents peut être utilisé pour des calculs, mais ne s'y limite pas. En réalité, les contrats intelligents sont des programmes basés sur la blockchain qui suivent une logique du type « si ceci, alors cela ».",
+  "smart-contracts-2-d-label": "Un site web",
+  "smart-contracts-2-d-explanation": "Un site web est le front-end qui capte les instructions de l’utilisateur. Un contrat intelligent est la logique backend où ces instructions sont exécutées, et le résultat peut être retourné.",
+  "smart-contracts-3-prompt": "Laquelle N’EST PAS une caractéristique principale des contrats intelligents ?",
+  "smart-contracts-3-a-label": "Exécution déterministe",
+  "smart-contracts-3-a-explanation": "Le principal avantage d’un contrat intelligent est qu’il exécute de manière déterministe un code sans ambiguïté, sans interprétation humaine ni biais.",
+  "smart-contracts-3-b-label": "Enregistrement public",
+  "smart-contracts-3-b-explanation": "Avec les contrats intelligents sur une blockchain publique, n’importe qui peut suivre instantanément les transferts d’actifs et autres informations associées.",
+  "smart-contracts-3-c-label": "Protection de la vie privée",
+  "smart-contracts-3-c-explanation": "Comme les blockchains sont des réseaux pseudonymes, les transactions sont liées publiquement à une adresse cryptographique unique, et non à une identité.",
+  "smart-contracts-3-d-label": "Capacité à changer",
+  "smart-contracts-3-d-explanation": "Un contrat intelligent ne peut pas être modifié une fois créé — son exécution est garantie selon les règles définies par son code.",
+  "smart-contracts-4-prompt": "Laquelle N’EST PAS une application des contrats intelligents ?",
+  "smart-contracts-4-a-label": "Stablecoins",
+  "smart-contracts-4-a-explanation": "Les stablecoins sont des objets token définis et suivis à l’aide de contrats intelligents.",
+  "smart-contracts-4-b-label": "Modifications du protocole\n",
+  "smart-contracts-4-b-explanation": "Bien que les modifications de protocole puissent parfois utiliser des contrats intelligents, leur création et définition sont proposées via des forums en ligne transparents et mises en œuvre dans les logiciels clients.",
+  "smart-contracts-4-c-label": "Jetons non fongibles (NFTs)",
+  "smart-contracts-4-c-explanation": "Les contrats intelligents sont utilisés pour définir une large gamme de NFT, allant de l’art numérique aux certificats de propriété d’actifs.",
+  "smart-contracts-4-d-label": "Échange de devises ouvert",
+  "smart-contracts-4-d-explanation": "Les échanges décentralisés (DEX) sont construits à l’aide de contrats intelligents pour fonctionner sans contrôle centralisé."
 }
diff --git a/src/intl/fr/page-10-year-anniversary.json b/src/intl/fr/page-10-year-anniversary.json
new file mode 100644
index 00000000000..f0bf2ee7953
--- /dev/null
+++ b/src/intl/fr/page-10-year-anniversary.json
@@ -0,0 +1,131 @@
+{
+  "page-10-year-anniversary-meta-title": "Anniversaire des 10 ans",
+  "page-10-year-anniversary-meta-description": "Célébrons 10 ans de résistance à la censure, de disponibilité à 100 %, de décentralisation, de construction communautaire, de croissance des développeurs, de collaboration mondiale, de valeurs cypherpunk, de hackathons, de finance sans autorisation, de neutralité crédible, de jardin infini, de diversité des clients et bien plus encore.",
+  "page-10-year-censorship-resistance": "résistance à la censure",
+  "page-10-year-uptime": "Disponibilité de 100 %",
+  "page-10-year-decentralization": "décentralisation",
+  "page-10-year-community-building": "développement communautaire",
+  "page-10-year-developer-growth": "croissance des développeurs",
+  "page-10-year-global-collaboration": "collaboration mondiale",
+  "page-10-year-cypherpunk-values": "valeurs cypherpunk",
+  "page-10-year-hackathons": "hackathons",
+  "page-10-year-permissionless-finance": "finance sans autorisation",
+  "page-10-year-credible-neutrality": "neutralité crédible",
+  "page-10-year-infinite-garden": "le jardin infini",
+  "page-10-year-client-diversity": "diversité des clients",
+  "page-10-year-celebrating": "Célébrons 10 ans de",
+  "page-10-year-hero-title": "Une décennie de transformation du monde, un bloc à la fois",
+  "page-10-year-hero-description": "Le 30 juillet 2015, la blockchain Ethereum est née. Dès l’instant où le bloc d'origine a été miné, elle a ouvert de nouvelles possibilités pour Internet, apportant des transformations majeures à la finance, à la propriété et à la programmabilité.",
+  "page-10-year-hero-tagline": "Dix ans d’existence, l’éternité devant nous.",
+  "page-10-year-join-party-title": "Rejoignez la fête",
+  "page-10-year-join-party-description": "Célébrez les 10 ans d’Ethereum avec la communauté mondiale. Trouvez un événement près de chez vous ou organisez votre propre célébration.",
+  "page-10-year-events-description-1": "Rejoignez des personnes du monde entier pour des conférences, des rencontres et des célébrations à l’occasion du dixième anniversaire d’Ethereum.",
+  "page-10-year-events-description-2": "Vous ne pouvez pas venir en personne ? Regardez notre diffusion en direct et suivez les actualités des événements dans le monde entier, pour que chacun puisse célébrer cette étape ensemble.",
+  "page-10-year-host-event-title": "Partagez votre événement",
+  "page-10-year-host-event-description": "Vous organisez un événement ? Saisissez les détails ci-dessous pour qu’il soit affiché sur la carte.",
+  "page-10-year-host-event-cta": "Partager l’événement",
+  "page-10-year-innovation-title": "10 ans de",
+  "page-10-year-innovation-subtitle": "Innovation",
+  "page-10-year-innovation-description-1": "Ethereum a transformé la blockchain en introduisant les contrats intelligents",
+  "page-10-year-innovation-description-2": "Avec Ethereum, les blockchains sont passées d’un registre numérique à une plateforme programmable où le code s’exécute automatiquement lorsque les conditions sont remplies.",
+  "page-10-year-innovation-description-3": "L’innovation d’Ethereum a permis l’émergence de nouvelles industries comme la DeFi, les NFT et les DAO. Elle a élargi l’usage de la blockchain au-delà de la monnaie numérique, pour en faire une plateforme qui a repensé notre façon de créer et d'échanger de la valeur.",
+  "page-10-year-adoption-title": "10 ans de",
+  "page-10-year-adoption-subtitle": "Adoption",
+  "page-10-year-adoption-description-1": "D’un livre blanc à plus de 24 millions de transactions quotidiennes dans l’écosystème Ethereum",
+  "page-10-year-adoption-description-2": "Ethereum est devenue une plateforme informatique mondiale alimentant des milliers d’applications utilisées quotidiennement par des millions de personnes. Elle transcende les secteurs et les frontières tout en continuant d'élargir ses domaines d'utilisation.",
+  "page-10-year-stories-title": "10 ans de",
+  "page-10-year-stories-subtitle": "Histoires",
+  "page-10-year-stories-description-1": "Un aperçu de l’utilisation d’Ethereum dans la vie quotidienne",
+  "page-10-year-stories-description-2": "Avec des millions de portefeuilles aux quatre coins du monde, les gens utilisent Ethereum de manière inspirante. Ces histoires réelles témoignent de la créativité, de la liberté et des liens rendus possibles grâce à Ethereum.",
+  "page-10-year-stories-cta": "Partagez votre histoire",
+  "page-10-year-ideas-title": "Avez-vous une idée sur la façon dont la communauté peut célébrer ?",
+  "page-10-year-ideas-description": "Onchain artefacts, un jeu-questionnaire mondial sur Ethereum : tout est possible ! Partagez votre idée ci-dessous.",
+  "page-10-year-ideas-cta": "Proposez votre idée",
+  "page-10-year-event-link": "Aller à l'évènement",
+  "page-10-year-countdown-expired": "Ethereum a 10 ans ! 🚀",
+  "page-10-year-countdown-day": "jour",
+  "page-10-year-countdown-days": "jours",
+  "page-10-year-countdown-hour": "heure",
+  "page-10-year-countdown-hours": "en heures",
+  "page-10-year-countdown-minute": "minute",
+  "page-10-year-countdown-minutes": "minutes",
+  "page-10-year-countdown-second": "seconde",
+  "page-10-year-countdown-seconds": "secondes",
+  "page-10-year-banner-header": "10 ans d'Ethereum",
+  "page-10-year-banner-launch-text": "Le 30 juillet 2015, à 15h44 UTC, le premier bloc de la blockchain Ethereum a vu le jour.",
+  "page-10-year-banner-tagline": "Dix ans derrière nous, l’infini devant ! 🚀",
+  "page-10-year-banner-cta": "Rejoignez la fête",
+  "page-10-year-stories-read-more": "En savoir plus",
+  "page-10-year-stories-show-original": "Afficher l'original",
+  "page-10-year-stories-show-english": "Voir l'anglais",
+  "page-10-year-stories-original-language": "Langue d'origine",
+  "page-10-year-stories-english-translation": "Traduction anglaise",
+  "page-10-year-stories-show-more": "Afficher plus",
+  "page-10-year-globe-go-to-event": "Aller à l'évènement",
+  "page-10-year-innovation-card-1-title": "Lancement d'Ethereum",
+  "page-10-year-innovation-card-1-date": "30 juillet 2015",
+  "page-10-year-innovation-card-1-description-1": "Le bloc d'origine d’Ethereum a été activé, lançant le réseau « Frontier ». Cette version minimaliste a offert aux développeurs leur première occasion de créer des applications décentralisées et d’expérimenter les contrats intelligents.",
+  "page-10-year-innovation-card-1-description-2": "La mission d’Ethereum : un internet ouvert où les utilisateurs contrôlent leurs données, où les applications fonctionnent sans intermédiaires, et où la valeur circule librement entre les personnes.",
+  "page-10-year-innovation-card-2-title": "DAI : Le stablecoin pionnier",
+  "page-10-year-innovation-card-2-date": "Décembre 2015",
+  "page-10-year-innovation-card-2-description-1": "Le premier stablecoin décentralisé a été lancé. Le DAI maintient un ancrage flexible au dollar américain grâce à des garanties en cryptomonnaies verrouillées dans des contrats intelligents.",
+  "page-10-year-innovation-card-2-description-2": "Contrairement aux stablecoins centralisés contrôlés par des entreprises, le DAI est régi par une organisation autonome décentralisée (DAO), ce qui le rend sans confiance et géré par la communauté.",
+  "page-10-year-innovation-card-3-title": "CryptoKitties et la frontière des NFT",
+  "page-10-year-innovation-card-3-date": "Novembre 2017",
+  "page-10-year-innovation-card-3-description-1": "CryptoKitties a donné vie à la propriété numérique. Ce jeu NFT précurseur a démontré comment la blockchain pouvait permettre de nouvelles formes d’expression, de collection et de culture en ligne.",
+  "page-10-year-innovation-card-3-description-2": "Cela a prouvé qu’Ethereum pouvait s’étendre au-delà de la finance vers le jeu, l’art et l’identité numérique, ouvrant des possibilités créatives entièrement nouvelles.",
+  "page-10-year-innovation-card-4-title": "L'été de la DeFi",
+  "page-10-year-innovation-card-4-date": "Juin 2020",
+  "page-10-year-innovation-card-4-description-1": "La croissance explosive de la DeFi a redéfini la manière dont le monde conçoit la finance. Les protocoles de prêt, d’échange et de génération de rendement ont connu un essor fulgurant, démontrant la puissance d’une infrastructure financière ouverte et composable.",
+  "page-10-year-innovation-card-4-description-2": "Cette période a amené des milliards de dollars en valeur sur la blockchain et a établi Ethereum comme le berceau de la finance décentralisée.",
+  "page-10-year-innovation-card-5-title": "Point sur la Fusion",
+  "page-10-year-innovation-card-5-date": "15 septembre 2022",
+  "page-10-year-innovation-card-5-description-1": "La plus grande transformation d’Ethereum à ce jour. Le réseau est passé en douceur d’un système de preuve de travail énergivore à un système de preuve d’enjeu. Avec des milliards de valeur en jeu sur Ethereum, ce changement a été comparé à un remplacement du moteur d’un avion en plein vol.",
+  "page-10-year-innovation-card-5-description-2": "La Fusion a réduit la consommation d’énergie d’Ethereum de 99,95 %, renforcé la sécurité du réseau et posé les bases des futures améliorations de mise à l’échelle.",
+  "page-10-year-innovation-card-6-title": "ETFs ETH Spot",
+  "page-10-year-innovation-card-6-date": "23 mai 2024",
+  "page-10-year-innovation-card-6-description-1": "Wall Street adopte Ethereum. Les ETF ETH au comptant ont été lancés, apportant du capital institutionnel et une légitimité réglementaire à la principale plateforme de contrats intelligents au monde.",
+  "page-10-year-innovation-card-6-description-2": "Cette approbation a marqué une acceptation plus large des actifs du monde réel tokenisés, avec de grandes institutions financières construisant désormais sur Ethereum pour intégrer en chaîne des actifs allant de l’immobilier aux obligations du Trésor.",
+  "page-10-year-adoption-card-1-title": "Une décennie de décentralisation",
+  "page-10-year-adoption-card-1-description": "Ce qui avait commencé comme un écosystème spécialisé s’étend désormais à <b>plus de 80 pays</b>, avec <b>870 000 validateurs</b>, <b>13 600 nœuds physiques</b> et <b>des millions d’utilisateurs</b> à travers les continents.",
+  "page-10-year-adoption-card-1-link-text": "Consultez les statistiques d’Ethereum",
+  "page-10-year-adoption-card-2-title": "10 ans, 16 mises à jour, 0 interruption",
+  "page-10-year-adoption-card-2-description": "Ethereum a maintenu une disponibilité parfaite tout en évoluant en permanence. La blockchain n’a jamais été mise hors ligne.",
+  "page-10-year-adoption-card-2-link-text": "Voir la feuille de route",
+  "page-10-year-adoption-card-3-title": "123 milliards de dollars de capitalisation boursière pour les stablecoins",
+  "page-10-year-adoption-card-3-description": "Au deuxième trimestre 2025, Ethereum L1 sécurise plus de 123 milliards de dollars en stablecoins, <a href=\"https://defillama.com/stablecoins/chains\">captant plus de 50 % du marché mondial des stablecoins.</a>",
+  "page-10-year-adoption-card-3-link-text": "En savoir plus sur les stablecoins",
+  "page-10-year-adoption-card-4-title": "75 milliards de dollars sécurisés dans la DeFi d’Ethereum",
+  "page-10-year-adoption-card-4-description": "Au deuxième trimestre 2025, <a href=\"https://defillama.com/chains\">Ethereum sécurise plus de 75 milliards de dollars en DeFi dans l’ensemble de son écosystème</a>.",
+  "page-10-year-adoption-card-4-link-text": "En savoir plus sur DeFi",
+  "page-10-year-adoption-card-5-title": "0,01 TWh par an",
+  "page-10-year-adoption-card-5-description": "Après La Fusion, la consommation d’énergie d’Ethereum a chuté de façon spectaculaire à seulement <a href=\"https://digiconomist.net/ethereum-energy-consumption\">0,01 TWh par an</a>, contre un pic de 93,95 TWh auparavant.",
+  "page-10-year-adoption-card-5-link-text": "En savoir plus sur la consommation énergétique d'Ethereum",
+  "page-10-year-adoption-card-6-title": "Plus de 250 TPS",
+  "page-10-year-adoption-card-6-description": "Le débit d’Ethereum a considérablement augmenté depuis son lancement, l’écosystème d’Ethereum traitant désormais plus de <a href=\"https://l2beat.com/scaling/activity\">250 transactions par seconde.</a>",
+  "page-10-year-adoption-card-6-link-text": "En savoir plus sur les secondes couches",
+  "page-10-year-torch-title": "La Torche Ethereum",
+  "page-10-year-torch-description": "Un NFT unique célébrant le 10e anniversaire d’Ethereum. La Torche passe de membre en membre de la communauté, symbolisant l’esprit de collaboration et de décentralisation qui définit Ethereum.",
+  "page-10-year-torch-current-holder": "Détenteur actuel de la Torche",
+  "page-10-year-torch-no-holder": "Aucun détenteur actuel",
+  "page-10-year-torch-history-title": "Historique des détenteurs de la Torche",
+  "page-10-year-torch-no-history": "Aucun historique de transfert disponible",
+  "page-10-year-torch-from": "De",
+  "page-10-year-torch-to": "À",
+  "page-10-year-torch-view-tx": "Voir la transaction",
+  "page-10-year-livestream-title": "Rejoins le direct",
+  "page-10-year-livestream-video-title": "Diffusion en direct : 10 ans d’Ethereum",
+  "page-10-year-torch-nft-intro": "Pour commémorer cette étape historique, nous lançons la <strong>Torche Ethereum NFT</strong>, un NFT qui incarne l’esprit de décentralisation et de communauté qui a marqué la première décennie d’Ethereum.",
+  "page-10-year-torch-nft-description": "À l’image d’une flamme cérémonielle qui voyage de communauté en communauté, la Torche Ethereum parcourra l’écosystème Ethereum mondial. Ce NFT spécial sera transmis de portefeuille en portefeuille parmi des membres de la communauté, développeurs et bâtisseurs soigneusement sélectionnés, qui ont façonné l’histoire d’Ethereum au cours des 10 dernières années.",
+  "page-10-year-torch-one-of-kind-title": "Unique en son genre :",
+  "page-10-year-torch-one-of-kind-description": "Il n’existe qu’une seule Torche Ethereum NFT, faisant de chaque détenteur un gardien temporaire de l’héritage d’Ethereum",
+  "page-10-year-torch-time-limited-title": "Garde à durée limitée :",
+  "page-10-year-torch-time-limited-description": "Chaque détenteur conserve la torche pendant 24 heures avant de la transmettre au gardien suivant. Le 30 juillet, ce NFT sera brûlé pour célébrer l’anniversaire.",
+  "page-10-year-mint-card-title": "Immortalise l’instant",
+  "page-10-year-mint-card-description": "Célèbre une décennie de décentralisation avec un NFT gratuit et en édition limitée pour le 10e anniversaire. Obtiens le tien avant que le temps ne s’écoule.",
+  "page-10-year-mint-card-ended-title": "La période de réclamation est terminée",
+  "page-10-year-mint-card-ended-description": "Merci à tous d’avoir participé à la célébration",
+  "page-10-year-video-aria-label": "Vidéo du 10e anniversaire",
+  "page-10-year-nft-link-label": "Découvrez les dix ans du NFT Ethereum sur OpenSea",
+  "page-10-year-terms-and-conditions": "Termes et conditions"
+}
diff --git a/src/intl/fr/page-about.json b/src/intl/fr/page-about.json
index a52f108bd4b..60901dc6426 100644
--- a/src/intl/fr/page-about.json
+++ b/src/intl/fr/page-about.json
@@ -7,7 +7,7 @@
   "page-about-li-2": "prévu",
   "page-about-li-3": "implémenté",
   "page-about-li-4": "implémenté",
-  "page-about-link-1": "Le code source de ce répertoire est sous licence MIT",
+  "page-about-link-1": "Le code source de ce dépôt est sous licence MIT",
   "page-about-link-2": "GitHub",
   "page-about-link-3": "Voir la liste complète des tâches en cours sur GitHub",
   "page-about-link-4": "Rejoignez notre serveur Discord",
@@ -17,11 +17,11 @@
   "page-about-p-1": "Depuis le lancement d'ethereum.org, nous nous efforçons d'être transparents sur la façon dont nous fonctionnons. C'est l'une de nos valeurs fondamentales, car nous pensons que la transparence est essentielle au succès d'Ethereum.",
   "page-about-p-2": "Nous utilisons",
   "page-about-p-3": "comme principal outil de gestion de projet. Nous organisons nos tâches en 3 catégories :",
-  "page-about-p-4": "  Nous faisons de notre mieux pour que la communauté soit informée du statut d'une tâche spécifique.",
+  "page-about-p-4": "Nous faisons de notre mieux pour que la communauté soit informée du statut d'une tâche spécifique.",
   "page-about-p-5": "Les tâches en cours d'implémentation.",
-  "page-about-p-6": "Les tâches que nous avons mises en file d'attente pour les implémenter plus tard.",
+  "page-about-p-6": "Les tâches mises en file d'attente pour être implémentées prochainement.",
   "page-about-p-7": "Les tâches récemment terminées.",
-  "page-about-p-8": "Vous avez des idées pour améliorer ethereum.org ? Nous adorerions collaborer avec vous !",
+  "page-about-p-8": "Vous avez des idées pour améliorer ethereum.org ? Nous serions ravis de collaborer avec vous !",
   "page-what-is-ethereum-energy-consumption-chart-legend": "Consommation d'énergie annuelle en TWh/an",
   "energy-consumption-chart-global-data-centers-label": "Centres de données globaux",
   "energy-consumption-chart-airbnb-label": "Airbnb",
diff --git a/src/intl/fr/page-apps.json b/src/intl/fr/page-apps.json
index 568d11d0fb5..c0d5877a7c0 100644
--- a/src/intl/fr/page-apps.json
+++ b/src/intl/fr/page-apps.json
@@ -1,289 +1,72 @@
 {
-  "page-apps-1inch-logo-alt": "Logo 1inch",
-  "page-apps-aave-logo-alt": "Logo Aave",
-  "page-apps-add-button": "Suggérer une DApp",
-  "page-apps-add-title": "Ajouter une DApp",
-  "page-apps-ankr-logo-alt": "Logo Ankr",
-  "page-apps-api3-logo-alt": "Logo API3",
-  "page-apps-arweave-logo-alt": "Logo ARweave",
-  "page-apps-audius-logo-alt": "Logo Audius",
-  "page-apps-axie-infinity-logo-alt": "Logo Axie Infinity",
-  "page-apps-balancer-logo-alt": "Logo Balancer",
-  "page-apps-brave-logo-alt": "Logo Brave",
-  "page-apps-beginner-friendly-description": "Quelques applications décentralisées pour les débutants. Explorez plus d'applications décentralisées ci-dessous.",
-  "page-apps-beginner-friendly-header": "Convient aux débutants",
-  "page-apps-category-arts": "Art et mode",
-  "page-apps-category-browsers": "Navigateurs",
-  "page-apps-category-code-marketplaces": "Marchés de code",
-  "page-apps-category-collectibles": "Produits de collection numériques",
-  "page-apps-category-competitive": "Jeux Web3",
-  "page-apps-category-computing": "Outils de développement",
-  "page-apps-category-dex": "Échanges",
-  "page-apps-category-investments": "Fonds d'investissement",
-  "page-apps-category-lending": "Prêter et emprunter",
-  "page-apps-category-lottery": "Financement participatif",
-  "page-apps-category-marketplaces": "Marchés",
-  "page-apps-category-music": "Musique",
-  "page-apps-category-payments": "Paiements",
-  "page-apps-category-insurance": "Assurance",
-  "page-apps-category-portfolios": "Gestion de portefeuille",
-  "page-apps-category-trading": "Marchés prédictifs",
-  "page-apps-category-utilities": "Utilitaires",
-  "page-apps-category-worlds": "Mondes virtuels",
-  "page-apps-category-demand-aggregator": "Agrégateurs de demande",
-  "page-apps-category-derivatives": "Dérivés",
-  "page-apps-category-liquid-staking": "Mise en jeu libre",
-  "page-apps-category-bridges": "Passerelles",
-  "page-apps-category-experiences": "Expériences partagées",
-  "page-apps-category-guilds": "Guildes de rendement",
-  "page-apps-category-avatar": "Avatars",
-  "page-apps-choose-category": "Choisir une catégorie",
-  "page-apps-category-social": "Réseaux sociaux",
-  "page-apps-category-content": "Contenu",
-  "page-apps-category-community": "Communauté",
-  "page-apps-category-messaging": "Messagerie",
-  "page-apps-category-identity": "Identité",
-  "page-apps-collectibles-benefits-1-description": "Lorsque de l'art est tokenisé sur Ethereum, la propriété peut être prouvée à tout le monde. Vous pouvez tracer le parcours de l'œuvre depuis sa création à son possesseur actuel. Cela empêche les contrefaçons.",
-  "page-apps-collectibles-benefits-1-title": "La propriété est démontrable",
-  "page-apps-collectibles-benefits-2-description": "Payer pour diffuser de la musique ou acheter des œuvres d'art est beaucoup plus juste pour les artistes. Avec Ethereum, il y a moins besoin d'intermédiaires. Et si des intermédiaires sont nécessaires, leurs coûts ne sont pas aussi élevés parce que les plateformes n'ont pas besoin de payer pour l'infrastructure du réseau.",
-  "page-apps-collectibles-benefits-2-title": "Plus équitable pour les créateurs",
-  "page-apps-collectibles-benefits-3-description": "Les objets de collection tokenisés sont liés à votre adresse Ethereum, pas à la plateforme. Ainsi, vous pouvez vendre des objets, comme par exemple des items in-game, non plus seulement dans le jeu lui-même mais sur n'importe quel marché Ethereum.",
-  "page-apps-collectibles-benefits-3-title": "Les objets de collection ne vous quittent plus",
-  "page-apps-collectibles-benefits-4-description": "Les outils et les produits existent déjà pour vous permettre de tokeniser votre art et de le vendre ! Et vos jetons peuvent être vendus sur toutes les plateformes d'objets de collection Ethereum.",
-  "page-apps-collectibles-benefits-4-title": "Infrastructure déjà en place",
-  "page-apps-collectibles-benefits-description": "Ce sont des applications qui se concentrent sur la propriété numérique, augmentant le potentiel de gains pour les créateurs, et inventant de nouvelles façons d'investir dans vos créateurs préférés et leur travail.",
-  "page-apps-collectibles-benefits-title": "collections décentralisées et streaming",
-  "page-apps-collectibles-button": "Arts et objets de collection",
-  "page-apps-collectibles-description": "Ce sont des applications qui se concentrent sur la propriété numérique, augmentant le potentiel de gains pour les créateurs, et inventant de nouvelles façons d'investir dans vos créateurs préférés et leur travail.",
-  "page-apps-collectibles-title": "Arts et objets de collection décentralisés",
-  "page-apps-compound-logo-alt": "Logo Compound",
-  "page-apps-convex-logo-alt": "Logo de Convex",
-  "page-apps-cryptopunks-logo-alt": "Logo CryptoPunks",
-  "page-apps-cryptovoxels-logo-alt": "Logo Cryptovoxels",
-  "page-apps-cyberconnect-logo-alt": "Logo CyberConnect",
-  "page-apps-dapp-description-1inch": "Vous aide à éviter un glissement du prix à la hausse en agrégant les meilleurs prix.",
-  "page-apps-dapp-description-aave": "Prêtez vos jetons pour gagner des intérêts et retirez à tout moment.",
-  "page-apps-dapp-description-ankr": "Ensemble de différents produits d'infrastructure Web3 pour construire, gagner, jouer et plus encore — le tout sur la blockchain.",
-  "page-apps-dapp-description-api3": "Flux de données de prix qui permettent aux dApps sur 10 réseaux (et plus encore) de se connecter à des données de prix d'actifs en temps réel, y compris les prix des crypto-monnaies et du forex.",
-  "page-apps-dapp-description-arweave": "Stockez les données de manière permanente et durable avec un seul frais initial.",
-  "page-apps-dapp-description-async-art": "Créez, collectionnez et échangez #ProgrammableArt - des peintures numériques divisées en \"calques\" que vous pouvez utiliser pour affecter l'image globale. Chaque maître et chaque calque est un jeton ERC721.",
-  "page-apps-dapp-description-audius": "Plateforme de streaming décentralisée. Écoutes = argent pour les créateurs, pas pour les labels.",
-  "page-apps-dapp-description-axie-infinity": "Échangez et combattez des créatures appelées Axies. Et empochez en jouant, disponible sur mobile",
-  "page-apps-dapp-description-balancer": "Balancer est une plateforme automatisée de gestion de portefeuille et de trading.",
-  "page-apps-dapp-description-brave": "Gagnez des jetons en naviguant et soutenez vos créateurs préférés avec eux.",
+  "page-apps-all-apps": "Toutes les applications",
   "page-apps-dapp-description-cent": "Un réseau social où vous gagnez de l'argent en publiant des NFT.",
-  "page-apps-dapp-description-compound": "Prêtez vos jetons pour gagner des intérêts et retirez à tout moment.",
-  "page-apps-dapp-description-convex": "Convex permet aux apporteurs de liquidité de Curve de gagner des commissions d'échange et d'obtenir des CRV boostés sans verrouiller les leurs.",
-  "page-apps-dapp-description-cryptopunks": "Achetez, enchérissez sur des punks et proposez-les à la vente - l'un des premiers objets de collection tokenisés sur Ethereum.",
-  "page-apps-dapp-description-cryptovoxels": "Créez des galeries d'art, construisez des magasins et achetez des terrains – un monde virtuel Ethereum.",
-  "page-apps-dapp-description-cyberconnect": "Protocole de graphe social décentralisé qui aide les dApps à amorcer l'effet de réseau et à construire des expériences sociales personnalisées",
-  "page-apps-dapp-description-dark-forest": "Conquérez des planètes dans un univers infini, généré de façon procédurale et spécifié par cryptographie.",
   "page-apps-dapp-description-decentraland": "Collectez et échangez des terrains virtuels dans un monde virtuel que vous pouvez explorer.",
   "page-apps-dapp-description-ens": "Noms conviviaux pour les adresses Ethereum et les sites décentralisés.",
-  "page-apps-dapp-description-foundation": "Investissez dans des éditions uniques d'œuvres d'art numériques et échangez des pièces avec d'autres acheteurs.",
   "page-apps-dapp-description-gitcoin": "Gagnez de la cryptomonnaie en travaillant sur des logiciels en open source.",
-  "page-apps-dapp-description-gitcoin-grants": "Financement participatif de projets communautaires Ethereum avec des contributions amplifiées",
-  "page-apps-dapp-description-gm": "Plateforme tout-en-un pour chatter, en vocal et en text qui partage vraiment ses revenus avec ses créateurs",
   "page-apps-dapp-description-gods-unchained": "Jeu stratégique de cartes de trading. Gagnez des cartes que vous pouvez vendre dans la vie réelle en jouant.",
-  "page-apps-dapp-description-golem": "Accédez à l'énergie informatique partagée ou louez vos propres ressources.",
-  "page-apps-dapp-description-graph": "Un protocole d'indexation pour rechercher dans des réseaux comme Ethereum et IPFS.",
-  "page-apps-dapp-description-ipfs": "Un protocole hypermédia pair à pair conçu pour préserver et augmenter le savoir de l'humanité en rendant le web évolutif, résilient et plus ouvert.",
-  "page-apps-dapp-description-radicle": "Sécurisez le code pair à pair sans intermédiaires.",
-  "page-apps-dapp-description-kyberswap": "Échangez et gagnez aux meilleurs taux.",
-  "page-apps-dapp-description-kiwinews": "Découvrez des actualités, des articles et des produits Ethereum intéressants, sélectionnés pour les créateurs par des créateurs. Discutez-en avec d'autres développeurs, fondateurs et investisseurs.",
-  "page-apps-dapp-description-lido": "La mise en jeu simplifiée et sécurisée pour les actifs numériques.",
-  "page-apps-dapp-description-loopring": "Plateforme de trading Peer-to-peer conçue pour la vitesse.",
-  "page-apps-dapp-description-marble-cards": "Créez et échangez des cartes numériques uniques basées sur des URL.",
-  "page-apps-dapp-description-matcha": "Analyse plusieurs marchés pour vous aider à trouver les meilleurs prix.",
-  "page-apps-dapp-description-meeds": "Hubs de communautés Web3 à l'ère du travail décentralisé. Récompensez les contributions qui le méritent de manière juste et transparente.",
-  "page-apps-dapp-description-mirror": "Construit sur web3 pour web3, la solide plateforme de publication de Mirror repousse les limites de l'écriture en ligne",
-  "page-apps-dapp-description-multichain": "Le routeur ultime pour web3. Il s'agit d'une infrastructure développée pour des interactions arbitraires entre chaînes.",
-  "page-apps-dapp-description-nifty-gateway": "Achetez des œuvres sur la chaîne auprès des meilleurs artistes, athlètes, marques et créateurs.",
-  "page-apps-dapp-description-summerfi": "Échangez, empruntez et économisez avec Dai, un stablecoin Ethereum.",
-  "page-apps-dapp-description-opensea": "Achetez, vendez, découvrez, et échangez des produits en édition limitée.",
-  "page-apps-dapp-description-opera": "Envoyez des cryptomonnaies à partir de votre navigateur aux commerçants, aux autres utilisateurs et aux applications.",
-  "page-apps-dapp-description-osuvox": "Avatars 3D vivant sur la blockchain",
-  "page-apps-dapp-description-poap": "Accumulez des NFT prouvant que vous étiez à différents événements virtuels ou en personne. Utilisez-les pour rejoindre des tirages au sort, voter, collaborer ou juste pour vous vanter.",
-  "page-apps-dapp-description-polymarket": "Pariez sur les résultats, négociez sur les marchés de l'information.",
-  "page-apps-dapp-description-pooltogether": "Une loterie que vous ne pouvez pas perdre. Des prix chaque semaine.",
-  "page-apps-dapp-description-index-coop": "Un fonds d'indice de cryptomonnaies qui permet à votre portefeuille d'accéder aux jetons DeFi les plus performants.",
-  "page-apps-dapp-description-nexus-mutual": "Couverture sans compagnie d'assurance. Soyez protégé contre les bogues et le piratage de contrat unique.",
-  "page-apps-dapp-description-etherisc": "Un modèle d’assurance décentralisé permettant à tous et chacun de créer sa propre couverture d’assurance.",
-  "page-apps-dapp-description-zapper": "Surveillez votre portefeuille et utilisez une gamme de produits DeFi à partir d'une seule interface.",
-  "page-apps-dapp-description-zerion": "Gérez votre portefeuille et évaluez facilement tous les actifs DeFi sur le marché.",
-  "page-apps-dapp-description-rotki": "Logiciel libre pour effectuer le suivi, l'analyse, la comptabilité et la fiscalité de votre portefeuille en respectant votre confidentialité.",
-  "page-apps-dapp-description-krystal": "Une plateforme à guichet unique pour accéder à tous vos services DeFi préférés.",
-  "page-apps-dapp-description-rarible": "Créez, vendez et achetez des objets de collection tokenisés.",
-  "page-apps-dapp-description-request-finance": "Une gamme d'outils financiers pour les factures, les salaires et les dépenses en cryptomonnaie.",
-  "page-apps-dapp-description-rubic": "Agrégateur de technologie Inter-Chain pour les utilisateurs et les dApps.",
-  "page-apps-dapp-description-sablier": "Diffusez de l'argent en temps réel.",
-  "page-apps-dapp-description-spatial": "Créez votre propre avatar personnalisé et des mondes 3D",
-  "page-apps-dapp-description-spruce": "Pile open-source pour laisser le contrôle de l'identité et des données là où il devrait être : entre les mains des utilisateurs.",
-  "page-apps-dapp-description-status": "Conçu pour permettre la libre circulation de l'information, protéger le droit à des conversations privées et sécurisées, et promouvoir la souveraineté des individus.",
-  "page-apps-dapp-description-superrare": "Achetez des œuvres numériques directement auprès des artistes ou sur les marchés secondaires.",
-  "page-apps-dapp-description-synthetix": "Synthetix est un protocole pour émettre et échanger des avoirs synthétiques",
-  "page-apps-dapp-description-uniswap": "Échangez facilement des jetons ou envoyez des jetons pour des récompenses en pourcentage.",
-  "page-apps-dapp-description-xmtp": "Envoyez des messages entre les comptes blockchain, y compris les messages directs, les alertes, les annonces et plus encore.",
-  "page-apps-dapp-description-yearn": "Yearn Finance est un agrégateur de rendement. Il donne aux individus, aux DAO et aux autres protocoles un moyen de déposer des avoirs numériques et de recevoir des intérêts.",
-  "page-apps-docklink-dapps": "Introduction aux dapps",
-  "page-apps-docklink-smart-contracts": "Contrats intelligents",
-  "page-apps-dark-forest-logo-alt": "Logo de Dark Forest",
-  "page-apps-decentraland-logo-alt": "Logo de Decentraland",
-  "page-apps-index-coop-logo-alt": "Logo Index Coop",
-  "page-apps-nexus-mutual-logo-alt": "Logo Nexus Mutual",
-  "page-apps-etherisc-logo-alt": "Logo Etherisc",
-  "page-apps-zapper-logo-alt": "Logo Zapper",
-  "page-apps-zerion-logo-alt": "Logo Zerion",
-  "page-apps-rotki-logo-alt": "Logo Rotki",
-  "page-apps-krystal-logo-alt": "Logo Krystal",
-  "page-apps-synthetix-logo-alt": "Logo de Synthetix",
-  "page-apps-desc": "Trouvez une application Ethereum a essayer.",
-  "page-apps-doge-img-alt": "Image d'un Shiba utilisant un ordinateur",
-  "page-apps-editors-choice-dark-forest": "Affrontez d'autres joueurs pour conquérir des planètes et essayez la technologie de pointe de mise à l'échelle/de confidentialité d'Ethereum. À destination uniquement de ceux qui sont familiarisés avec la technologie Ethereum.",
-  "page-apps-editors-choice-foundation": "Investissez dans la culture. Achetez, échangez, et vendez des illustrations numériques uniques et des articles de mode de certains artistes, musiciens et marques incroyables.",
-  "page-apps-editors-choice-pooltogether": "Achetez un billet gagnant pour la loterie. Chaque semaine, l'intérêt généré par l'ensemble du pool de billets est envoyé à un heureux gagnant. Récupérez votre argent quand vous le souhaitez.",
-  "page-apps-editors-choice-uniswap": "Échangez facilement vos jetons. Un favori de la communauté qui vous permet d'échanger des jetons avec le réseau.",
-  "page-apps-ens-logo-alt": "Logo du service d'Ethereum",
-  "page-apps-explore-dapps-description": "Beaucoup de dApps sont encore expérimentales, testant les possibilités de réseaux décentralisés. Mais il y a eu quelques premiers succès dans les catégories de la technologie, de la finance, des jeux et des objets de collection.",
-  "page-apps-explore-dapps-title": "Explorez des applications décentralisées",
-  "page-apps-features-1-description": "Une fois déployé sur Ethereum, le code d'une application décentralisée (DApp) ne peut pas être supprimé. Tout le monde peut utiliser les fonctionnalités d'une DApp. Même si l'équipe derrière l'application est dissoute, vous pourrez toujours l'utiliser. Une fois placé sur Ethereum, il y reste.",
-  "page-apps-features-1-title": "Aucun propriétaire",
-  "page-apps-features-2-description": "Vous ne pouvez pas être empêché d'utiliser une DApp ou de soumettre des transactions. Par exemple, si Twitter était sur Ethereum, personne ne pourrait bloquer votre compte ou vous empêcher de tweeter.",
-  "page-apps-features-2-title": "À l'abri de la censure",
-  "page-apps-features-3-description": "Étant donné que Ethereum a l'ETH, les paiements sont natifs d'Ethereum. Les développeurs n'ont pas besoin de passer du temps à intégrer des fournisseurs de paiement tiers.",
-  "page-apps-features-3-title": "Paiements intégrés",
-  "page-apps-features-4-description": "Le code d'une application décentralisée est souvent ouvert et compatible par défaut. Les équipes construisent régulièrement en utilisant le travail d'autres équipes. Si vous souhaitez permettre aux utilisateurs d'échanger des jetons dans votre DApp, il vous suffit de brancher le code d'une autre DApp.",
-  "page-apps-features-4-title": "Prêt à l'emploi",
-  "page-apps-features-5-description": "Avec la plupart des DApps, vous n'avez pas besoin de partager votre identité dans le monde réel. Votre compte Ethereum est votre identifiant et vous n'avez besoin que d'un portefeuille.",
-  "page-apps-features-5-title": "Une connexion anonyme",
-  "page-apps-features-6-description": "La cryptographie garantit que les attaquants ne peuvent pas falsifier les transactions et autres interactions DApp en votre nom. Vous autorisez les actions DApp avec votre compte Ethereum, généralement grâce à votre portefeuille, donc gardez vos identifiants en lieu sûr.",
-  "page-apps-features-6-title": "Sécurisé par la cryptographie",
-  "page-apps-features-7-description": "Une fois que la DApp est active sur Ethereum, elle ne s'arrêtera que si Ethereum lui-même s'arrête. Les réseaux de la taille d'Ethereum sont notoirement difficiles à attaquer.",
-  "page-apps-features-7-title": "Pas de temps d'arrêt",
-  "page-apps-finance-benefits-1-description": "Les services financiers fonctionnant sur Ethereum n'ont pas d'obligation d'inscription. Si vous avez des fonds et une connexion internet sécurisée, vous pouvez y aller.",
-  "page-apps-finance-benefits-1-title": "Accès libre",
-  "page-apps-finance-benefits-2-description": "Il existe tout un monde de jetons avec lesquels vous pouvez interagir à travers ces produits financiers. Les gens construisent sans arrêt de nouveaux jetons sur Ethereum.",
-  "page-apps-finance-benefits-2-title": "Une nouvelle économie de jetons",
-  "page-apps-finance-benefits-3-description": "Les équipes ont construit des <a href=\"/glossary/#stablecoin\">stablecoins</a>, une monnaie cryptographique moins volatile. Celles-ci vous permettent d'expérimenter et d'utiliser la cryptomonnaie sans risque ni incertitude.",
-  "page-apps-finance-benefits-3-title": "Stablecoins",
-  "page-apps-finance-benefits-4-description": "Les produits financiers de l'espace Ethereum sont tous modulaires et compatibles les uns avec les autres. De nouvelles configurations de ces modules apparaissent sans cesse sur le marché, augmentant ainsi ce que vous pouvez faire avec votre crypto.",
-  "page-apps-finance-benefits-4-title": "Services financiers interconnectés",
-  "page-apps-finance-benefits-description": "Qu'est-ce qui fait qu'Ethereum permet aux applications de financement décentralisés de prospérer ?",
-  "page-apps-finance-benefits-title": "finance décentralisée",
-  "page-apps-finance-button": "Finance",
-  "page-apps-finance-description": "Ce sont des applications qui se concentrent sur la mise en place de services financiers utilisant des cryptos. Elles vous permettent de prêter, d'emprunter, de gagner des intérêts et d'effectuer des paiements privés, sans avoir à fournir de données personnelles.",
-  "page-apps-finance-title": "Finance décentralisée",
-  "page-apps-foundation-logo-alt": "Logo de la fondation",
-  "page-apps-gaming-benefits-1-description": "Qu'il s'agisse de terrains virtuels ou de cartes à collectionner, vos objets sont négociables sur les marchés d'objets de collection. Vos objets en jeu ont une valeur réelle.",
-  "page-apps-gaming-benefits-1-title": "Les objets du jeu servent aussi de jetons",
-  "page-apps-gaming-benefits-2-description": "Vous êtes seul propriétaire de vos objets, et dans certains cas de vos progrès. Vous ne perdrez donc rien si l'entreprise à l'origine du jeu est attaquée, subit un dysfonctionnement du serveur ou se dissout.",
-  "page-apps-gaming-benefits-2-title": "Vos sauvegardes sont sûres",
-  "page-apps-gaming-benefits-3-description": "De la même façon que les paiements Ethereum sont accessibles à tous pour être vérifiés, les jeux peuvent user de cette qualité pour garantir l'équité. En théorie, tout est vérifiable, du nombre de coups critiques à la taille du trésor de guerre d'un adversaire.",
-  "page-apps-gaming-benefits-3-title": "L'équité prouvée",
-  "page-apps-gaming-benefits-description": "Qu'est-ce qui, dans Ethereum, permet au jeu décentralisé de prospérer ?",
-  "page-apps-gaming-benefits-title": "jeux décentralisés",
-  "page-apps-gaming-button": "Jeu",
-  "page-apps-gaming-description": "Ce sont des applications qui se concentrent sur la création de mondes virtuels et la lutte contre d'autres joueurs en utilisant des objets de collection qui ont une valeur réelle.",
-  "page-apps-gaming-title": "Jeux décentralisés",
-  "page-apps-get-some-eth-description": "Les actions Dapp entraînent des frais de transaction",
-  "page-apps-get-started-subtitle": "Pour essayer une DApp, vous aurez besoin d'un <a href=\"/glossary/#wallet\">portefeuille</a> et de quelques ETH. Un portefeuille vous permettra de vous connecter, ou d'ouvrir une session. Et vous aurez besoin de l'ETH pour payer les <a href=\"/glossary/#transaction-fee\">frais de transaction</a>.",
-  "page-apps-get-started-title": "Premiers pas",
-  "page-apps-gitcoin-grants-logo-alt": "Logo Gitcoin Grants",
-  "page-apps-gitcoin-logo-alt": "Logo Gitcoin",
-  "page-apps-gm-logo-alt": "Logo gm.xyz",
-  "page-apps-gods-unchained-logo-alt": "Logo de Gods Unchained",
-  "page-apps-golem-logo-alt": "Logo golem",
-  "page-apps-graph-logo-alt": "Logo Graph",
-  "page-apps-radicle-logo-alt": "Logo Radicle",
-  "page-apps-hero-header": "Outils et services alimentés par Ethereum",
-  "page-apps-hero-subtitle": "Les DApps sont un mouvement croissant d'applications qui utilisent Ethereum pour transformer les modèles économiques ou en inventer de nouveaux.",
-  "page-apps-how-dapps-work-p1": "Les DApps ont leur code backend (contrats intelligents) fonctionnant sur un réseau décentralisé et non pas sur un serveur centralisé. Elles utilisent la <a href=\"/glossary/#blockchain\">blockchain</a> Ethereum pour le stockage de données et les contrats intelligents pour leur logique d'app.",
-  "page-apps-how-dapps-work-p2": "Un contrat intelligent est comme un ensemble de règles qui vivent sur la chaîne pour que tout le monde puisse les voir et qui fonctionnent exactement selon ces règles. Imaginez un distributeur automatique : si vous lui fournissez suffisamment de fonds et la bonne sélection, vous obtiendrez l'article que vous voulez. Et comme les distributeurs automatiques, les contrats intelligents peuvent détenir des fonds tout comme votre compte Ethereum. Cela permet au code de servir de médiateur aux accords et aux transactions.",
-  "page-apps-how-dapps-work-p3": "Une fois que les DApps sont déployées sur le réseau Ethereum, vous ne pouvez pas les modifier. Les DApps peuvent être décentralisées car elles sont contrôlées par la logique inscrite dans le contrat, pas par un individu ou une entreprise.",
-  "page-apps-how-dapps-work-title": "Comment fonctionnent les DApps",
-  "page-apps-ipfs-logo-alt": "Logo IPFS",
-  "page-apps-kyberswap-logo-alt": "Logo KyberSwap",
-  "page-apps-learn-callout-button": "Commencer à construire",
-  "page-apps-learn-callout-description": "Notre portail de développeurs a de la documentation, des outils et des structures pour vous aider à commencer à construire une DApp.",
-  "page-apps-learn-callout-image-alt": "Illustration d'une main frabriquant un symbole ETH au moyen de briques de lego.",
-  "page-apps-learn-callout-title": "Apprenez à élaborer une DApp",
-  "page-apps-lido-logo-alt": "Logo Lido",
-  "page-apps-loopring-logo-alt": "Logo Loopring",
-  "page-apps-magic-behind-dapps-description": "Les DApps peuvent donner l'impression d'être des applications classiques, mais elles possèdent des propriétés particulières grâce aux superpouvoirs hérités d'Ethereum. Voici ce qui les distingue des applications classiques.",
-  "page-apps-magic-behind-dapps-link": "Qu'est-ce qui rend Ethereum génial ?",
-  "page-apps-magic-behind-dapps-title": "La magie derrière les DApps",
-  "page-apps-magic-title-1": "La magie",
-  "page-apps-magic-title-2": "derrière",
-  "page-apps-magician-img-alt": "Illustration de magiciens",
-  "page-apps-marble-cards-logo-alt": "Logo marble.cards",
-  "page-apps-async-logo-alt": "Logo d'Async",
-  "page-apps-matcha-logo-alt": "Logo Matcha",
-  "page-apps-meeds-logo-alt": "Logo Meeds",
-  "page-apps-metaverse-benefits-title": "métavers",
-  "page-apps-metaverse-benefits-description": "Qu'est-ce qui, dans Ethereum, permet au métavers de prospérer ?",
-  "page-apps-metaverse-benefits-1-title": "NFTs",
-  "page-apps-metaverse-benefits-1-description": "Des objets uniques dans un jeu qui sont la propriété de l'utilisateur et interopérables à travers différents mondes virtuels et marchés ayant les mêmes normes.",
-  "page-apps-metaverse-benefits-2-title": "Communautés détenues par les utilisateurs",
-  "page-apps-metaverse-benefits-2-description": "Les identités appartiennent aux utilisateurs avec d'infinies possibilités d'explorer et de créer des réseaux sociaux à travers plusieurs mondes virtuels.",
-  "page-apps-metaverse-button": "Métavers",
-  "page-apps-metaverse-title": "Métavers",
-  "page-apps-metaverse-description": "Ce sont des applications qui permettent aux utilisateurs de participer librement à des mondes virtuels. Les utilisateurs peuvent former des réseaux personnels et prendre possession d'actifs numériques",
-  "page-apps-mirror-logo-alt": "Logo Mirror",
-  "page-apps-mobile-options-header": "Parcourir une autre catégorie",
-  "page-apps-multichain-logo-alt": "Logo Multichain",
-  "page-apps-nifty-gateway-logo-alt": "Logo Nifty Gateway",
-  "page-apps-summerfi-logo-alt": "Logo de Summer.fi",
-  "page-apps-opensea-logo-alt": "Logo OpenSea",
-  "page-apps-opera-logo-alt": "Logo Opera",
-  "page-apps-osuvox-logo-alt": "Logo OSUVOX",
-  "page-apps-polymarket-logo-alt": "Logo Polymarket",
-  "page-apps-poap-logo-alt": "Logo Proof of Attendance Protocol",
-  "page-apps-pooltogether-logo-alt": "Logo PoolTogether",
-  "page-apps-rarible-logo-alt": "Logo Rarible",
-  "page-apps-ready-button": "Aller",
-  "page-apps-ready-description": "Choisissez une DApp à essayer",
-  "page-apps-ready-title": "Prêt ?",
-  "page-apps-request-finance-logo-alt": "Logo de Request Finance",
-  "page-apps-rubic-logo-alt": "Logo Rubic",
-  "page-apps-sablier-logo-alt": "Logo Sablier",
-  "page-apps-set-up-a-wallet-button": "Trouver un portefeuille",
-  "page-apps-set-up-a-wallet-description": "Un portefeuille est votre \"nom d'utilisateur\" pour une DApp",
-  "page-apps-set-up-a-wallet-title": "Configurez un portefeuille",
-  "page-apps-social-button": "Réseaux sociaux",
-  "page-apps-social-description": "Ce sont des applications qui se concentrent sur la création de réseaux sociaux décentralisés en utilisant des technologies d'identité décentralisées où les identités numériques et les graphes sociaux appartiennent aux utilisateurs.",
-  "page-apps-social-title": "Réseaux sociaux",
-  "page-apps-spatial-logo-alt": "Logo Spatial",
-  "page-apps-spruce-logo-alt": "Logo Spruce",
-  "page-apps-status-logo-alt": "Logo Status",
-  "page-apps-superrare-logo-alt": "Logo SuperRare",
-  "page-apps-technology-button": "Technologie",
-  "page-apps-technology-description": "Ce sont des applications qui se concentrent sur la décentralisation des outils de développement, l'intégration de systèmes de chiffrement dans la technologie existante, et la création de marchés pour le développement des logiciels libres.",
-  "page-apps-technology-title": "Technologie décentralisée",
-  "page-apps-uniswap-logo-alt": "Logo Uniswap",
-  "page-apps-wallet-callout-button": "Trouver un portefeuille",
-  "page-apps-wallet-callout-description": "Les portefeuilles sont également des DApps. Trouvez-en un basé sur les fonctionnalités qui vous conviennent.",
-  "page-apps-wallet-callout-image-alt": "Illustration d'un robot.",
-  "page-apps-wallet-callout-title": "Voir les portefeuilles",
-  "page-apps-warning-header": "Faites toujours vos propres recherches",
-  "page-apps-warning-message": "Ethereum est une nouvelle technologie et la plupart des applications sont nouvelles. Avant de déposer de grandes quantités d'argent, assurez-vous de bien comprendre les risques.",
-  "page-apps-what-are-dapps": "En quoi consistent les DApps ?",
-  "page-apps-more-on-defi-button": "En savoir plus sur la finance décentralisée",
-  "page-apps-more-on-nft-button": "En savoir plus sur les objets de collection tokenisés",
-  "page-apps-more-on-nft-gaming-button": "En savoir plus sur les objets en jeu tokenisés",
-  "page-apps-dapp-description-pwn": "Prêts faciles garantis par n'importe quel jeton ou NFT sur Ethereum.",
-  "page-apps-pwn-image-alt": "Logo PWN",
-  "page-apps-xmtp-logo-alt": "Logo XMTP",
-  "opage-apps-yearn-logo-alt": "Logo de Yearn",
-  "page-apps-yearn-image-alt": "Logo de Yearn",
-  "page-apps-convex-image-alt": "Logo de Convex",
+  "page-apps-dapp-description-augur": "Pariez sur les résultats, négociez sur les marchés de l'information.",
+  "page-apps-ready-button": "Go",
   "foundation": "Fondation",
   "page-wallets-get-some": "Obtenir de l'ETH",
-  "page-apps-dapp-description-curve": "Curve est un DEX focalisé sur les stablecoins",
-  "page-apps-curve-image-alt": "Logo de Curve",
-  "page-apps-dapp-description-dodo": "DODO est un fournisseur de liquidités sur la chaîne, qui s'appuie sur l'algorithme Proactive Market Maker (PMM)",
-  "page-apps-dodo-image-alt": "Logo de DODO",
-  "page-apps-dapp-description-artblocks": "Art Blocks a pour mission de donner vie à des œuvres captivantes d'art génératif contemporain",
-  "page-apps-artblocks-image-alt": "Logo Art Blocks",
-  "page-apps-explore-title": "Voulez-vous explorer d'autres applications ?",
-  "page-apps-explore": "Consultez des centaines de dApps"
-}
+  "page-apps-title": "Applications",
+  "page-apps-subtitle": "Découvrez une liste d'applications organisées qui fonctionnent sur Ethereum et les réseaux de couche 2 (L2)",
+  "page-apps-learn-button": "En savoir plus sur les applications",
+  "page-apps-highlights-title": "Points forts",
+  "page-apps-discover-title": "Découvrir",
+  "page-apps-applications-title": "Applications",
+  "page-apps-categories-title": "Catégories d'applications",
+  "page-apps-community-picks-title": "Choix de la communauté",
+  "page-apps-meta-title": "Meilleures applications cryptographiques sur Ethereum",
+  "page-apps-meta-description": "Découvrez des applications cryptographiques sur Ethereum : explorez la DeFi, les NFT, les réseaux sociaux, les jeux, les ponts entre les chaînes, la confidentialité, la productivité et les dApps DAO. Trouvez des applications on-chain fiables pour trader, gagner et interagir.",
+  "page-apps-category-defi-name": "DeFi",
+  "page-apps-category-defi-description": "DeFi est une catégorie d'applications décentralisées qui permettent aux utilisateurs de prêter, d'emprunter, d'échanger et de percevoir des intérêts sur leurs actifs cryptographiques.",
+  "page-apps-category-defi-meta-title": "Liste des applications DeFi Ethereum : Prêts, Emprunts et Intérêts",
+  "page-apps-category-defi-meta-description": "Explorez les meilleures applications DeFi sur Ethereum pour les prêts, les emprunts, l'émission de pièces stables, le crédit et le trading DEX en chaîne.",
+  "page-apps-category-collectibles-name": "Objets de collection",
+  "page-apps-category-collectibles-description": "Les objets de collection sont des actifs numériques uniques et ne peuvent pas être reproduits.",
+  "page-apps-category-collectibles-meta-title": "Liste des meilleures applications NFT sur Ethereum",
+  "page-apps-category-collectibles-meta-description": "Explorez les meilleures applications NFT pour acheter des objets de collection, échanger des thèmes de jeu et découvrir de nouveaux actifs numériques sur les principales places de marché Ethereum.",
+  "page-apps-category-social-name": "Réseaux sociaux",
+  "page-apps-category-social-description": "Applications sociales est une catégorie d'applications décentralisées permettant aux utilisateurs de se connecter avec d'autres et de partager du contenu.",
+  "page-apps-category-social-meta-title": "Applications sociales sur Ethereum : Farcaster, Zora et bien d'autres",
+  "page-apps-category-social-meta-description": "Découvrez les meilleures applications de messagerie et sociales sur Ethereum.",
+  "page-apps-category-gaming-name": "Jeu",
+  "page-apps-category-gaming-description": "Jeux est une catégorie d'applications décentralisées permettant aux utilisateurs de jouer à des jeux et de gagner des récompenses.",
+  "page-apps-category-gaming-meta-title": "Liste des jeux crypto et NFT sur Ethereum",
+  "page-apps-category-gaming-meta-description": "Découvrez les meilleurs jeux blockchain amusants : MMORPG, jeux de cartes, jeux d'IA, RPG, jeux grand public",
+  "page-apps-category-bridge-name": "Les ponts",
+  "page-apps-category-bridge-description": "Ponts entre chaînes est une catégorie d'applications décentralisées permettant aux utilisateurs de relier leurs actifs entre différents réseaux.",
+  "page-apps-category-bridge-meta-title": "Liste des Ponts Ethereum entre différents réseaux",
+  "page-apps-category-bridge-meta-description": "Découvrez les meilleures applications de Ponts entre chaînes pour déplacer vos actifs entre différents réseaux et les réseaux de couche 2.",
+  "page-apps-category-productivity-name": "Productivité",
+  "page-apps-category-productivity-description": "La productivité est une catégorie d’applications décentralisées qui permettent aux utilisateurs d’être plus productifs.",
+  "page-apps-category-productivity-meta-title": "Applications de productivité et d'identité décentralisées",
+  "page-apps-category-productivity-meta-description": "Découvrez les meilleures applications Ethereum pour l'identité décentralisée, le stockage, le DNS et le calcul vidéo. Boostez votre productivité on-chain grâce à des outils d'infrastructure fiables.",
+  "page-apps-category-privacy-name": "Confidentialité",
+  "page-apps-category-privacy-description": "La confidentialité est une catégorie d'applications décentralisées qui permettent aux utilisateurs de rester privés.",
+  "page-apps-category-privacy-meta-title": "Applications de confidentialité Ethereum : Tornado Cash et autres",
+  "page-apps-category-privacy-meta-description": "Découvrez les applications de confidentialité Ethereum comme Tornado Cash et d'autres qui protègent l'anonymat des utilisateurs, permettent des transactions privées et améliorent la confidentialité sur la chaîne.",
+  "page-apps-category-dao-name": "DAO",
+  "page-apps-category-dao-description": "DAO est une catégorie d'applications décentralisées qui permettent aux utilisateurs de gouverner et de créer des organisations autonomes décentralisées.",
+  "page-apps-category-dao-meta-title": "Liste des outils DAO sur Ethereum",
+  "page-apps-category-dao-meta-description": "Découvrez les meilleurs outils DAO sur Ethereum pour la gouvernance, la gestion de trésorerie, les votes, et la coordination de contributeurs. Déployer, gérez et développez votre organisation décentralisée.",
+  "page-apps-see-all": "Voir tout",
+  "page-apps-suggest-an-app-title": "Suggérer une application",
+  "page-apps-suggest-an-app-description": "Nous sommes toujours à la recherche de nouvelles applications à ajouter à notre liste. Si vous connaissez une application qui, selon vous, mériterait d'y figurer, n'hésitez pas à nous le faire savoir.",
+  "page-apps-suggest-an-app-button": "Suggérer une application",
+  "page-apps-filter-by": "Filtrer par",
+  "page-apps-filter-all": "Tout",
+  "page-apps-showing": "Affiche",
+  "page-apps-visit-app": "Visiter {appName}",
+  "page-apps-see-next": "Voir la suite",
+  "page-apps-info-title": "Info",
+  "page-apps-info-founded": "Fondé",
+  "page-apps-info-creator": "Créateur",
+  "page-apps-info-last-updated": "Dernière mise à jour",
+  "page-apps-gallery-title": "Galerie",
+  "page-apps-more-apps-like-this": "Plus d’applications similaires",
+  "page-apps-today": "Aujourd’hui",
+  "page-apps-one-day-ago": "Il y a 1 jour",
+  "page-apps-days-ago": "Il y a {days} jours"
+}
\ No newline at end of file
diff --git a/src/intl/fr/page-bug-bounty.json b/src/intl/fr/page-bug-bounty.json
index b0623d62152..b337b3efea3 100644
--- a/src/intl/fr/page-bug-bounty.json
+++ b/src/intl/fr/page-bug-bounty.json
@@ -13,13 +13,15 @@
   "page-upgrades-bug-bounty-misc-bugs-desc-2": "Solidity et Viper ne disposent pas de garanties de sécurité concernant la compilation des entrées non fiables – et nous ne délivrons pas de récompenses pour les plantages du compilateur sur les données générées de manière malveillante.",
   "page-upgrades-bug-bounty-deposit-bugs": "Bugs du contrat de dépôt",
   "page-upgrades-bug-bounty-deposit-bugs-desc": "Les spécifications et le code source du Contrat de dépôt de la Chaîne Phare font partie du programme de primes aux bogues.",
+  "page-upgrades-bug-bounty-deposit-contract-specs": "Spécifications du contrat de dépôt",
+  "page-upgrades-bug-bounty-deposit-contract-source": "Code source du contrat de dépôt",
   "page-upgrades-bug-bounty-dependency-bugs": "Bugs de dépendance",
   "page-upgrades-bug-bounty-dependency-bugs-desc": "Certaines dépendances sont cruciales pour le fonctionnement du réseau Ethereum, et certaines d'entre elles ont été ajoutées au programme de bug bounty. Actuellement, la liste des dépendances incluses dans le programme de bug bounty est constituée de C-KZG-4844 et Go-KZG-4844.",
   "page-upgrades-bug-bounty-docking": "fusion",
   "page-upgrades-bug-bounty-email-us": "Envoyez-nous un courriel :",
   "page-upgrades-bug-bounty-help-links": "Liens utiles",
   "page-upgrades-bug-bounty-hunting": "Règles pour la chasse aux bogues",
-  "page-upgrades-bug-bounty-hunting-desc": "Le programme de primes aux bogues est expérimental et discrétionnaire, et est destiné à notre communauté Ethereum active afin d'encourager et récompenser ceux qui aident à l'amélioration de la plateforme. Ce n'est pas une compétition. Vous devez savoir que nous pouvons annuler le programme n'importe quand, et les primes sont attribuées à la discrétion du comité du programme de primes aux bogues de l'Ethereum Foundation. De plus, nous ne pourrons pas attribuer de primes aux personnes qui sont sur la liste des personnes bannies ou faisant partie de pays étant sur la liste de pays bannis (p. ex. Corée du Nord, Iran, etc.). La législation locale exige de notre part de demander la preuve de votre identité. Vous êtes responsables eu égard aux implications fiscales. Toutes les récompenses sont assujetties aux lois applicables. En conclusion, vos évaluations ne doivent pas violer de lois ou compromettre des données qui ne vous appartiennent pas et doivent être effectuées sur des réseaux de test en fonctionnement local.",
+  "page-upgrades-bug-bounty-hunting-desc": "Le programme de primes aux bogues est un programme de récompenses expérimental et discrétionnaire destiné à notre communauté Ethereum active pour encourager et récompenser ceux qui contribuent à améliorer la plateforme. Il ne s'agit pas d'un concours. Vous devez savoir que nous pouvons annuler le programme à tout moment, et que les récompenses sont à l'entière discrétion du comité du programme de primes aux bogues de la Fondation Ethereum. De plus, nous ne sommes pas en mesure d'attribuer des récompenses à des personnes figurant sur des listes de sanctions ou se trouvant dans des pays figurant sur des listes de sanctions (par exemple, la Corée du Nord, l'Iran, etc.). Les lois locales nous obligent à demander une preuve de votre identité. Vous êtes responsable de toutes les taxes. Toutes les récompenses sont soumises à la loi applicable. Enfin, vos tests ne doivent enfreindre aucune loi ni compromettre des données qui ne sont pas les vôtres et doivent se dérouler sur des réseaux de test locaux en cours d'exécution.",
   "page-upgrades-bug-bounty-hunting-leaderboard": "Classement des primes aux bogues de la couche de consensus",
   "page-upgrades-bug-bounty-hunting-execution-leaderboard": "Classement des primes aux bogues de la couche d'exécution",
   "page-upgrades-bug-bounty-hunting-leaderboard-subtitle": "Trouver des bogues de couche de consensus pour être ajouté à ce classement",
@@ -36,7 +38,7 @@
   "page-upgrades-bug-bounty-meta-description": "Un aperçu du programme Ethereum de primes aux bogues : comment s'impliquer et récompenser les informations.",
   "page-upgrades-bug-bounty-meta-title": "Programme de primes aux bogues d'Ethereum",
   "page-upgrades-bug-bounty-not-included": "Hors périmètre",
-  "page-upgrades-bug-bounty-not-included-desc": "Seules les cibles listées dans le champ d'application font partie du programme Bug Bounty. Cela signifie que, par exemple, notre infrastructure, telle que les pages web, les DNS, le courrier électronique, etc. ne fait pas partie du champ d'application du programme de primes. Les bugs des contrats ERC20 ne sont généralement pas inclus dans le champ d'application du programme de primes. Cependant, nous pouvons aider à contacter les parties concernées, comme les auteurs ou les échanges dans de tels cas. ENS est maintenu par la fondation ENS, et ne fait pas partie du champ d'application de la prime. Les vulnérabilités nécessitant que l'utilisateur ait publiquement exposé une API, telle que\nJSON-RPC ou l'API Beacon, ne font pas partie du champ d'application du programme de primes aux bugs.",
+  "page-upgrades-bug-bounty-not-included-desc": "Seules les <a>cibles listées comme étant dans le périmètre</a> font partie du programme de primes aux bogues. Les vulnérabilités qui ne sont PAS éligibles au programme incluent :",
   "page-upgrades-bug-bounty-owasp": "Voir la méthode OWASP",
   "page-upgrades-bug-bounty-points": "L'EF fournira également des récompenses basées sur :",
   "page-upgrades-bug-bounty-points-error": "Erreur lors du chargement des données... Veuillez actualiser.",
@@ -58,7 +60,7 @@
   "page-upgrades-bug-bounty-execution-specs": "Spécifications de la couche d'exécution",
   "page-upgrades-bug-bounty-specs-docs": "Documents de spécification",
   "page-upgrades-bug-bounty-submit": "Soumettre un bogue",
-  "page-upgrades-bug-bounty-submit-desc": "Pour chaque bogue valide que vous trouverez vous gagnerez des récompenses. La quantité de récompenses gagnées varie selon son importance. La gravité est calculée selon le modèle d'évaluation des risques OWASP basé sur l'impact sur le réseau Ethereum et la probabilité.",
+  "page-upgrades-bug-bounty-submit-desc": "Pour chaque bogue valide que vous trouverez, vous gagnerez des récompenses. Le montant des récompenses attribuées variera <strong>en fonction de la gravité</strong>. La gravité est calculée selon le modèle d'évaluation des risques de l'OWASP, en fonction de l'impact sur le réseau Ethereum et de la probabilité.",
   "page-upgrades-bug-bounty-subtitle": "Gagnez jusqu'à 250 000 USD et une place sur le tableau des meilleurs en trouvant des bugs de protocole, de client et de compilateur de langage affectant le réseau Ethereum.",
   "page-upgrades-bug-bounty-title": "Ouvert pour soumissions",
   "page-upgrades-bug-bounty-title-1": "Chaîne phare",
@@ -71,10 +73,10 @@
   "page-upgrades-bug-bounty-type-4": "Incohérences de calcul ou de paramètre",
   "page-upgrades-bug-bounty-types": "Types de bogues",
   "page-upgrades-bug-bounty-validity": "Dans le champ d'application",
-  "page-upgrades-bug-bounty-validity-desc": "Notre programme de chasse aux bogues (bug bounty) couvre l'ensemble du processus : de la solidité des protocoles (tels que le modèle de consensus de la blockchain, les protocoles wire et p2p, la preuve d'enjeu, etc.) et de la conformité du protocole/de l'implémentation à la sécurité du réseau et à l'intégrité du consensus. La sécurité classique des clients ainsi que la sécurité des primitives cryptographiques font également partie du programme. En cas de doute, envoyez un email à bounty@ethereum.org et demandez-nous. Vous pouvez également soumettre une divulgation/vulnérabilité directement à <a href=\"mailto:bounty@ethereum.org\">bounty@ethereum.org,</a> auquel cas nous vous demandons de crypter le message à l'aide de notre <a href=\"https://ethereum.org/security_at_ethereum.org.asc\" target=\"_blank\" rel=\"noreferrer\">clé PGP</a>",
+  "page-upgrades-bug-bounty-validity-desc": "Notre programme de primes aux bogues couvre l'ensemble du processus : de la solidité des protocoles (tels que le modèle de consensus de la blockchain, les protocoles filaires et p2p, la preuve d'enjeu, etc.) et de la conformité des protocoles/implémentations à la sécurité du réseau et à l'intégrité du consensus. La sécurité classique du client ainsi que la sécurité des primitives cryptographiques font également partie du programme. En cas de doute, envoyez un e-mail à bounty@ethereum.org et posez-nous la question. Vous pouvez également soumettre une divulgation/vulnérabilité directement à <mailto>bounty@ethereum.org</mailto>, auquel cas nous vous demandons de chiffrer le message à l'aide de notre <a>clé PGP</a>.",
   "page-upgrades-bug-bounty-card-critical": "Critique",
   "page-upgrades-bug-bounty-card-critical-risk": "Soumettre un bogue à risque critique",
-  "page-upgrades-bug-bounty-card-h2": "Moyen",
+  "page-upgrades-bug-bounty-card-h2": "Modéré",
   "page-upgrades-bug-bounty-card-high": "Élevé",
   "page-upgrades-bug-bounty-card-high-risk": "Soumettre un bogue à risque élevé",
   "page-upgrades-bug-bounty-card-label-1": "Jusqu'à 1 000 points",
@@ -105,28 +107,28 @@
   "page-upgrades-question-title": "Questions fréquemment posées",
   "bug-bounty-faq-q1-title": "À quoi doit ressembler une bonne soumission de vulnérabilité ?",
   "bug-bounty-faq-q1-contentPreview": "Voir un exemple réel d'une soumission de vulnérabilité de qualité.",
-  "bug-bounty-faq-q1-content-1": "<b>Description :</b> Déni de service à distance utilisant des blocs non validés",
-  "bug-bounty-faq-q1-content-2": "<b>Scénario d'attaque :</b> Un attaquant peut envoyer des blocs qui peuvent nécessiter une quantité élevée de calculs (la gasLimit maximale) mais n'ont pas de preuve de travail. Si l'attaquant envoie des blocs en continu, il peut forcer le nœud victime à utiliser le CPU à 100 %.",
-  "bug-bounty-faq-q1-content-3": "<b>Impact :</b> Un attaquant peut abuser de l'utilisation du CPU sur des nœuds distants, en provoquant éventuellement des DoS complets.",
-  "bug-bounty-faq-q1-content-4": "<b>Composants :</b> Version client Go v0.6.8",
-  "bug-bounty-faq-q1-content-5": "<b>Reproduction :</b> Envoyer un bloc à un nœud Go qui contient de nombreuses transactions sans PoW valide.",
-  "bug-bounty-faq-q1-content-6": "<b>Détails :</b> Les blocs sont validés dans la méthode <code>Process(Block, dontReact)</code>. Cette méthode exécute des tâches coûteuses à forte intensité de CPU, telles que des transactions (<code>sm.ApplyDiff</code>), puis vérifie la preuve de travail (<code>sm.ValidateBlock()</code>). Cela permet à un attaquant d'envoyer des blocs qui peuvent nécessiter une grande quantité de calculs (la <code>gazLimit</code> maximum) mais qui n'ont pas de preuve de travail. Si l'attaquant envoie des blocs de façon continue, il peut forcer le nœud victime à utiliser le CPU à 100 %.",
-  "bug-bounty-faq-q1-content-7": "<b>Correctif : </b> Inversez l'ordre des vérifications.",
+  "bug-bounty-faq-q1-content-1": "<strong>Description :</strong> Déni de service à distance utilisant des blocs non validés",
+  "bug-bounty-faq-q1-content-2": "<strong>Scénario d'attaque :</strong> Un attaquant peut envoyer des blocs qui peuvent nécessiter une quantité élevée de calculs (la gasLimit maximale) mais n'ont pas de preuve de travail. Si l'attaquant envoie des blocs en continu, il peut forcer le nœud victime à utiliser le CPU à 100 %.",
+  "bug-bounty-faq-q1-content-3": "<strong>Impact :</strong> Un attaquant peut abuser de l'utilisation du CPU sur des nœuds distants, en provoquant éventuellement des DoS complets.",
+  "bug-bounty-faq-q1-content-4": "<strong>Composants :</strong> Version client Go v0.6.8",
+  "bug-bounty-faq-q1-content-5": "<strong>Reproduction :</strong> Envoyer un bloc à un nœud Go qui contient de nombreuses transactions sans PoW valide.",
+  "bug-bounty-faq-q1-content-6": "<strong>Détails :</strong> Les blocs sont validés dans la méthode <code>Process(Block, dontReact)</code>. Cette méthode exécute des tâches coûteuses et gourmandes en CPU, telles que l'exécution de transactions (<code>sm.ApplyDiff</code>), puis elle vérifie la preuve de travail (<code>sm.ValidateBlock()</code>). Cela permet à un attaquant d'envoyer des blocs qui peuvent nécessiter une grande quantité de calcul (la <code>limite de gaz</code> maximale) mais qui n'ont pas de preuve de travail. Si l'attaquant envoie des blocs en continu, il peut forcer le nœud victime à utiliser 100 % de son CPU.",
+  "bug-bounty-faq-q1-content-7": "<strong>Correctif :</strong> Inversez l'ordre des vérifications.",
   "bug-bounty-faq-q2-title": "Le programme de primes aux bogues est-il limité dans le temps ?",
   "bug-bounty-faq-q2-contentPreview": "Non.",
-  "bug-bounty-faq-q2-content-1": "Aucune date de fin n'est actuellement fixée. Se reporter au <a href=\"https://blog.ethereum.org/\" target=\"_blank\" rel=\"noreferrer\">blog de l'Ethereum Foundation</a> pour plus d'informations récentes.",
+  "bug-bounty-faq-q2-content-1": "Aucune date de fin n'est actuellement fixée. Consultez <a>le blog de la Fondation Ethereum</a> pour les dernières nouvelles.",
   "bug-bounty-faq-q3-title": "Comment les primes sont-elles payées ?",
   "bug-bounty-faq-q3-contentPreview": "Les récompenses sont versées en ETH ou en DAI.",
-  "bug-bounty-faq-q3-content-1": "Les récompenses sont versées en ETH ou en DAI après validation de la soumission, généralement quelques jours plus tard. Les lois locales nous obligent à demander <b>une preuve de votre identité</b>. En outre, nous aurons besoin de votre adresse ETH.",
+  "bug-bounty-faq-q3-content-1": "Les récompenses sont versées en ETH ou en DAI après la validation de la soumission, généralement quelques jours plus tard. Les lois locales nous obligent à demander une <strong>preuve de votre identité</strong>. De plus, nous aurons besoin de votre adresse ETH.",
   "bug-bounty-faq-q4-title": "Puis-je faire don de ma récompense à une association caritative ?",
   "bug-bounty-faq-q4-contentPreview": "Oui !",
   "bug-bounty-faq-q4-content-1": "Nous pouvons faire don de votre récompense à l'organisation caritative établie de votre choix.",
   "bug-bounty-faq-q5-title": "J'ai signalé un problème / une vulnérabilité mais je n'ai pas reçu de réponse !",
   "bug-bounty-faq-q5-contentPreview": "Veuillez prévoir quelques jours pour que quelqu'un réponde à votre demande.",
-  "bug-bounty-faq-q5-content-1": "Nous nous efforçons de répondre aux demandes le plus rapidement possible. N'hésitez pas à nous envoyer un email à <a href=\"mailto:bounty@ethereum.org\" target=\"_blank\" rel=\"noreferrer\">bounty@ethereum.org</a> si vous n'avez pas reçu de réponse dans un délai d'un jour ou deux.",
+  "bug-bounty-faq-q5-content-1": "Nous nous efforçons de répondre aux soumissions le plus rapidement possible. N'hésitez pas à nous envoyer un e-mail à <a>bounty@ethereum.org</a> si vous n'avez pas reçu de réponse dans un délai d'un jour ou deux.",
   "bug-bounty-faq-q6-title": "Je veux rester anonyme / Je ne veux pas que mon nom apparaisse sur le tableau des résultats.",
   "bug-bounty-faq-q6-contentPreview": "Vous pouvez le faire, mais cela pourrait vous rendre inéligible aux récompenses.",
-  "bug-bounty-faq-q6-content-1": "Les soumissions anonymes ou sous pseudonyme sont acceptables, mais elles ne vous donneront pas droit aux récompenses ETH/DAI. Pour être éligible aux récompenses ETH/DAI, nous avons besoin de votre vrai nom et d'une preuve de votre identité. Le don de votre prime à une organisation caritative ne requiert pas votre identité.",
+  "bug-bounty-faq-q6-content-1": "Soumettre anonymement ou sous pseudonyme est accepté, mais cela vous rend inéligible aux récompenses en ETH/DAI. Pour être éligible aux récompenses en ETH/DAI, nous exigeons que votre vrai nom et une preuve de votre identité soient envoyés, chiffrés via PGP sur notre site sécurisé de dépôt, à notre équipe juridique de la Fondation Ethereum, qui est seule habilitée à examiner ces documents. Faire don de votre prime à une organisation caritative ne nécessite pas de fournir votre identité.",
   "bug-bounty-faq-q6-content-2": "Veuillez nous faire savoir si vous ne souhaitez pas que votre nom/surnom apparaisse sur le tableau des résultats.",
   "bug-bounty-faq-q7-title": "Quels sont les points du classement ?",
   "bug-bounty-faq-q7-contentPreview": "Un score est attribué à chaque vulnérabilité/problème découvert",
@@ -134,5 +136,34 @@
   "bug-bounty-faq-q8-title": "Avez-vous une clé PGP ?",
   "bug-bounty-faq-q8-contentPreview": "Oui. Développez pour plus de détails.",
   "bug-bounty-faq-q8-content-1": "Veuillez utiliser <code>AE96 ED96 9E47 9B00 84F3 E17F E88D 3334 FA5F 6A0A</code>",
-  "bug-bounty-faq-q8-PGP-key": "Clé PGP"
+  "bug-bounty-faq-q8-PGP-key": "Clé PGP",
+  "page-upgrades-bug-bounty-severity-qualifications-title": "Qualifications de la gravité des vulnérabilités",
+  "page-upgrades-bug-bounty-severity-qualifications-desc": "La gravité est évaluée en fonction de la capacité d'une vulnérabilité découverte à effectuer les opérations suivantes :",
+  "page-upgrades-bug-bounty-severity-low-title": "Gravité faible",
+  "page-upgrades-bug-bounty-severity-low-li-1": "Slacher <strong>0,01 %</strong> des validateurs",
+  "page-upgrades-bug-bounty-severity-low-li-2": "Provoquer de manière triviale des divisions du réseau affectant <strong>0,01 %</strong> du réseau",
+  "page-upgrades-bug-bounty-severity-low-li-3": "Pouvoir mettre hors service <strong>0,01 %</strong> du réseau en envoyant un seul paquet réseau ou une seule transaction en chaîne",
+  "page-upgrades-bug-bounty-severity-medium-title": "Gravité moyenne",
+  "page-upgrades-bug-bounty-severity-medium-li-1": "Slacher <strong>1 %</strong> des validateurs",
+  "page-upgrades-bug-bounty-severity-medium-li-2": "Provoquer de manière triviale des divisions du réseau affectant <strong>5 %</strong> du réseau",
+  "page-upgrades-bug-bounty-severity-medium-li-3": "Pouvoir mettre hors service <strong>5 %</strong> du réseau en envoyant un seul paquet réseau ou une seule transaction en chaîne",
+  "page-upgrades-bug-bounty-severity-high-title": "Gravité élevée",
+  "page-upgrades-bug-bounty-severity-high-li-1": "Slacher <strong>33 %</strong> des validateurs",
+  "page-upgrades-bug-bounty-severity-high-li-2": "Provoquer de manière triviale des divisions du réseau affectant <strong>33 %</strong> du réseau",
+  "page-upgrades-bug-bounty-severity-high-li-3": "Pouvoir mettre hors service <strong>33 %</strong> du réseau en envoyant un seul paquet réseau ou une seule transaction en chaîne",
+  "page-upgrades-bug-bounty-severity-critical-title": "Gravité critique",
+  "page-upgrades-bug-bounty-severity-critical-li-1": "Slacher <strong>50 %</strong> des validateurs",
+  "page-upgrades-bug-bounty-severity-critical-li-2": "Exploiter un bogue d'EIP/spécification ou de client pour <strong>créer facilement une quantité infinie d'ETH</strong> qui est finalisée par le réseau",
+  "page-upgrades-bug-bounty-severity-critical-li-3": "<strong>Voler des ETH</strong> sur tous les EOA",
+  "page-upgrades-bug-bounty-severity-critical-li-4": "<strong>Brûler des ETH</strong> sur tous les EOA",
+  "page-upgrades-bug-bounty-severity-critical-li-5": "<strong>Mettre hors service l'ensemble du réseau</strong> en envoyant une seule transaction malveillante en chaîne qui finit par faire planter tous les clients",
+  "page-upgrades-bug-bounty-out-of-scope-footnote": "Ces cas ne sont généralement pas inclus, mais nous pouvons aider à contacter les parties concernées, comme les auteurs ou les plateformes d'échange",
+  "page-upgrades-bug-bounty-not-included-li-1": "Bogues d'infrastructure — tels que les pages web, le DNS, les e-mails, etc.",
+  "page-upgrades-bug-bounty-not-included-li-2": "Bogues de contrat ERC-20",
+  "page-upgrades-bug-bounty-not-included-li-3": "Bogues de l'Ethereum Naming Service (ENS) (maintenu par la fondation ENS)",
+  "page-upgrades-bug-bounty-not-included-li-4": "Vulnérabilités nécessitant que l'utilisateur ait exposé publiquement une API, telle que JSON-RPC ou l'API Beacon",
+  "page-upgrades-bug-bounty-not-included-li-5": "Erreurs typographiques",
+  "page-upgrades-bug-bounty-not-included-li-6": "Tests",
+  "page-upgrades-bug-bounty-not-included-li-7": "Attaques par déni de service (DoS) à pair unique demandant un effort élevé (soutenu, intensif en CPU ou en bande passante, et/ou nécessitant plus d'un paquet ou d'une transaction en chaîne)",
+  "page-upgrades-bug-bounty-not-included-li-8": "Tout problème connu du public (y compris les publications sur les forums, les PR, les problèmes sur GitHub, les commits, les articles de blog, les messages publics sur Discord, etc.)"
 }
diff --git a/src/intl/fr/page-collectibles.json b/src/intl/fr/page-collectibles.json
new file mode 100644
index 00000000000..e66cfe8fc6e
--- /dev/null
+++ b/src/intl/fr/page-collectibles.json
@@ -0,0 +1,67 @@
+{
+  "page-collectibles-already-desc": "Vérifiez votre progression",
+  "page-collectibles-already-title": "Vous êtes déjà un contributeur ?",
+  "page-collectibles-code-content-desc": "Corriger des problèmes, rédiger ou améliorer des articles, ou proposer des améliorations de design pour le site web.",
+  "page-collectibles-code-content-design-1issue": "Badge « Problème de design résolu »",
+  "page-collectibles-code-content-design-desc": "Faire des critiques de design, améliorer notre système de design ou participer à des tests utilisateurs.",
+  "page-collectibles-code-content-design-title": "Conception",
+  "page-collectibles-code-content-design-user-testing": "Badge « Participation aux tests utilisateurs »",
+  "page-collectibles-code-content-developer-10pr": "Badge « 10 PR fusionnées »",
+  "page-collectibles-code-content-developer-1pr": "Badge « 1 PR fusionnée »",
+  "page-collectibles-code-content-developer-5pr": "Badge « 5 PR fusionnées »",
+  "page-collectibles-code-content-developer-desc": "Toute amélioration fusionnée sur le site web.",
+  "page-collectibles-code-content-developer-title": "Développeur",
+  "page-collectibles-code-content-gitpoap-1pr": "Badge « PR fusionnée »",
+  "page-collectibles-code-content-gitpoap-desc": "Déclarable automatiquement après la fusion de votre PR.",
+  "page-collectibles-code-content-gitpoap-title": "GitPOAP",
+  "page-collectibles-code-content-instructions-1": "Aller sur notre <a href=\"https://github.com/ethereum/ethereum-org-website\">dépôt GitHub</a>",
+  "page-collectibles-code-content-instructions-2": "Choisir un problème sur lequel travailler",
+  "page-collectibles-code-content-instructions-3": "Valider une correction ou une amélioration",
+  "page-collectibles-code-content-title": "Code et Contenu",
+  "page-collectibles-code-content-writing-badge-1": "Badge de contribution de contenu",
+  "page-collectibles-code-content-writing-desc": "Pour toute amélioration de contenu fusionnée dans la branche master.",
+  "page-collectibles-code-content-writing-title": "Rédaction",
+  "page-collectibles-connect-wallet": "Connecter un portefeuille",
+  "page-collectibles-contributing-since": "Contribuant depuis",
+  "page-collectibles-contributor-img-alt": "Deux contributeurs en conversation",
+  "page-collectibles-contributor-progress-label": "Réclamé",
+  "page-collectibles-current-year-title": "Année en cours",
+  "page-collectibles-get-started": "Commencer",
+  "page-collectibles-hero-description": "Prouvez que vous avez travaillé sur ethereum.org, onchain.",
+  "page-collectibles-hero-header": "Objets de collection Ethereum.org",
+  "page-collectibles-hero-title": "Badges",
+  "page-collectibles-how-step1-desc": "sur le site web",
+  "page-collectibles-how-step1-title": "Contribuer",
+  "page-collectibles-how-step2-desc": "sur Discord",
+  "page-collectibles-how-step2-title": "Obtenir une vérification",
+  "page-collectibles-how-step3-desc": "sur Galxe",
+  "page-collectibles-how-step3-title": "Réclamer un NFT",
+  "page-collectibles-how-title": "Fonctionnement",
+  "page-collectibles-improve-desc-1": "Gagner des NFTs uniques en aidant à maintenir et développer le site ethereum.org. Ces badges <strong>reconnaissent votre participation onchain</strong>.",
+  "page-collectibles-improve-desc-2": "Les meilleurs détenteurs reçoivent<a>des cadeaux de contributeur</a> ou des billets à prix réduit pour des événements comme Devcon. Vos badges onchain permettent aux <strong>autres de vous soutenir facilement.</strong>.",
+  "page-collectibles-improve-title": "Améliorer ethereum.org",
+  "page-collectibles-index-frequency": "Les résultats sont mis à jour une fois par jour à 15 h 15 UTC",
+  "page-collectibles-instructions-label": "Instructions",
+  "page-collectibles-previous-years-badge-count": "{count, plural, =0 {aucun badge} =1 {1 badge} other {# badges}}",
+  "page-collectibles-previous-years-collectors-count": "{count, plural, =0 {aucun collectionneur} =1 {1 collectionneur} other {# collectionneurs}}\n",
+  "page-collectibles-previous-years-no-badges": "Aucun badge créé",
+  "page-collectibles-previous-years": "Années précédentes",
+  "page-collectibles-social-desc": "Participer à l’une de nos discussions Discord pour tester le site avant les mises à jour ou pour suivre les actualités de ethereum.org lors de nos appels communautaires mensuels.",
+  "page-collectibles-social-instructions-1": "Rejoindre notre <a href=\"https://discord.gg/ethereum-org/\">serveur Discord</a>",
+  "page-collectibles-social-instructions-2": "Voir le planning",
+  "page-collectibles-social-instructions-3": "Rejoindre !",
+  "page-collectibles-social-title": "Réseaux sociaux",
+  "page-collectibles-stats-collectors": "Collectionneurs",
+  "page-collectibles-stats-minted": "Frappé",
+  "page-collectibles-stats-unique-badges": "Badges uniques",
+  "page-collectibles-translations-1000": "Badge des 1 000 mots",
+  "page-collectibles-translations-10000": "Badge des 10 000 mots",
+  "page-collectibles-translations-250": "Badge des 250 mots",
+  "page-collectibles-translations-50000": "Badge des 50 000 mots",
+  "page-collectibles-translations-badge-desc": "Vers n’importe quelle langue.",
+  "page-collectibles-translations-desc": "La plupart des utilisateurs ne parlent pas anglais, il est donc essentiel d’aider à traduire nos articles dans d’autres langues, sans qu’aucune expérience en traduction ne soit nécessaire.",
+  "page-collectibles-translations-instructions-1": "Inscris-toi sur <a href=\"https://crowdin.com/project/ethereum-org\">Crowdin</a>",
+  "page-collectibles-translations-instructions-2": "Sélectionner une langue",
+  "page-collectibles-translations-instructions-3": "Commencez à traduire",
+  "page-collectibles-translations-title": "Traductions"
+}
diff --git a/src/intl/fr/page-community-events.json b/src/intl/fr/page-community-events.json
index c1a14d1fa55..bf0399f8eaa 100644
--- a/src/intl/fr/page-community-events.json
+++ b/src/intl/fr/page-community-events.json
@@ -75,7 +75,6 @@
   "page-events-tag-hackathon": "Hackathon",
   "page-events-tag-meetup": "Rencontre",
   "page-events-tag-popup": "Popup",
-  "page-events-tag-regional": "Régional",
   "page-events-tag-group": "Groupe",
   "page-events-tag-other": "Autre",
   "page-events-tag-cowork": "Cotravail",
diff --git a/src/intl/fr/page-community.json b/src/intl/fr/page-community.json
index 261cfdc2cc0..cf2f7b9a921 100644
--- a/src/intl/fr/page-community.json
+++ b/src/intl/fr/page-community.json
@@ -7,6 +7,9 @@
   "page-community-card-3-description": "Découvrez comment vous impliquer pour obtenir une liste identifiant les façons dont vous pouvez contribuer en fonction de vos compétences et de vos antécédents professionnels.",
   "page-community-card-4-title": "Rechercher des subventions",
   "page-community-card-4-description": "Des subventions de financement sont disponibles pour vous aider à démarrer un projet.",
+  "page-community-community-hub-list-h3": "Centre communautaire",
+  "page-community-community-hub-list-cta-label-1": "Inscription au co-working",
+  "page-community-community-hub-list-cta-label-2": "Rencontre",
   "page-community-contribute": "Contribuer à ethereum.org",
   "page-community-contribute-button": "En savoir plus sur la contribution",
   "page-community-contribute-description": "Pour beaucoup de gens, ethereum.org est leur premier pas dans l’écosystème. Il est tenu à jour et amélioré par des milliers de contributeurs open-source. Envie d’aider ? Lisez notre guide sur la contribution ou abordez un problème sur notre GitHub.",
@@ -32,7 +35,7 @@
   "page-community-hero-title": "Rejoindre la communauté",
   "page-community-meetuplist-no-meetups": "Nous n'avons pas de rencontres correspondant à cette recherche. En connaissez-vous une ?",
   "page-community-meta-title": "Centre communautaire",
-  "page-community-meta-description": "Description de la page d'accueil communautaire",
+  "page-community-meta-description": "Pôle communautaire pour l'écosystème Ethereum",
   "page-community-open-source": "Créateur ? Constructeur ? Soyez payé pour votre travail.",
   "page-community-open-source-description": "Vous construisez sur Ethereum, ou vous l'envisagez ? Les entreprises embauchent pour des milliers de fonctions techniques ou non. Vous avez un projet? Essayez de trouver une subvention pour le faire démarrer.",
   "page-community-open-source-image-alt": "Soyez rémunéré pour votre travail",
diff --git a/src/intl/fr/page-developers-docs.json b/src/intl/fr/page-developers-docs.json
index 2278b6e3c36..ec4c04bdbbd 100644
--- a/src/intl/fr/page-developers-docs.json
+++ b/src/intl/fr/page-developers-docs.json
@@ -116,6 +116,7 @@
   "docs-nav-transactions": "Transactions",
   "docs-nav-transactions-description": "Transferts et autres actions qui modifient l'état d'Ethereum",
   "docs-nav-upgrading-smart-contracts": "Mise à jour des contrats intelligents",
+  "docs-nav-naming-smart-contracts": "Nommer les contrats intelligents",
   "docs-nav-verifying-smart-contracts": "Vérification des contrats intelligents",
   "docs-nav-web2-vs-web3": "Web2 vs Web3",
   "docs-nav-web2-vs-web3-description": "Les différences fondamentales que les applications basées sur la blockchain fournissent",
diff --git a/src/intl/fr/page-developers-index.json b/src/intl/fr/page-developers-index.json
index c0b5001e8ec..0c0ca01847b 100644
--- a/src/intl/fr/page-developers-index.json
+++ b/src/intl/fr/page-developers-index.json
@@ -1,37 +1,26 @@
 {
   "page-developer-meta-title": "Ressources pour les développeurs Ethereum",
-  "page-developers-about": "À propos de ces ressources développeur",
-  "page-developers-about-desc": "ethereum.org est là pour vous aider à développer avec Ethereum, et fournit de la documentation sur des concepts fondamentaux ainsi que sur la pile de développement. De plus, il existe des tutoriels pour vous aider à démarrer et à être opérationnel.",
-  "page-developers-about-desc-2": "Inspirés par le réseau de développeurs Mozilla (MDN), nous avons pensé qu'Ethereum avait besoin d'un endroit pour héberger du contenu et ressources de qualité pour les développeurs. Comme chez nos amis de Mozilla, tout ici est en open source et disponible pour vous permettre de vous développer et de vous améliorer.",
   "page-developers-account-desc": "Contrats ou personnes sur le réseau",
   "page-developers-accounts-link": "Comptes",
-  "page-developers-advanced": "Avancé",
   "page-developers-api-desc": "Utiliser les bibliothèques pour interagir avec les contrats intelligents",
   "page-developers-api-link": "API back-end",
   "page-developers-block-desc": "Lots de transactions ajoutés à la blockchain",
   "page-developers-block-explorers-desc": "Votre portail vers les données Ethereum",
   "page-developers-block-explorers-link": "Explorateurs de bloc",
   "page-developers-blocks-link": "Blocs",
-  "page-developers-browse-tutorials": "Parcourir les tutoriels",
-  "page-developers-choose-stack": "Choisir sa pile",
-  "page-developers-contribute": "Contribuer",
   "page-developers-dev-env-desc": "IDE adaptés au développement d'appd",
   "page-developers-dev-env-link": "Environnements de développement",
-  "page-developers-discord": "Rejoindre Discord",
   "page-developers-docs-introductions": "Introductions",
   "page-developers-ethskills-label": "Contexte d'agent IA pour Ethereum",
   "page-developers-evm-desc": "L'ordinateur qui traite les transactions",
   "page-developers-evm-link": "La machine virtuelle Ethereum (EVM)",
   "page-developers-explore-documentation": "Explorer la documentation",
-  "page-developers-feedback": "Si vous avez des commentaires, contactez-nous via un ticket GitHub ou notre serveur Discord.",
   "page-developers-frameworks-desc": "Outils pour accélérer le développement",
   "page-developers-frameworks-link": "Frameworks de développement",
   "page-developers-fundamentals": "Fondamentaux",
   "page-developers-gas-desc": "Ethers nécessaires pour alimenter les transactions",
   "page-developers-gas-link": "Gaz",
-  "page-developers-get-started": "Comment souhaitez-vous commencer ?",
-  "page-developers-improve-ethereum": "Aidez-nous à améliorer ethereum.org",
-  "page-developers-improve-ethereum-desc": "Comme ethereum.org, ces documents sont des contributions de la communauté. Créez une Pull Request (PR) si vous voyez des erreurs, des possibilités d'amélioration ou de nouvelles opportunités d'aider les développeurs Ethereum.",
+  "page-developers-get-started": "Que voulez-vous créer aujourd'hui ?",
   "page-developers-into-eth-desc": "Introduction à la blockchain et à Ethereum",
   "page-developers-intro-ether-desc": "Une introduction à la cryptomonnaie et à l'Ether",
   "page-developers-intro-dapps-desc": "Introduction aux applications décentralisées",
@@ -42,6 +31,7 @@
   "page-developers-intro-stack-desc": "Une introduction à la pile Ethereum",
   "page-developers-js-libraries-desc": "Utiliser JavaScript pour interagir avec les contrats intelligents",
   "page-developers-js-libraries-link": "Bibliothèques JavaScript",
+  "page-developers-jump-right-in-title": "Développez rapidement votre idée",
   "page-developers-language-desc": "Utiliser Ethereum avec des langages courants",
   "page-developers-languages": "Langages de programmation",
   "page-developers-learn": "Apprendre le développement Ethereum",
@@ -50,41 +40,32 @@
   "page-developers-learn-tutorials-cta": "Visionner les tutoriels",
   "page-developers-learn-tutorials-desc": "Apprenez le développement Ethereum étape par étape auprès d'utilisateurs expérimentés.",
   "page-developers-meta-desc": "Documentation, tutoriels et outils pour les développeurs Ethereum.",
-  "page-developers-mev-desc": "Une introduction à la Valeur Extractible Maximale (Maximal extractable value - MEV)",
-  "page-developers-mev-link": "Valeur Extractible Maximale (Maximal extractable value - MEV)",
-  "page-developers-mining-desc": "Comment de nouveaux blocs sont créés et le consensus a été atteint en utilisant la preuve de travail",
-  "page-developers-mining-link": "Minage",
-  "page-developers-mining-algorithms-desc": "Informations sur les algorithmes de minage d'Ethereum",
-  "page-developers-mining-algorithms-link": "Algorithmes de minage",
   "page-developers-networks-desc": "Présentation du réseau principal et des réseaux de test",
   "page-developers-networks-link": "Réseaux",
   "page-developers-node-clients-desc": "Comment les blocs et les transactions sont vérifiés sur le réseau",
-  "page-developers-node-clients-link": " Nœuds et clients",
-  "page-developers-oracle-desc": "Récupération de données hors chaîne dans vos contrats intelligents",
-  "page-developers-oracles-link": "Oracles",
+  "page-developers-node-clients-link": "Nœuds et clients",
   "page-developers-play-code": "Jouer avec le code",
+  "page-developers-quickstart-scaffold-subtext": "Lancez votre ensemble d’applications Ethereum en quelques secondes.",
+  "page-developers-quickstart-scaffold-docs": "Lire la documentation Scaffold-ETH 2",
   "page-developers-read-docs": "Lire la documentation",
-  "page-developers-scaling-desc": "Solutions pour des transactions plus rapides",
-  "page-developers-scaling-link": "Évolutivité",
+  "page-developers-start-quest": "Commencer la quête",
+  "page-developers-resources": "Ressources",
   "page-developers-smart-contract-security-desc": "Mesures de sécurité à prendre en compte lors du développement de contrats intelligents",
   "page-developers-smart-contract-security-link": "Sécurité des contrats intelligents",
-  "page-developers-set-up": "Configurer un environnement local",
-  "page-developers-setup-desc": "Préparez votre pile en configurant un environnement de développement.",
   "page-developers-smart-contracts-desc": "La logique derrière les appd : des accords auto-exécutants",
   "page-developers-smart-contracts-link": "Contrats intelligents",
+  "page-developers-solidity-docs": "Lire la documentation de Solidity",
   "page-developers-speedrunethereum-title": "Apprenez les concepts les plus importants en construisant sur Ethereum",
+  "page-developers-speedrunethereum-description": "Recevez un mentorat d'autres personnes et apprenez à collaborer avec d'autres développeurs.",
   "page-developers-speedrunethereum-link": "SpeedRun Ethereum",
   "page-developers-stack": "La pile",
-  "page-developers-start": "Commencer à expérimenter",
-  "page-developers-start-desc": "Vous voulez commencer par expérimenter, et poser des questions plus tard ?",
+  "page-developers-start": "Défis et mentorat",
   "page-developers-storage-desc": "Comment gérer le stockage d'appd",
   "page-developers-storage-link": "Stockage",
-  "page-developers-subtitle": "Un manuel de développement pour Ethereum. Par les développeurs, pour les développeurs.",
+  "page-developers-subtitle": "Un manuel de constructeurs pour Ethereum. Tout ce dont vous avez besoin pour construire et mettre à niveau votre application onchain.",
   "page-developers-title-1": "Ethereum",
   "page-developers-title-2": "développeur",
   "page-developers-title-3": "ressources",
-  "page-developers-token-standards-desc": "Présentation des normes de jetons acceptées",
-  "page-developers-token-standards-link": "Normes de jetons",
   "page-developers-transactions-desc": "Comment l'état d'Ethereum change",
   "page-developers-transactions-link": "Transactions",
   "page-developers-web3-desc": "Différences du monde de développement Web3",
@@ -96,5 +77,57 @@
   "page-developers-data-structures-and-encoding-link": "Structures de données et encodage",
   "page-developers-data-structures-and-encoding-desc": "Introduction aux structures de données et au schéma d'encodage utilisés dans la pile Ethereum",
   "alt-eth-blocks": "Illustration de blocs organisés comme un symbole ETH",
-  "page-assets-doge": "Doge avec DApps"
+  "page-assets-doge": "Doge avec DApps",
+  "page-developers-build-section-desc": "Tout ce dont vous avez besoin pour apprendre et construire vos premières applications sur Ethereum",
+  "page-developers-resources-section-title": "Ressources utiles pour les développeurs",
+  "page-developers-get-help-title": "Obtenir de l'aide",
+  "page-developers-get-help-desc": "Si vous êtes bloqué ou avez besoin d'aide pour résoudre des problèmes, demandez des conseils.",
+  "page-developers-stack-exchange": "Stack Exchange",
+  "page-developers-ask-ai": "Interrogez l'IA",
+  "page-developers-resources-title": "Ressources",
+  "page-developers-resources-desc": "Vous voulez d’abord tester par vous-même, et poser vos questions ensuite ? Explorez les espaces de test sans risques, les formations intensives, etc.",
+  "page-developers-tutorials-title": "Tutos",
+  "page-developers-tutorials-desc": "Apprenez le développement Ethereum étape par étape auprès d'utilisateurs expérimentés.",
+  "page-developers-video-courses-title": "Cours vidéo",
+  "page-developers-video-courses-desc": "Vous voulez démarrer votre carrière professionnelle dans la blockchain ? Ces cours vous prépareront à être embauché en tant que développeur blockchain.",
+  "page-developers-docs-section-desc": "Comprendre les concepts de base d'Ethereum et de blockchains",
+  "page-developers-hackathons-title": "Rejoindre les hackathons",
+  "page-developers-hackathons-desc": "Les hackathons sont d'excellentes opportunités de réseauter et d'apprendre des autres, ainsi que de démarrer des projets et de gagner des prix",
+  "page-developers-visit-ethglobal": "Visitez EthGlobal",
+  "page-developers-founders-title": "Êtes-vous un créateur d'entreprise ?",
+  "page-developers-founders-desc": "Vous avez déjà une idée de projet ou travaillez sur un prototype ? Découvrez comment faire passer votre projet à l'étape suivante. Nous pouvons vous mettre en relation avec des organisations et des experts compétents.",
+  "page-developers-get-in-touch": "Nous contacter",
+  "page-developers-see-grant-options": "Voir les options de subvention",
+  "page-developers-speedrun-nft-alt": "Bannière Speedrun Ethereum Tokenisation",
+  "page-developers-speedrun-nft-title": "Tokenisation",
+  "page-developers-speedrun-nft-desc": "Créez un jeton unique pour apprendre les bases de scaffold-eth.",
+  "page-developers-skill-beginner": "Débutant",
+  "page-developers-skill-intermediate": "Intermédiaire",
+  "page-developers-skill-advanced": "Avancé",
+  "page-developers-speedrun-dex-alt": "Bannière Speedrun Ethereum DEX",
+  "page-developers-speedrun-dex-title": "DEX",
+  "page-developers-speedrun-dex-desc": "Créez un teneur de marché automatisé simple, fournissez des liquidités et mettez en œuvre des échanges de jetons.",
+  "page-developers-speedrun-stablecoins-alt": "Bannière Speedrun Ethereum Stablecoins",
+  "page-developers-speedrun-stablecoins-title": "Stablecoins",
+  "page-developers-speedrun-stablecoins-desc": "Créez un stablecoin et apprenez les mécanismes de stabilité et les oracles de prix.",
+  "page-developers-course-duration": "<span></span>cours d'une heure",
+  "page-developers-course-blockchain-basics-title": "Notions de base sur la blockchain",
+  "page-developers-course-blockchain-basics-desc": "Découvrez comment fonctionnent les blockchains et les contrats intelligents, créez un portefeuille et signez votre première transaction.",
+  "page-developers-course-blockchain-basics-alt": "Bannière du cours de base Cyfrin Updraft Blockchain",
+  "page-developers-course-solidity-title": "Développement de contrats intelligents avec Solidity",
+  "page-developers-course-solidity-desc": "La programmation en Solidity est votre porte d'entrée vers le développement Web3 dans les écosystèmes compatibles avec Ethereum.",
+  "page-developers-course-solidity-alt": "Bannière du cours de développement de contrat intelligent Cyfrin Updraft Solidity",
+  "page-developers-course-foundry-fundamentals-title": "Fondamentaux de Foundry",
+  "page-developers-course-foundry-fundamentals-desc": "Améliorez vos compétences en développement Solidity avec Foundry et des concepts et outils avancés de développement du Web3.",
+  "page-developers-course-foundry-fundamentals-alt": "Bannière du cours sur les fondamentaux de Cyfrin Updraft Foundry",
+  "page-developers-course-advanced-foundry-title": "Foundry avancé",
+  "page-developers-course-advanced-foundry-desc": "Maîtriser les techniques de développement web3 avec Foundry avancé pour le développement de contrats intelligents Solidity.",
+  "page-developers-course-advanced-foundry-alt": "Bannière du cours avancé Foundry de Cyfrin Updraft",
+  "page-developers-course-security-title": "Sécurité de contrat intelligent",
+  "page-developers-course-security-desc": "Démarrez votre carrière comme chercheur en sécurité des contrats intelligents. Formez-vous à l’audit des contrats intelligents et aux bonnes pratiques.",
+  "page-developers-course-security-alt": "Bannière du cours de base Cyfrin Updraft Blockchain",
+  "page-developers-why-title": "Soyez bien payé. Travaillez à distance. Construisez l'avenir.",
+  "page-developers-why-subtitle": "Plus de la moitié des carrières dans la blockchain sont principalement en télétravail, certaines estimations évaluant ce chiffre jusqu'à 70 %.",
+  "page-developers-why-avg-salary-dev": "Salaire moyen d'un développeur",
+  "page-developers-why-avg-salary-blockchain": "Salaire moyen dans l'industrie de la blockchain"
 }
diff --git a/src/intl/fr/page-developers-tutorials.json b/src/intl/fr/page-developers-tutorials.json
index 07fbc332fdd..2f645aee387 100644
--- a/src/intl/fr/page-developers-tutorials.json
+++ b/src/intl/fr/page-developers-tutorials.json
@@ -1,13 +1,14 @@
 {
   "comp-tutorial-metadata-minute-read": "minutes de lecture",
-  "page-tutorial-listing-policy-intro": "Avant de soumettre un tutoriel, prenez le temps de lire notre politique d'inscription.",
+  "page-tutorial-listing-policy-intro": "Avant de soumettre un tutoriel, veuillez <a href=\"/contributing/content-resources/\">lire notre politique de référencement</a>.",
   "comp-tutorial-metadata-tip-author": "Astuce de l'auteur",
+  "page-tutorial-create-an-issue": "Créez un ticket",
+  "page-tutorial-create-an-issue-desc": "Remplissez le modèle de problème en y décrivant votre tutoriel.",
   "page-tutorial-raise-issue-btn": "Soulever un problème",
   "page-tutorial-read-time": "min",
   "page-tutorial-submit-btn": "Soumettre un tutoriel",
-  "page-tutorial-submit-tutorial": "Pour soumettre un tutoriel, vous devrez utiliser GitHub. Nous vous invitons à créer un ticket ou une demande d'extraction.",
   "page-tutorial-subtitle": "Bienvenue dans notre liste organisée de tutoriels de la communauté.",
-  "page-tutorial-tags-error": "Aucun tutoriel ne contient tous ces tags",
+  "page-tutorial-tags-error": "Il n'y a pas encore de tutoriels avec tous les tags sélectionnés.",
   "page-tutorial-title": "Tutoriels de développement Ethereum",
   "page-tutorials-meta-description": "Naviguez et filtrez les tutoriels de la communauté Ethereum par sujet.",
   "page-tutorial-external-link": "Externe",
diff --git a/src/intl/fr/page-energy-consumption.json b/src/intl/fr/page-energy-consumption.json
new file mode 100644
index 00000000000..2942ea59d38
--- /dev/null
+++ b/src/intl/fr/page-energy-consumption.json
@@ -0,0 +1,21 @@
+{
+  "adoption-chart-artists-label": "Artistes",
+  "adoption-chart-column-now-label": "Maintenant",
+  "adoption-chart-companies-label": "Sociétés",
+  "adoption-chart-developers-label": "Développeurs",
+  "adoption-chart-gamers-label": "Gamers",
+  "adoption-chart-investors-label": "Investisseurs",
+  "adoption-chart-musicians-label": "Musiciens",
+  "adoption-chart-refugees-label": "Réfugiés",
+  "adoption-chart-writers-label": "Auteurs",
+  "energy-consumption-chart-airbnb-label": "Airbnb",
+  "energy-consumption-chart-btc-pow-label": "BTC PoW",
+  "energy-consumption-chart-eth-pos-label": "ETH PoS",
+  "energy-consumption-chart-eth-pow-label": "ETH PoW",
+  "energy-consumption-chart-gaming-us-label": "Jouer aux États-Unis",
+  "energy-consumption-chart-global-data-centers-label": "Centres de données globaux",
+  "energy-consumption-chart-netflix-label": "Netflix",
+  "energy-consumption-chart-paypal-label": "PayPal",
+  "energy-consumption-gold-mining-cbeci-label": "Extraction d'or",
+  "energy-consumption-chart-legend": "Consommation d'énergie annuelle en TWh/an"
+}
diff --git a/src/intl/fr/page-ethereum-history-founder-and-ownership.json b/src/intl/fr/page-ethereum-history-founder-and-ownership.json
new file mode 100644
index 00000000000..04f1949c304
--- /dev/null
+++ b/src/intl/fr/page-ethereum-history-founder-and-ownership.json
@@ -0,0 +1,65 @@
+{
+  "page-ethereum-history-founder-and-ownership-meta-title": "Histoire d'Ethereum : fondateur, lancement et propriété | ethereum.org",
+  "page-ethereum-history-founder-and-ownership-meta-description": "Découvrez l'histoire d'Ethereum, notamment qui l'a créé, quand il a été lancé et qui le contrôle aujourd'hui.",
+  "page-ethereum-history-founder-and-ownership-twitter-meta-description": "Découvrez les différences entre le Bitcoin et l'Ethereum, notamment les cas d'utilisation, les performances du réseau, l'économie des jetons et plus encore.",
+  "page-ethereum-history-founder-and-ownership-title": "Histoire d'Ethereum : fondateur, lancement et propriété",
+  "page-ethereum-history-founder-and-ownership-description-1": "Ethereum a été fondé par Vitalik Buterin en 2013. Plusieurs cofondateurs se sont joints à lui plus tard, notamment Gavin Wood et Joseph Lubin. Le réseau Ethereum a été officiellement lancé le 30 juillet 2015, avec le minage du premier bloc (le bloc d'origine).",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-description-1": "Contrairement aux organisations traditionnelles, <strong>Ethereum n'a pas de PDG</strong>, de conseil d'administration ou de partie de contrôle unique. C'est une plateforme décentralisée gouvernée par sa communauté, avec le soutien de l'organisation à but non lucratif Ethereum Foundation.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum": "Qui a fondé/cofondé Ethereum ?",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-1": "Ethereum a été <strong>fondé par Vitalik Buterin</strong> qui en a conçu l'idée <strong>fin 2013</strong>.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-2": "Né en Russie en 1994 et élevé au Canada, Buterin a fait preuve d'un talent mathématique exceptionnel dès son plus jeune âge.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-3": "Il a découvert le Bitcoin en 2011, et a commencé à écrire des articles sur le Bitcoin, ce qui l'a amené à cofonder le <em>Bitcoin Magazine</em> en 2012. C'était l'une des premières publications dédiées à la cryptomonnaie. En faisant partie de la première communauté Bitcoin, il a été le témoin direct de son potentiel et de ses limites.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-4": "En 2014, Vitalik a publié le <whitepaper>livre blanc d'Ethereum</whitepaper>, décrivant une plateforme qui irait au-delà du Bitcoin en créant une blockchain capable de faire plus que de simples paiements.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-5": "Ethereum étend l'approche du Bitcoin, en disant en gros, eh bien, au lieu d'avoir des règles conçues pour prendre en charge une seule application, nous allons créer quelque chose de plus général où les gens peuvent simplement construire leurs propres applications et où les règles de toutes les applications qu'ils ont construites peuvent être exécutées, implémentées sur la plateforme Ethereum.",
+  "page-ethereum-history-founder-and-ownership-when-ethereum-when-did-ethereum-launch": "Quand Ethereum a-t-il été lancé ?",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now": "Qui possède et gère Ethereum aujourd'hui ?",
+  "page-ethereum-history-founder-and-ownership-founder-of-ethereum": "Fondateur d'Ethereum",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-6": "Ethereum a été cofondé par 8 personnes qui ont contribué à donner vie à Ethereum.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-vitalik-buterin": "<strong>Vitalik Buterin</strong> : a conçu Ethereum en 2013, a rédigé le livre blanc original, et en est devenu le principal visionnaire et défenseur, articulant le concept d'un ordinateur mondial décentralisé et guidant la direction technique et philosophique du protocole.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-gavin-wood": "<strong>Gavin Wood</strong> : a développé le langage de programmation <solidity>Solidity</solidity> et a rédigé le <ethereumYellowPaper>« Yellow Paper » d'Ethereum</ethereumYellowPaper>, le guide technique de la machine virtuelle Ethereum (EVM).",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-joseph-lubin": "<strong>Joseph Lubin</strong> : a contribué au financement des toutes premières étapes d'Ethereum et a fondé plus tard <consensys>ConsenSys</consensys>, une société axée sur la création d'applications et d'infrastructures basées sur Ethereum.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-jeffrey-wilcke": "<strong>Jeffrey Wilcke</strong> : a créé <geth>Geth</geth>, le client d'exécution original et le plus utilisé d'Ethereum, responsable de l'exécution de l'EVM et du stockage des données du réseau Ethereum.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-mihai-alisie": "<strong>Mihai Alisie</strong> : a cofondé le Bitcoin Magazine avec Vitalik Buterin et a contribué à la création de la Fondation Ethereum en Suisse, en tant que vice-président et en mettant en place le cadre juridique de la prévente de l'ether.",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-anthony-di-lorio": "<strong>Anthony Di Lorio</strong>",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-amir-chetrit": "<strong>Amir Chetrit</strong>",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-charles-hoskinson": "<strong>Charles Hoskinson</strong>",
+  "page-ethereum-history-founder-and-ownership-who-founded-ethereum-launch-description-7": "Aujourd'hui, Vitalik Buterin reste activement impliqué dans le développement d'Ethereum. Joseph Lubin continue de diriger ConsenSys. Son entreprise développe des outils clés pour l'écosystème Ethereum comme <strong>MetaMask</strong> et <strong>Infura</strong>.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-1": "Le voyage de l'idée initiale de Vitalik au lancement officiel d'Ethereum a duré environ 20 mois. Voici les étapes clés :",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-2": "<strong>Novembre 2013 :</strong> Vitalik Buterin partage le livre blanc d'Ethereum. Il y décrit sa vision d'une plateforme blockchain capable d'exécuter des contrats intelligents.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-3": "<strong>Janvier 2014 :</strong> Vitalik <announcement>annonce publiquement</announcement> le concept d'Ethereum lors de la North American Bitcoin Conference à Miami.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-4": "<strong>Juillet–août 2014 :</strong> pour financer le développement d'Ethereum, l'équipe fondatrice a mené une campagne de financement participatif public. Ils ont levé 31 000 BTC (d'une valeur d'environ 18 millions de dollars à l'époque) en échange d'ether (ETH).",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-5": "<strong>Avril 2015 :</strong> Vitalik et les cofondateurs lancent le réseau de test Olympic d'Ethereum. C'était la dernière phase de test avant le lancement du réseau principal.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-6": "<strong>30 juillet 2015 :</strong> l'équipe fondatrice lance officiellement le réseau principal d'Ethereum en minant le bloc d'origine. Cela marque la naissance du réseau Ethereum.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-7": "<strong>14 mars 2016 :</strong> la communauté Ethereum met en œuvre « Homestead », la première mise à niveau planifiée. Cela signale qu'Ethereum était prêt pour une adoption grand public.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-8": "Dans le projet Ethereum, nous avions cette idée que nous n'aurions qu'une seule chance, que c'était une occasion unique, donc nous devions réussir.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-9": "Cofondateur d'Ethereum",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-10": "Le lancement d'Ethereum a marqué une étape majeure dans la technologie blockchain. Il a introduit les contrats intelligents et a créé une plateforme pour les applications décentralisées.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-11": "Vous pouvez <genesisBlock>toujours voir le bloc d'origine d'Ethereum</genesisBlock>, préservant ainsi le moment où Ethereum a vu le jour.",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-12": "Voir la liste complète des mises à niveau d'Ethereum",
+  "page-ethereum-history-founder-and-ownership-when-did-ethereum-launch-description-13": "Consultez la future feuille de route d'Ethereum",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-1": "L'un des aspects les plus uniques d'Ethereum est sa structure de propriété, ou plus précisément, son absence de propriété traditionnelle. Contrairement à une entreprise classique, Ethereum :",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-2": "<strong>n'a pas de PDG ou d'autorité centrale</strong>",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-3": "n'est <strong>pas contrôlé par une seule entité</strong> ou organisation",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-4": "<strong>n'a pas d'actionnaires</strong> au sens traditionnel du terme",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-5": "Au lieu de cela, Ethereum fonctionne comme un réseau décentralisé. Il est <strong>maintenu par des milliers d'ordinateurs indépendants</strong> (nœuds) à travers le monde. Ce modèle décentralisé est au cœur de la conception et de la valeur d'Ethereum.",
+  "page-ethereum-history-founder-and-ownership-who-owns-and-runs-ethereum-now-description-6": "Plusieurs groupes clés contribuent au développement et à la gouvernance continus d'Ethereum :",
+  "page-ethereum-history-founder-and-ownership-ethereum-foundation": "1. La Fondation Ethereum",
+  "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-1": "La <strong>Fondation Ethereum est une organisation à but non lucratif</strong> qui soutient Ethereum et les technologies connexes. Bien qu'importante, elle ne contrôle pas le réseau. La fondation :",
+  "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-2": "Gère des fonds pour soutenir le développement d'Ethereum",
+  "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-3": "Accorde des subventions à des projets qui se construisent sur Ethereum",
+  "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-4": "Organise des événements communautaires et des initiatives éducatives",
+  "page-ethereum-history-founder-and-ownership-ethereum-foundation-description-5": "Coordonne les efforts de recherche",
+  "page-ethereum-history-founder-and-ownership-core-developers": "2. Développeurs et chercheurs principaux",
+  "page-ethereum-history-founder-and-ownership-core-developers-description-1": "Une communauté mondiale de développeurs et de chercheurs contribue au code et à la conception d'Ethereum. Ces contributeurs proposent, discutent et mettent en œuvre des améliorations par le biais d'un processus ouvert et public. Vitalik Buterin reste respecté au sein de la communauté, cependant, les décisions sont prises par accord de groupe plutôt que par une seule personne.",
+  "page-ethereum-history-founder-and-ownership-eip": "3. Propositions d'amélioration d'Ethereum (EIP)",
+  "page-ethereum-history-founder-and-ownership-eip-description-1": "La communauté Ethereum propose des changements au réseau par le biais des <eips>propositions d'amélioration d'Ethereum (EIP)</eips>. Ce système ouvert permet à quiconque de suggérer des améliorations. Ces idées sont ensuite discutées, affinées et potentiellement mises en œuvre par la communauté.",
+  "page-ethereum-history-founder-and-ownership-validators": "4. Opérateurs de nœuds et validateurs",
+  "page-ethereum-history-founder-and-ownership-validators-description-1": "Depuis le passage d'Ethereum à la preuve d'enjeu en septembre 2022, le réseau est sécurisé par des validateurs qui bloquent (mettent en jeu) des ETH et traitent les transactions. Il existe <beaconchain>un grand nombre de validateurs</beaconchain> répartis dans le monde entier, ce qui distribue largement le contrôle du réseau.",
+  "page-ethereum-history-founder-and-ownership-validators-description-2": "Ce modèle décentralisé limite le contrôle par une seule entité, ce qui rend Ethereum résistant à la censure. Cela inclut ses fondateurs d'origine. Aucune personne ou organisation ne peut modifier les règles d'Ethereum ou arrêter le réseau par elle-même.",
+  "page-ethereum-history-founder-and-ownership-validators-description-3": "La principale différence entre la création d'une application sur Ethereum et sa création sur une plateforme centralisée traditionnelle est l'idée fondamentale qu'une fois que vous avez créé votre application, celle-ci n'a pas besoin de dépendre de vous ou de toute autre personne pour continuer d'exister. Et l'application est garantie de continuer à fonctionner selon les règles qui ont été spécifiées.",
+  "page-ethereum-history-founder-and-ownership-conclusion": "Conclusion",
+  "page-ethereum-history-founder-and-ownership-conclusion-description-1": "De sa création par Vitalik Buterin en 2013 à son lancement en 2015 et à sa croissance actuelle, <strong>Ethereum est resté fidèle à sa vision fondatrice</strong>. Il reste une plateforme <strong>décentralisée et neutre de manière crédible</strong> pour des applications qui s'exécutent exactement comme elles ont été programmées. Le réseau et les applications construites dessus fonctionnent <strong>sans temps d'arrêt, censure, fraude ou interférence de tiers</strong>.",
+  "page-ethereum-history-founder-and-ownership-conclusion-description-2": "L'histoire d'Ethereum continue de se dérouler avec chaque mise à jour et innovation. À mesure que le réseau évolue, il illustre la manière dont la gouvernance décentralisée peut stimuler le progrès technologique sans les structures d'entreprise traditionnelles.",
+  "page-ethereum-history-founder-and-ownership-conclusion-description-3": "Ethereum est passé d'un livre blanc visionnaire à une <strong>couche d'infrastructure mondiale alimentant des milliers d'applications et des milliards de dollars en valeur</strong>. Cela prouve que la collaboration ouverte peut remodeler non seulement la finance, mais aussi les concepts fondamentaux de propriété, de gouvernance et de confiance numérique.",
+  "page-ethereum-history-founder-and-ownership-conclusion-description-4": "En savoir plus sur le processus de gouvernance d'Ethereum"
+}
diff --git a/src/intl/fr/page-ethereum-vs-bitcoin.json b/src/intl/fr/page-ethereum-vs-bitcoin.json
new file mode 100644
index 00000000000..175e5ab50c4
--- /dev/null
+++ b/src/intl/fr/page-ethereum-vs-bitcoin.json
@@ -0,0 +1,101 @@
+{
+  "page-ethereum-vs-bitcoin-meta-title": "Ethereum vs Bitcoin : quelle est la différence ? | ethereum.org",
+  "page-ethereum-vs-bitcoin-meta-description": "Découvrez les différences entre le Bitcoin et l'Ethereum, notamment les cas d'utilisation, les performances du réseau, la sécurité, l'économie des jetons, le niveau de décentralisation et plus encore.",
+  "page-ethereum-vs-bitcoin-twitter-meta-description": "Découvrez les différences entre le Bitcoin et l'Ethereum, notamment les cas d'utilisation, les performances du réseau, l'économie des jetons et plus encore.",
+  "page-ethereum-vs-bitcoin-title": "Ethereum vs Bitcoin : quelle est la différence ?",
+  "page-ethereum-vs-bitcoin-description-1": "Le Bitcoin et l'Ethereum sont deux des réseaux blockchain décentralisés les plus connus, mais ils servent des objectifs très différents.",
+  "page-ethereum-vs-bitcoin-section-1": "Bitcoin (avec un B majuscule) est une blockchain conçue pour une monnaie numérique appelée bitcoin (avec un b minuscule). Ethereum est conçu pour être une plateforme décentralisée pour les applications et les actifs, alimentée par sa cryptomonnaie native, <strong>l'ether (ETH)</strong>.",
+  "page-ethereum-vs-bitcoin-section-2": "Tous deux utilisent la technologie blockchain, sont open-source et sont maintenus par des communautés mondiales, mais leurs objectifs et leurs fonctionnalités sont distincts. Dans ce guide, nous examinerons ce qu'est chaque réseau, ce qu'ils ont en commun et comment ils diffèrent dans des domaines comme la technologie, la culture et les perspectives d'avenir.",
+  "page-ethereum-vs-bitcoin-bitcoin-section-title": "Bitcoin — un bref aperçu",
+  "page-ethereum-vs-bitcoin-bitcoin-section-1": "Bitcoin est un réseau de monnaie numérique décentralisé. Il a été <strong>créé en 2009</strong> par une entité anonyme utilisant le nom de <strong>Satoshi Nakamoto</strong>, peu après la crise financière de 2008. L'idée était que Bitcoin soit un système de paiement électronique de pair à pair.",
+  "page-ethereum-vs-bitcoin-bitcoin-section-2": "Bitcoin permet à quiconque d'<strong>envoyer et de recevoir des bitcoins</strong> sur Internet <strong>sans dépendre d'une autorité centrale</strong> comme une banque. Toutes les transactions sont enregistrées sur un registre public connu sous le nom de blockchain.",
+  "page-ethereum-vs-bitcoin-bitcoin-section-3": "Bitcoin utilise la preuve de travail (proof-of-work) pour sécuriser son réseau. Des ordinateurs du monde entier s'affrontent pour résoudre des énigmes cryptographiques qui leur permettent d'ajouter de nouveaux blocs. Ces ordinateurs spécialisés sont appelés mineurs et reçoivent des bitcoins en récompense de bloc pour le « minage » de nouveaux blocs.",
+  "page-ethereum-vs-bitcoin-bitcoin-section-4": "<strong>L'offre maximale de Bitcoin est fixée à 21 millions de pièces</strong>. Ce choix de conception est l'une des principales raisons pour lesquelles le Bitcoin est souvent qualifié d'or numérique.",
+  "page-ethereum-vs-bitcoin-ethereum-section-title": "Ethereum — un bref aperçu",
+  "page-ethereum-vs-bitcoin-ethereum-section-1": "Comme Bitcoin, Ethereum est également un réseau blockchain décentralisé, mais il a été <strong>conçu pour faire plus que simplement enregistrer des paiements</strong>. Lancé en <strong>2015</strong> par un développeur de logiciels appelé <strong>Vitalik Buterin</strong> et ses cofondateurs, Ethereum a été conçu pour être une plateforme de contrats intelligents et d'applications décentralisées.",
+  "page-ethereum-vs-bitcoin-ethereum-section-2": "Ethereum permet à quiconque d'envoyer et de recevoir de la valeur comme Bitcoin, mais il agit également comme <strong>une plateforme que tout le monde peut utiliser pour des applications</strong>. Le réseau Ethereum fonctionne sur des milliers de nœuds et n'est contrôlé par aucune entité unique.",
+  "page-ethereum-vs-bitcoin-ethereum-section-3": "N'importe qui peut créer et déployer des applications sur Ethereum. Ces programmes sont appelés <strong>contrats intelligents</strong>, et ils constituent l'innovation principale d'Ethereum.",
+  "page-ethereum-vs-bitcoin-ethereum-section-4": "Une fois le contrat intelligent déployé, il s'exécute de manière déterministe lorsqu'on interagit avec lui. Cela permet de créer des applications pour des choses comme le prêt, le trading, les jeux et les objets de collection numériques qui fonctionnent 24h/24, 7j/7, pour des millions d'utilisateurs dans le monde entier.",
+  "page-ethereum-vs-bitcoin-ethereum-section-5": "De la même manière que le bitcoin est utilisé pour payer les frais de transaction sur le réseau Bitcoin, la monnaie native d'Ethereum, l'ether, est utilisée pour payer les frais de transaction, publier et utiliser des contrats intelligents, et sécuriser le réseau. <strong>L'ether agit à la fois comme carburant pour l'exécution des programmes et comme réserve de valeur</strong>.",
+  "page-ethereum-vs-bitcoin-ethereum-section-6": "En savoir plus sur Ethereum et son fonctionnement",
+  "page-ethereum-vs-bitcoin-differences-section-title": "Les principales différences",
+  "page-ethereum-vs-bitcoin-differences-section-1": "Le Bitcoin et l'Ethereum utilisent la technologie blockchain pour maintenir des réseaux décentralisés, mais ils diffèrent par leur conception, leur objectif et leurs capacités.",
+  "page-ethereum-vs-bitcoin-differences-table-area": "Domaine",
+  "page-ethereum-vs-bitcoin-differences-table-bitcoin": "Bitcoin",
+  "page-ethereum-vs-bitcoin-differences-table-ethereum": "Ethereum",
+  "page-ethereum-vs-bitcoin-differences-table-row-1-1": "Objectif principal",
+  "page-ethereum-vs-bitcoin-differences-table-row-1-2": "Monnaie numérique de pair à pair",
+  "page-ethereum-vs-bitcoin-differences-table-row-1-3": "Plateforme pour les applications et les économies numériques",
+  "page-ethereum-vs-bitcoin-differences-table-row-2-1": "Contrats intelligents",
+  "page-ethereum-vs-bitcoin-differences-table-row-2-2": "Non pris en charge",
+  "page-ethereum-vs-bitcoin-differences-table-row-2-3": "Fonctionnalité principale",
+  "page-ethereum-vs-bitcoin-differences-table-row-3-1": "Offre",
+  "page-ethereum-vs-bitcoin-differences-table-row-3-2": "Le bitcoin est émis à chaque bloc à un taux fixe/prédéterminé dicté par le protocole original et inchangé, avec une limite fixe finale de 21 millions.",
+  "page-ethereum-vs-bitcoin-differences-table-row-3-3": "L'ether est brûlé à chaque bloc proportionnellement à l'activité/la demande, et émis à chaque époque proportionnellement au total d'ETH mis en jeu. Pas de limite fixe, mais le taux d'émission est limité par le total d'ETH mis en jeu.",
+  "page-ethereum-vs-bitcoin-differences-table-row-4-1": "Mécanisme de consensus",
+  "page-ethereum-vs-bitcoin-differences-table-row-4-2": "Preuve de travail",
+  "page-ethereum-vs-bitcoin-differences-table-row-4-3": "Preuve d'enjeu",
+  "page-ethereum-vs-bitcoin-differences-table-row-5-1": "Rapidité",
+  "page-ethereum-vs-bitcoin-differences-table-row-5-2": "Considérée par la plupart comme irréversible après six blocs, soit environ 60 minutes en moyenne",
+  "page-ethereum-vs-bitcoin-differences-table-row-5-3": "Environ 15 minutes pour la finalité",
+  "page-ethereum-vs-bitcoin-differences-table-row-6-1": "Consommation d'énergie",
+  "page-ethereum-vs-bitcoin-differences-table-row-6-2": "Élevé",
+  "page-ethereum-vs-bitcoin-differences-table-row-6-3": "Faible",
+  "page-ethereum-vs-bitcoin-differences-table-row-7-1": "Gouvernance",
+  "page-ethereum-vs-bitcoin-differences-table-row-7-2": "Conservateur, évolue lentement",
+  "page-ethereum-vs-bitcoin-differences-table-row-7-3": "Flexible, axé sur la communauté",
+  "page-ethereum-vs-bitcoin-differences-table-row-8-1": "Écosystème de développeurs",
+  "page-ethereum-vs-bitcoin-differences-table-row-8-2": "Plus petit",
+  "page-ethereum-vs-bitcoin-differences-table-row-8-3": "Vaste et actif",
+  "page-ethereum-vs-bitcoin-differences-table-row-9-1": "Mises à niveau",
+  "page-ethereum-vs-bitcoin-differences-table-row-9-2": "Rares",
+  "page-ethereum-vs-bitcoin-differences-table-row-9-3": "Fréquentes et itératives",
+  "page-ethereum-vs-bitcoin-purpose-title": "Objectif de Bitcoin vs Ethereum",
+  "page-ethereum-vs-bitcoin-purpose-1": "Le Bitcoin a été créé en 2009 à la suite de la crise financière mondiale. Son objectif était d'offrir une forme de monnaie de pair à pair qui fonctionnait sans banques ni gouvernements. Sa conception est simple. Le réseau vise à <strong>transférer de la valeur d'une personne à une autre sans intermédiaire</strong>. Cet objectif précis l'a aidé à se faire connaître comme une forme d'or numérique, une réserve de valeur rare et durable qui peut également être utilisée comme moyen d'échange.",
+  "page-ethereum-vs-bitcoin-purpose-2": "Ethereum a été lancé en 2015 avec une vision plus large. Ses créateurs voulaient prendre la sécurité et la décentralisation de la blockchain et la rendre programmable. Plutôt que de se limiter aux paiements, <strong>Ethereum permet à quiconque d'écrire et de publier des programmes auto-exécutables</strong> appelés contrats intelligents. Cela ouvre la porte à une toute nouvelle catégorie d'applications, allant de la <strong>finance décentralisée (DeFi)</strong> et des <strong>stablecoins</strong> aux <strong>jetons non fongibles (NFT)</strong>, aux <strong>jeux</strong> et aux <strong>médias sociaux décentralisés</strong>.",
+  "page-ethereum-vs-bitcoin-purpose-3": "Les conceptions techniques reflètent ces objectifs. Le langage de script de Bitcoin est limité, ce qui réduit la complexité et aide à maintenir la sécurité du réseau. Le langage de programmation d'Ethereum est plus expressif, ce qui lui permet de stocker et de gérer des états et des interactions plus complexes entre les applications. Cette flexibilité est une force, mais elle signifie aussi que le réseau évolue plus rapidement, avec des mises à niveau régulières et de nouvelles fonctionnalités.",
+  "page-ethereum-vs-bitcoin-purpose-4": "Tous deux jouent des rôles distincts dans l'économie numérique au sens large. Le Bitcoin se concentre sur son rôle de réserve de valeur stable et décentralisée. Ethereum vise à être une couche de règlement (settlement) mondiale pour les applications décentralisées et les actifs programmables.",
+  "page-ethereum-vs-bitcoin-usecases-and-adoption-title": "Cas d'utilisation et adoption",
+  "page-ethereum-vs-bitcoin-usecases-and-adoption-1": "Le <strong>Bitcoin</strong> est couramment utilisé comme réserve de valeur. De nombreux investisseurs le considèrent comme <strong>une couverture contre l'inflation</strong> ou l'instabilité économique. Dans certains pays, il est utilisé comme <strong>monnaie alternative</strong> ou comme un moyen pour les gens d'épargner en dehors du système bancaire traditionnel.",
+  "page-ethereum-vs-bitcoin-usecases-and-adoption-2": "L'<strong>Ether</strong> sert également de réserve de valeur, mais son <strong>rôle principal est d'alimenter un vaste écosystème d'applications</strong> et d'actifs. Les développeurs peuvent utiliser Ethereum pour créer de nouveaux protocoles, lancer des jetons, exploiter des échanges décentralisés, frapper des NFT, créer des jeux et développer des plateformes sociales qui fonctionnent sans contrôle centralisé.",
+  "page-ethereum-vs-bitcoin-usecases-and-adoption-3": "Ethereum prend en charge des milliers d'applications décentralisées pour de nouvelles formes de finance, de financement participatif et de propriété numérique. Certains cas d'utilisation connectent même les deux réseaux. Par exemple, <strong>le Bitcoin peut être « enveloppé » (wrapped) et utilisé sur Ethereum</strong> pour des activités comme le prêt, l'emprunt et le trading dans la DeFi.",
+  "page-ethereum-vs-bitcoin-usecases-and-adoption-4": "L'adoption institutionnelle reflète ces différences. La cryptomonnaie Bitcoin est largement détenue comme une réserve de valeur à long terme, tandis qu'<strong>Ethereum est considéré comme une infrastructure décentralisée</strong>. Sa programmabilité séduit les plateformes fintech et les fournisseurs de paiement.",
+  "page-ethereum-vs-bitcoin-usecases-and-adoption-5": "En savoir plus sur l'utilisation d'Ethereum",
+  "page-ethereum-vs-bitcoin-monetary-policy-title": "Politique monétaire",
+  "page-ethereum-vs-bitcoin-monetary-policy-1": "L'offre de Bitcoin sera plafonnée à <strong>21 millions de pièces</strong>. Cette limite stricte est appliquée par le protocole et c'est l'une des raisons pour lesquelles le Bitcoin est comparé à l'or. De nouveaux bitcoins entrent en circulation grâce aux <strong>récompenses de minage</strong>, qui sont <strong>divisées par deux tous les 210 000 blocs</strong> (ce qui prend environ 4 ans à miner), lors d'un événement appelé <strong>le halving</strong> (division par deux). La récompense a commencé à 50 bitcoins par bloc en 2009, est passée à 25 en 2012, puis à 12,5 en 2016, et ainsi de suite. À ce rythme, le dernier bitcoin devrait être miné aux alentours de l'an 2140.",
+  "page-ethereum-vs-bitcoin-monetary-policy-2": "Les récompenses de minage et les frais de transaction de Bitcoin paient pour le réseau et sont utilisés pour le sécuriser. Cependant, à mesure que la récompense de bloc est divisée par deux, le réseau devient plus dépendant des frais de transaction pour se financer. Actuellement, les frais de réseau ne représentent qu'une petite partie des revenus du réseau, <5 %, ce qui signifie que la sécurité à long terme du réseau pourrait être menacée à mesure que l'émission du réseau Bitcoin tend vers 0.",
+  "page-ethereum-vs-bitcoin-monetary-policy-3": "<strong>Ethereum n'a pas de plafond d'approvisionnement fixe</strong>. Au lieu de cela, son émission est déterminée par les règles du protocole, et des mises à niveau récentes ont introduit des mécanismes qui peuvent réduire l'offre au fil du temps. La plus notable est la mise à niveau EIP-1559, qui brûle une partie des frais de transaction. Lorsque <strong>l'activité du réseau est élevée, plus d'ETH peuvent être brûlés</strong> qu'émis, ce qui rend l'offre déflationniste pendant ces périodes.",
+  "page-ethereum-vs-bitcoin-monetary-policy-4": "L'approche monétaire d'Ethereum garantit un budget de sécurité à perpétuité, les frais de transaction et les récompenses de bloc constituant le budget de sécurité du réseau.",
+  "page-ethereum-vs-bitcoin-developer-ecosystem-title": "Écosystème de développeurs",
+  "page-ethereum-vs-bitcoin-developer-ecosystem-1": "<strong>Ethereum</strong> possède l'une des <strong>plus grandes communautés de développeurs de blockchain</strong>. Développer sur Ethereum vous donne accès à un large éventail d'<strong>outils, de cadres de travail, de subventions</strong> et de <strong>hackathons</strong>. La machine virtuelle Ethereum (EVM) est l'environnement d'exécution d'Ethereum et est devenue une norme courante, de nombreuses autres blockchains l'utilisant pour garantir la compatibilité.",
+  "page-ethereum-vs-bitcoin-developer-ecosystem-2": "Les normes de jetons comme ERC-20 et ERC-721 sont devenues la base d'une grande partie de l'économie blockchain au sens large. De nombreux réseaux de couche 2 et d'autres blockchains utilisent l'EVM pour que le code des applications, des portefeuilles et des contrats intelligents puisse être utilisé sur différentes blockchains avec des changements minimes.",
+  "page-ethereum-vs-bitcoin-developer-ecosystem-3": "<strong>La communauté des développeurs de Bitcoin est plus petite</strong> et plus ciblée. La plupart des activités se concentrent sur la maintenance et l'amélioration du protocole de base, ainsi que sur le développement de solutions de couche 2 comme le Lightning Network pour des paiements plus rapides et moins chers.",
+  "page-ethereum-vs-bitcoin-developer-ecosystem-4": "En savoir plus sur les ressources pour les développeurs Ethereum",
+  "page-ethereum-vs-bitcoin-security-and-consensus-title": "Sécurité et consensus",
+  "page-ethereum-vs-bitcoin-security-and-consensus-1": "Le Bitcoin et l'Ethereum sont tous deux sécurisés par de vastes réseaux distribués de nœuds indépendants, mais ils utilisent des méthodes différentes pour s'accorder sur l'état du réseau.",
+  "page-ethereum-vs-bitcoin-security-and-consensus-2": "Bitcoin utilise un système appelé <strong>preuve de travail (proof-of-work)</strong>. Des ordinateurs appelés mineurs s'affrontent pour résoudre des énigmes cryptographiques. Le premier à en résoudre une peut ajouter le bloc de transactions suivant à la blockchain et gagne une récompense en bitcoins. Cette approche donne à Bitcoin ce que l'on appelle une finalité probabiliste, ce qui signifie qu'une transaction n'est considérée comme hautement sécurisée qu'après que plusieurs autres blocs aient été ajoutés par-dessus. Pour Bitcoin, cela correspond souvent à environ six confirmations, soit <strong>environ une heure</strong>.",
+  "page-ethereum-vs-bitcoin-security-and-consensus-3": "Ethereum utilise la <strong>preuve d'enjeu (proof-of-stake)</strong>. Dans ce modèle, les validateurs bloquent, ou mettent en jeu, des ETH pour avoir la chance d'être sélectionnés pour proposer et confirmer de nouveaux blocs. La sélection est aléatoire, mais la probabilité d'être choisi augmente avec la quantité d'ETH mis en jeu. Les validateurs qui agissent de manière malhonnête <strong>risquent de perdre leur mise</strong>. Cela permet à Ethereum d'atteindre une finalité économique, où les blocs finalisés sont extrêmement difficiles à annuler, souvent en <strong>environ 15 minutes</strong>. Ethereum utilise également des points de contrôle (checkpoints) pour marquer les blocs comme irréversibles une fois qu'un nombre suffisant de validateurs sont d'accord.",
+  "page-ethereum-vs-bitcoin-security-and-consensus-4": "En savoir plus sur le mécanisme de consensus d'Ethereum",
+  "page-ethereum-vs-bitcoin-underlying-technology-title": "Technologie sous-jacente",
+  "page-ethereum-vs-bitcoin-underlying-technology-1": "<strong>Bitcoin</strong> utilise ce que l'on appelle le <strong>modèle de sortie de transaction non dépensée</strong> (Unspent Transaction Output), ou UTXO. Dans ce système, la blockchain ne suit pas les soldes des comptes. Au lieu de cela, elle enregistre les sorties des transactions précédentes qui n'ont pas encore été dépensées. Lorsque vous dépensez des bitcoins, vous utilisez ces sorties comme entrées pour une nouvelle transaction, créant ainsi de nouvelles sorties.",
+  "page-ethereum-vs-bitcoin-underlying-technology-2": "Vous pouvez vous représenter cela comme si vous utilisiez de l'argent liquide. Si vous avez deux billets de cinq dollars et que vous voulez dépenser sept dollars, vous donnez les deux billets et recevez trois dollars en monnaie. Bitcoin enregistre les billets et la monnaie, pas votre solde total.",
+  "page-ethereum-vs-bitcoin-underlying-technology-3": "<strong>Ethereum</strong> utilise un <strong>modèle basé sur les comptes</strong>. Au lieu de suivre les sorties individuelles, il conserve un enregistrement des soldes des comptes, comme le fait un compte bancaire. Cette approche facilite la gestion des contrats intelligents et de la logique complexe, car les comptes peuvent stocker des données et interagir les uns avec les autres comme des programmes.",
+  "page-ethereum-vs-bitcoin-underlying-technology-4": "Chaque modèle a ses compromis. Les UTXO peuvent offrir une plus grande confidentialité et faciliter le suivi des pièces individuelles. Les systèmes basés sur les comptes sont plus simples pour créer des applications.",
+  "page-ethereum-vs-bitcoin-underlying-technology-5": "En savoir plus dans la documentation pour les développeurs Ethereum",
+  "page-ethereum-vs-bitcoin-decentralization-title": "Décentralisation",
+  "page-ethereum-vs-bitcoin-decentralization-1": "Le Bitcoin et l'Ethereum sont tous deux conçus pour être décentralisés, mais ils mesurent et abordent cette question de différentes manières.",
+  "page-ethereum-vs-bitcoin-decentralization-2": "La décentralisation de <strong>Bitcoin</strong> est soutenue par sa <strong>conception technique simple</strong>, sa stabilité à long terme et sa <strong>large distribution de nœuds</strong>. Ses faibles exigences en matière de ressources facilitent l'exécution de nœuds complets à domicile, ce qui contribue à préserver l'indépendance et la résistance à la censure du réseau.",
+  "page-ethereum-vs-bitcoin-decentralization-3": "<strong>Ethereum</strong> dispose également d'un réseau de nœuds important et en pleine croissance. Il met un fort accent sur la diversité des clients, ce qui signifie que plusieurs versions du logiciel sont <strong>maintenues par des équipes indépendantes</strong>. Cela réduit la dépendance à l'égard d'un seul client et aide à se protéger contre les bogues ou les pannes qui pourraient affecter le réseau.",
+  "page-ethereum-vs-bitcoin-decentralization-4": "Ethereum a <strong>un plus grand nombre de participants</strong> impliqués dans des activités comme la mise en jeu (staking), les mises à niveau et les discussions sur la gouvernance, mais <strong>les deux réseaux visent à rester ouverts et résilients</strong>. Bitcoin maintient les exigences des nœuds inchangées, en s'appuyant sur un plus petit nombre de clients logiciels. Ethereum encourage différents contributeurs, chacun apportant sa propre perspective.",
+  "page-ethereum-vs-bitcoin-environmental-impact-title": "Impact environnemental",
+  "page-ethereum-vs-bitcoin-environmental-impact-1": "L'un des changements les plus importants de l'histoire d'Ethereum a été le passage de la preuve de travail à la <strong>preuve d'enjeu</strong> en 2022. Connue sous le nom de La Fusion (The Merge), cette transition a <strong>réduit la consommation d'énergie du réseau de plus de 99 %</strong>.",
+  "page-ethereum-vs-bitcoin-environmental-impact-2": "Avec la preuve d'enjeu, Ethereum ne dépend plus du minage énergivore. Au lieu de cela, les validateurs sont sélectionnés au hasard, la probabilité de sélection augmentant avec la quantité d'ETH qu'ils ont mis en jeu. Ce changement a fait d'Ethereum l'un des réseaux blockchain les plus économes en énergie.",
+  "page-ethereum-vs-bitcoin-environmental-impact-3": "Bitcoin continue d'utiliser la <strong>preuve de travail</strong>, qui <strong>nécessite de grandes quantités d'électricité</strong> car les mineurs s'affrontent pour résoudre des énigmes cryptographiques. Une partie de cette énergie provient de sources renouvelables, et des discussions sont en cours au sein de la communauté Bitcoin sur les moyens d'améliorer la durabilité.",
+  "page-ethereum-vs-bitcoin-environmental-impact-4": "La différence de consommation d'énergie est devenue un point de comparaison important entre les deux réseaux. L'empreinte énergétique plus faible d'Ethereum le rend plus attrayant dans les contextes où l'impact environnemental est une priorité.",
+  "page-ethereum-vs-bitcoin-environmental-impact-5": "Lire le rapport complet sur la consommation d'énergie d'Ethereum",
+  "page-ethereum-vs-bitcoin-future-outlook-title": "À quoi ressemble l'avenir",
+  "page-ethereum-vs-bitcoin-future-outlook-1": "Le Bitcoin est de plus en plus adopté comme réserve de valeur et actif de réserve. Il est peu probable qu'il change de manière significative, et cette stabilité fait partie de son attrait.",
+  "page-ethereum-vs-bitcoin-future-outlook-2": "Ethereum se positionne comme une plateforme d'applications dans la nouvelle économie numérique. Avec la croissance des réseaux de couche 2 et les mises à niveau continues, il vise à prendre en charge des applications, des infrastructures et des actifs à l'échelle mondiale.",
+  "page-ethereum-vs-bitcoin-future-outlook-3": "Pour de nombreux utilisateurs, <strong>les deux réseaux ne sont pas en concurrence directe</strong>. Ils servent des objectifs différents et peuvent se compléter dans une approche diversifiée des actifs numériques.",
+  "page-ethereum-vs-bitcoin-future-outlook-4": "En savoir plus sur la feuille de route d'Ethereum"
+}
\ No newline at end of file
diff --git a/src/intl/fr/page-founders.json b/src/intl/fr/page-founders.json
new file mode 100644
index 00000000000..600c7ff90d0
--- /dev/null
+++ b/src/intl/fr/page-founders.json
@@ -0,0 +1,65 @@
+{
+  "page-founders-accelerators-alliance-description": "Alliance est le principal accélérateur de cryptomonnaies et la principale communauté de fondateurs. Les startups en IA sont maintenant acceptées.",
+  "page-founders-accelerators-alliance-highlight-1": "Financement de 500 000 $",
+  "page-founders-accelerators-base-description": "Base Batches est un programme mondial pour les développeurs qui créent la prochaine vague d'applications en chaîne.",
+  "page-founders-accelerators-base-highlight-1": "Jusqu'à 1 million de dollars de financement",
+  "page-founders-accelerators-growth-label": "Accélérateurs et croissance",
+  "page-founders-accelerators-kernel-description": "Kernel, c'est construire lentement, grâce à des interactions répétées avec des pairs.",
+  "page-founders-accelerators-kernel-highlight-1": "Plus de 2 200 membres",
+  "page-founders-accelerators-kernel-highlight-2": "Plus de 150 projets actifs",
+  "page-founders-apply-h2": "Demander de l'aide",
+  "page-founders-apply-p1": "Choisissez votre parcours et soyez orienté vers l'étape suivante la plus pertinente.",
+  "page-founders-cta-explore-name": "Explorer {name}",
+  "page-founders-cta-visit-name": "Visiter {name}",
+  "page-founders-description": "Une plateforme dédiée aux entrepreneurs pour accéder à des programmes, à du mentorat et à de la visibilité dans tout l'écosystème Ethereum, offrant aux fondateurs le soutien dont ils ont besoin à chaque étape.",
+  "page-founders-funding-arbitrum-description": "La mission est de donner aux développeurs et aux entrepreneurs les moyens de créer des DApps percutantes qui tirent parti des capacités du réseau Arbitrum.",
+  "page-founders-funding-arbitrum-highlight-1": "Plus de 300 projets soutenus",
+  "page-founders-funding-base-description": "Les subventions Builder Grants sont des expériences continues visant à récompenser les développeurs de Base.",
+  "page-founders-funding-base-highlight-1": "Subventions de 1 à 5 ETH",
+  "page-founders-funding-esp-description": "Allouer des ressources aux projets critiques, être une voix appréciée au sein de l'écosystème Ethereum et promouvoir Ethereum dans le monde extérieur.",
+  "page-founders-funding-esp-highlight-1": "Plus de 2 000 projets soutenus",
+  "page-founders-funding-label": "Financement",
+  "page-founders-funding-optimism-description": "Soutien aux développeurs individuels et aux équipes créant des applications en chaîne, des outils et une infrastructure pour faire progresser la Superchain.",
+  "page-founders-funding-optimism-highlight-1": "19 chaînes éligibles",
+  "page-founders-funding-optimism-highlight-2": "Plus de 700 projets soutenus",
+  "page-founders-funding-polygon-description": "Un programme de subventions communautaires pour soutenir les développeurs, les équipes et les créateurs qui s'engagent dans la croissance de Polygon.",
+  "page-founders-funding-polygon-highlight-1": "Développer ou migrer sur Polygon",
+  "page-founders-funding-unichain-description": "Une série de programmes et de ressources conçus pour soutenir la communauté de développeurs émergente d'Unichain.",
+  "page-founders-funding-unichain-highlight-1": "Nouveaux mécanismes DeFi",
+  "page-founders-get-in-touch-cta": "Demander de l'aide",
+  "page-founders-get-in-touch-h2": "Équipe de réussite des fondateurs de la Fondation Ethereum",
+  "page-founders-get-in-touch-p1": "Le programme Founder Success s'adresse aux développeurs ayant des idées audacieuses, aux entrepreneurs qui considèrent Ethereum comme le fondement de produits et d'entreprises capables de façonner l'avenir.",
+  "page-founders-metadata-description": "Donner aux fondateurs sur Ethereum les moyens d'agir grâce à des programmes, du mentorat et des ressources. Découvrez comment l'écosystème Ethereum soutient les entrepreneurs, de l'idée à la croissance.",
+  "page-founders-metadata-title": "Aide aux fondateurs",
+  "page-founders-partnerships-devconnect-description": "Devconnect ARG est l'Exposition universelle d'Ethereum : une vitrine d'applications et un événement pour se connecter, développer et accélérer l'adoption d'Ethereum.",
+  "page-founders-partnerships-ef-founder-support-cta": "Planifier un entretien de présentation",
+  "page-founders-partnerships-ef-founder-support-description": "Coordination du partage des revenus, de la liquidité et des partenariats. L'équipe de réussite des fondateurs de l'EF aide à mettre en relation les bonnes équipes pour que cela se produise.",
+  "page-founders-partnerships-ef-founder-support-subtitle": "Présentations aux protocoles/équipes DeFi",
+  "page-founders-partnerships-ens-description": "Le programme vise à soutenir les projets qui ont démontré une utilité et un impact exceptionnels pour les développeurs comme pour les utilisateurs.",
+  "page-founders-partnerships-ens-highlight-1": "Petites subventions jusqu'à 2 ETH",
+  "page-founders-partnerships-ens-highlight-2": "Grandes subventions jusqu'à 50 000 USDC",
+  "page-founders-partnerships-ethglobal-description": "Des événements mondiaux qui favorisent un écosystème de classe mondiale de développeurs et d'entrepreneurs Ethereum.",
+  "page-founders-partnerships-label": "Partenariats et intégrations",
+  "page-founders-partnerships-protocol-guild-description": "Organisation de financement indépendante pour les développeurs principaux d'Ethereum. Nous finançons de manière proactive les mainteneurs dont le travail est essentiel à l'écosystème.",
+  "page-founders-partnerships-protocol-guild-highlight-1": "28 M$ levés pour les développeurs principaux",
+  "page-founders-partnerships-unichain-description": "Une série de programmes et de ressources conçus pour soutenir la communauté de développeurs émergente d'Unichain.",
+  "page-founders-partnerships-unichain-highlight-1": "Nouveaux mécanismes DeFi",
+  "page-founders-story-dith-p1": "Le soutien aux fondateurs de l'EF a été excellent, ils ont été un excellent partenaire de réflexion impartial et un conseiller pour nous alors que nous terminions notre première levée de fonds. Je n'hésite pas à recommander à d'autres fondateurs EVM de les contacter.",
+  "page-founders-story-fahim-p1": "L'équipe de réussite des fondateurs est un atout majeur pour l'écosystème Ethereum. Ils se soucient vraiment d'aider les équipes à réussir, et leur soutien pratique et leur engagement sincère à aider des équipes comme Optimism sont évidents. Je suis ravi de continuer à collaborer avec eux et de renforcer notre écosystème ensemble.",
+  "page-founders-story-kedian-p1": "Notre contact à l'EF a joué un rôle essentiel en nous guidant, non seulement en partageant des informations précieuses sur notre prochaine fonctionnalité, mais aussi en nous présentant des L2 clés de l'écosystème Ethereum.",
+  "page-founders-story-kedian-p2": "Grâce à leurs retours sur notre stratégie de commercialisation, nous avons accéléré la prise de décision, réduit le temps consacré à la recherche et nous sommes concentrés directement sur l'exécution.",
+  "page-founders-succeed-h2": "Comment d'autres ont réussi",
+  "page-founders-succeed-p1": "Vous n'êtes pas obligé de développer seul, cet écosystème vous soutient.",
+  "page-founders-support-tag-accelerator": "Accélérateur",
+  "page-founders-support-tag-active": "Actif",
+  "page-founders-support-tag-audit-grants": "Subventions d'audit",
+  "page-founders-support-tag-ecosystem-events": "Événements de l'écosystème",
+  "page-founders-support-tag-events": "Évènements",
+  "page-founders-support-tag-fundraising": "Collecte de fonds",
+  "page-founders-support-tag-grant-program": "Programme de subventions",
+  "page-founders-support-tag-mentorship": "Mentorat",
+  "page-founders-support-tag-networking": "Réseautage",
+  "page-founders-support-tag-public-goods": "Biens publics",
+  "page-founders-support-tag-tooling-infra": "Outils et infrastructure",
+  "page-founders-title": "Donner les moyens aux fondateurs sur Ethereum"
+}
diff --git a/src/intl/fr/page-gas.json b/src/intl/fr/page-gas.json
index 46441fa21c5..ee86f887e16 100644
--- a/src/intl/fr/page-gas.json
+++ b/src/intl/fr/page-gas.json
@@ -19,7 +19,7 @@
   "page-gas-how-do-i-pay-less-gas-card-1-description": "Tout comme les voyages en dehors des heures de pointe sont moins fréquentés et plus abordables, l'Ethereum est généralement moins cher à utiliser lorsque l'Amérique du Nord est endormie.",
   "page-gas-how-do-i-pay-less-gas-card-2-title": "Attendre la baisse du prix du gaz",
   "page-gas-how-do-i-pay-less-gas-card-2-description": "Les prix du gaz augmentent et diminuent toutes les douze secondes en fonction de l'encombrement d'Ethereum. Lorsque le prix du gaz est élevé, le fait d'attendre quelques minutes avant d'effectuer une transaction peut entraîner une baisse significative du prix à payer.",
-  "page-gas-how-do-i-pay-less-gas-card-3-title": "Utiliser la couche 2",
+  "page-gas-how-do-i-pay-less-gas-card-3-title": "Utilisez la couche 2",
   "page-gas-how-do-i-pay-less-gas-card-3-description": "Les couches de niveau 2 sont construites sur Ethereum, proposent des frais moins élevés et traitent davantage de transactions. Elles constituent un bon choix pour économiser des frais sur les transactions qui n'ont pas besoin d'être effectuées sur le réseau Ethereum principal.",
   "page-gas-try-layer-2": "Essayez la couche 2",
   "page-gas-what-causes-high-gas-fees-header": "Quelles sont les causes des frais de gaz élevés ?",
@@ -56,9 +56,9 @@
   "page-gas-faq-question-1-a-2": "Vous pouvez lire une description détaillée du processus dans <a href=\"/developers/docs/gas/\">la documentation destinée aux développeurs de gaz.</a>",
   "page-gas-faq-question-2-q": "Dois-je payer le gaz en ETH ?",
   "page-gas-faq-question-2-a-1": "Oui. Tous les frais de gaz sur Ethereum doivent être payés dans la devise native ETH.",
-  "page-gas-faq-question-2-a-2": "Plus d'infos sur ETH",
+  "page-gas-faq-question-2-a-2": "Autres informations sur ETH",
   "page-gas-faq-question-3-q": "Qu'est-ce que le gwei ?",
   "page-gas-faq-question-3-a-1": "Dans la plupart des portefeuilles ou des systèmes de suivi du gaz, les prix du gaz sont exprimés en 'gwei'.",
   "page-gas-faq-question-3-a-2": "Le Gwei est une unité plus petite de l'ETH, comme les centimes le sont pour les dollars, à la différence que 1 ETH équivaut à 1 milliard de Gwei. Le Gwei est utile lorsqu'il s'agit de très petites quantités d'ETH.",
-  "page-gas-use-layer-2": "Utiliser la couche 2"
+  "page-gas-use-layer-2": "Utilisez la couche 2"
 }
diff --git a/src/intl/fr/page-history.json b/src/intl/fr/page-history.json
index 41478e9c563..5540056b93f 100644
--- a/src/intl/fr/page-history.json
+++ b/src/intl/fr/page-history.json
@@ -1,7 +1,7 @@
 {
-  "page-history-slot-number": "Numéro d’emplacement",
+  "page-history-slot-number": "Numéro de créneau",
   "page-history-block-number": "Numéro de bloc",
-  "page-history-epoch-number": "Numéro d'Époque",
-  "page-history-ethereum-org-wayback": "ethereum.org sur waybackmachine",
-  "page-history-eth-price": "Prix ETH"
+  "page-history-epoch-number": "Numéro d'epoch",
+  "page-history-ethereum-org-wayback": "ethereum.org sur la Wayback Machine",
+  "page-history-eth-price": "Prix de l'ETH"
 }
diff --git a/src/intl/fr/page-layer-2-learn.json b/src/intl/fr/page-layer-2-learn.json
index 74a5dad851c..fc7f59eb2f0 100644
--- a/src/intl/fr/page-layer-2-learn.json
+++ b/src/intl/fr/page-layer-2-learn.json
@@ -1,9 +1,9 @@
 {
-  "page-layer-2-learn-meta-title": "Qu'est-ce que la couche 2 ? | ethereum.org",
+  "page-layer-2-learn-meta-title": "Qu'est-ce que la couche 2 ? | ethereum.org",
   "page-layer-2-learn-title": "Qu'est-ce que la couche 2 ?",
   "page-layer-2-learn-description": "Faire évoluer Ethereum pour une adoption massive",
   "page-layer-2-learn-button-1-label": "Qu'est-ce que la couche 2 ?",
-  "page-layer-2-learn-button-2-label": "Utiliser la couche 2",
+  "page-layer-2-learn-button-2-label": "Utilisez la couche 2",
   "page-layer-2-learn-what-is-layer-2-title": "Qu'est-ce que la couche 2 ?",
   "page-layer-2-learn-what-is-layer-2-1": "Couche 2 (L2) est un terme collectif décrivant un ensemble spécifique de solutions de mise à l'échelle d'Ethereum. <strong>Une couche 2 est une <a href=\"/glossary/#blockchain\">blockchain</a> séparée qui étend Ethereum et hérite des garanties de sécurité d'Ethereum</strong>.",
   "page-layer-2-learn-what-is-layer-2-2": "Maintenant, creusons un peu plus le sujet. Pour ce faire, nous devons d'abord expliquer la couche 1 (L1).",
@@ -19,7 +19,7 @@
   "page-layer-2-learn-why-do-we-need-layer-2-1": "Les trois propriétés souhaitables d’une blockchain sont la décentralisation, la sécurité et la scalabilité. Le trilemme de la blockchain stipule qu’une architecture blockchain simple ne peut en atteindre que deux sur trois. Vous voulez une blockchain sécurisée et décentralisée ? Il faut alors sacrifier la scalabilité. C’est là que les réseaux de seconde couche entrent en jeu.",
   "page-layer-2-learn-why-do-we-need-layer-2-2": "Ethereum a atteint la capacité actuelle de son réseau avec plus d’un million de transactions par jour, chacune faisant l’objet d’une forte demande. Le succès d’Ethereum et l’engouement pour son utilisation ont entraîné une hausse significative des prix du gaz. Par conséquent, le besoin en solutions d'évolutivité a lui aussi augmenté.",
   "page-layer-2-learn-why-do-we-need-layer-2-scalability": "Évolutivité",
-  "page-layer-2-learn-why-do-we-need-layer-2-scalability-1": "L'objectif principal de l'évolutivité est d'augmenter la vitesse de transaction (finalisation plus rapide) et le débit des transactions (nombre élevé de transactions par seconde), sans sacrifier la décentralisation ou la sécurité.",
+  "page-layer-2-learn-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é.",
   "page-layer-2-learn-why-do-we-need-layer-2-scalability-2": "La communauté Ethereum a pris une position ferme : elle ne sacrifiera pas la décentralisation ni la sécurité au profit de l'évolutivité. En attendant la fragmentation, le réseau principal d’Ethereum (couche 1) ne pourra traiter qu’environ 15 transactions par seconde. Lorsque la demande d’utilisation d’Ethereum est élevée, cela provoque une congestion du réseau, augmente les frais de transaction et exclut ceux qui n'ont pas les moyens d'utiliser Ethereum jusqu'à ce que les frais diminuent. C’est là qu’intervient la couche 2, pour faire évoluer Ethereum dès aujourd’hui.",
   "page-layer-2-learn-layer2Cards-1-title": "Des frais plus bas",
   "page-layer-2-learn-layer2Cards-1-description": "Le regroupement de plusieurs transactions en une seule transaction sur la couche 1 permet de réduire considérablement les frais de transaction, rendant ainsi Ethereum plus accessible à tous.",
@@ -30,10 +30,10 @@
   "page-layer-2-learn-how-does-layer-2-work-title": "Comment la couche 2 fonctionne-t-elle ?",
   "page-layer-2-learn-how-does-layer-2-work-1": "Comme mentionné précédemment, la couche 2 est un terme générique désignant les solutions d'évolutivité d'Ethereum qui traitent les transactions hors de la couche 1 d'Ethereum tout en continuant à bénéficier de la sécurité décentralisée et robuste de la couche 1 d'Ethereum. Une couche 2 est une blockchain distincte qui étend Ethereum. Comment cela fonctionne-t-il ?",
   "page-layer-2-learn-how-does-layer-2-work-2": "Il existe différents types de couche 2, chacune ayant ses propres compromis et modèles de sécurité. Les couches 2 allègent la charge transactionnelle de la couche 1, ce qui permet de réduire sa congestion et d'améliorer l'évolutivité de l'ensemble.",
-  "page-layer-2-learn-how-does-layer-2-work-rollups-title": "Rollups",
+  "page-layer-2-learn-how-does-layer-2-work-rollups-title": "rollups",
   "page-layer-2-learn-how-does-layer-2-work-rollups-1": "Les rollups regroupent (ou « roll up ») des centaines de transactions en une seule transaction sur la couche principale. Cela permet de répartir les frais de transaction de la couche principale entre tous les utilisateurs du rollup, ce qui réduit le coût pour chacun.",
   "page-layer-2-learn-how-does-layer-2-work-rollups-2": "Les données de transaction dans le rollup sont soumises à la couche 1, mais l'exécution est effectuée séparément par le rollup. En soumettant les données de transaction sur la couche 1, les rollups héritent de la sécurité d'Ethereum. En effet, une fois les données téléchargées sur la couche 1, l’annulation d’une transaction de rollup nécessite l’annulation d’Ethereum. Il existe deux approches différentes des rollups : optimiste et à divulgation nulle de connaissance. Celles-ci diffèrent principalement par la manière dont ces données de transaction sont soumises à la couche 1.",
-  "page-layer-2-learn-rollupCards-optimistic-title": "Rollups optimistes",
+  "page-layer-2-learn-rollupCards-optimistic-title": "Rollups optimisés",
   "page-layer-2-learn-rollupCards-optimistic-description": "Les rollups optimistes utilisent des preuves de fraude où les transactions sont supposées valides, mais peuvent être contestées si une transaction invalide est suspectée. En cas de suspicion, une preuve de fraude est exécutée pour vérifier si une transaction invalide a effectivement eu lieu.",
   "page-layer-2-learn-rollupCards-optimistic-childSentence": "En savoir plus sur les rollups optimistes",
   "page-layer-2-learn-rollupCards-zk-title": "Rollups à divulgation nulle de connaissance",
diff --git a/src/intl/fr/page-layer-2-networks.json b/src/intl/fr/page-layer-2-networks.json
index c35642d876e..9846e4033c9 100644
--- a/src/intl/fr/page-layer-2-networks.json
+++ b/src/intl/fr/page-layer-2-networks.json
@@ -7,7 +7,7 @@
   "page-layer-2-networks-more-advanced-descripton-3": "Pour en savoir plus sur la technologie, les risques et les mécanismes de confiance propres à ces réseaux, nous vous recommandons de consulter L2BEAT, qui propose un cadre d’évaluation des risques complet pour chaque projet, ainsi que growthepie, qui fournit des analyses de données générales.",
   "page-layer-2-networks-more-advanced-link-1": "Consultez le site l2beat.com",
   "page-layer-2-networks-more-advanced-link-2": "Consultez le site growthepie.com",
-  "page-layer-2-networks-callout-1-title": "Quels sont les avantages?",
+  "page-layer-2-networks-callout-1-title": "Quels sont les avantages ?",
   "page-layer-2-networks-callout-1-description": "La robustesse et la sécurité d’Ethereum permettent d'obtenir une plateforme sur laquelle d’autres réseaux peuvent se construire.",
   "page-layer-2-networks-callout-2-title": "Envie d’en savoir plus ?",
   "page-layer-2-networks-callout-2-description": "Vous souhaitez connaître la technologie et les raisons derrière cette approche de mise à l’échelle ? Découvrez les réflexions et les différentes approches technologiques qui la sous-tendent.",
@@ -72,7 +72,7 @@
   "page-layer-2-network-maturity-component-6": "Ces niveaux aident à suivre le développement du réseau et fournissent à la communauté un moyen normalisé d'évaluer les progrès accomplis.",
   "page-layer-2-network-maturity-component-7": "Le progrès technique à lui seul ne suffit pas : l’adoption par les utilisateurs et l’ancienneté sont des éléments essentiels de la solidité et de la maturité globales de tout réseau.",
   "page-layer-2-network-maturity-component-8": "Maturité",
-  "page-layer-2-network-maturity-component-9": "Conditions requises",
+  "page-layer-2-network-maturity-component-9": "Prérequis",
   "page-layer-2-network-maturity-component-10": "• Phase 2",
   "page-layer-2-network-maturity-component-11": "• Au moins 1 milliard de dollars de TVL",
   "page-layer-2-network-maturity-component-12": "• Phase 1",
diff --git a/src/intl/fr/page-layer-2.json b/src/intl/fr/page-layer-2.json
index c5e37e3f1c8..d15709857b6 100644
--- a/src/intl/fr/page-layer-2.json
+++ b/src/intl/fr/page-layer-2.json
@@ -1,58 +1,61 @@
 {
-    "page-layer-2-hero-title": "Couche 2",
-    "page-layer-2-hero-header": "Réseaux Ethereum",
-    "page-layer-2-hero-description": "Utilisez Ethereum à moindre coût.",
-    "page-layer-2-hero-button-2-content": "En savoir plus",
-    "page-layer-2-period": ".",
-    "page-layer-2-calloutCard-1-title": "Frais de 0,01 $",
-    "page-layer-2-calloutCard-1-description": "Vous pouvez échanger, envoyer de l'argent à l'international ou utiliser des applications sans vous soucier des coûts élevés.",
-    "page-layer-2-calloutCard-2-title": "Transactions quasi instantanées",
-    "page-layer-2-calloutCard-2-description": "Que vous réalisiez un paiement rapide ou que vous pratiquiez la finance décentralisée (DeFi), toutes les transactions sont réalisées en seulement quelques secondes.",
-    "page-layer-2-calloutCard-3-title": "Soutenu par Ethereum",
-    "page-layer-2-calloutCard-3-description": "La blockchain décentralisée et éprouvée d'Ethereum fonctionne comme la couche de règlement pour d'autres réseaux plus récents.",
-    "page-layer-2-meta-title": "Introduction à la couche 2 d'Ethereum : avantages et utilisations",
-    "page-layer-2-meta-description": "Explorez les différentes couches de niveau 2 du réseau Ethereum",
-    "page-layer-2-powered-by-ethereum-title": "Alimenté par Ethereum",
-    "page-layer-2-powered-by-ethereum-description-1": "Ethereum n'est plus un réseau isolé.",
-    "page-layer-2-powered-by-ethereum-description-2": "Avec des centaines de blockchains désormais construites au-dessus de lui, Ethereum est devenu plus économique, plus rapide et plus accessible pour un usage quotidien.",
-    "page-layer-2-powered-by-ethereum-description-3": "Adoptez le futur en rejoignant l’un des nombreux réseaux fonctionnant grâce à Ethereum !",
-    "page-layer-2-man-and-dog-alt": "Un homme et un chien en train de jouer",
-    "page-layer-2-blockchain-transaction-cost": "Coût moyen d'une transaction sur la blockchain Ethereum",
-    "page-layer-2-networks-transaction-cost": "Coût moyen d'une transaction sur les réseaux basés sur Ethereum",
-    "page-layer-2-network-of-networks-title": "Le réseau des réseaux",
-    "page-layer-2-network-of-networks-description": "La solidité et la sécurité d’Ethereum en font une plateforme sur laquelle d’autres réseaux peuvent s'appuyer. À partir d'un compte unique, tout est compatible et se connecte de manière transparente.",
-    "page-layer-2-ethereum-logo-alt": "Ethereum",
-    "page-layer-2-ready-to-start-title": "Prêt à commencer ?",
-    "page-layer-2-ready-to-start-description": "Jetez un coup d'œil à tous les différents réseaux disponibles.",
-    "page-layer-2-ready-to-start-button": "Explorer les réseaux",
-    "page-layer-2-go": "Aller",
-    "page-layer-2-walking-alt": "Marche",
-    "page-layer-2-why-do-we-need-multiple-networks-1": "Pourquoi avons-nous besoin de plusieurs réseaux sur Ethereum ?",
-    "page-layer-2-why-do-we-need-multiple-networks-2": "Pourquoi existe-t-il tous ces réseaux au lieu d’un seul réseau Ethereum ?",
-    "page-layer-2-faq-title": "Questions fréquemment posées",
-    "page-layer-2-faq-ExpandableCard-1-title": "Comment savoir si un réseau fait partie d’Ethereum ?",
-    "page-layer-2-faq-ExpandableCard-1-description-1": "Il existe de nombreuses façons de classer les réseaux en lien avec Ethereum. De nombreux réseaux affirment mettre Ethereum à l'échelle pour gagner en popularité. Il est toutefois important de savoir si le réseau stocke ses données sur le réseau principal Ethereum. Cela renforce grandement la sécurité des utilisateurs ainsi que la vision décentralisée et ouverte d’Ethereum. Les projets qui suivent ce modèle sont souvent appelés des « rollups ». Si les données sont stockées ailleurs, alors le projet n’est pas une extension directe d’Ethereum, mais plutôt un réseau indépendant. Découvrez quelques-uns des plus populaires",
-    "page-layer-2-faq-ExpandableCard-1-description-2": "Certaines industries spécifiques, comme celles des jeux vidéo ou des applications non financières, n’ont pas forcément besoin d’une relation aussi directe et étroite avec Ethereum, car d’autres technologies peuvent mieux convenir à leurs besoins.",
-    "page-layer-2-faq-ExpandableCard-2-title": "Tous ces réseaux sont-ils sûrs ?",
-    "page-layer-2-faq-ExpandableCard-2-description-1": "Bien qu’ils soient généralement conçus de manière à offrir des fonctionnalités de sécurité robustes, leur sûreté dépend de la technologie sous-jacente, de la sécurité des contrats intelligents, et",
-    "page-layer-2-faq-ExpandableCard-2-link": "maturité du réseau",
-    "page-layer-2-faq-ExpandableCard-2-description-2": "Les utilisateurs devraient faire preuve de vigilance, commencer par de petites transactions et se tenir informés des évolutions pour garantir une utilisation sécurisée.",
-    "page-layer-2-faq-ExpandableCard-3-title": "Pourquoi Ethereum ne peut-il pas faire évoluer sa propre chaîne au lieu de dépendre de ces réseaux ?",
-    "page-layer-2-faq-ExpandableCard-3-description": "Ethereum ne peut pas facilement faire évoluer sa propre chaîne principale, car elle doit rester sécurisée et décentralisée. Rendre la chaîne principale plus rapide pourrait la rendre moins sûre et plus centralisée. Les réseaux d'Ethereum apportent une solution en traitant les transactions en dehors de la chaîne principale, puis en utilisant celle-ci pour garantir la sécurité. Cela permet à Ethereum de gérer un plus grand nombre de transactions sans compromettre ni la sécurité ni la décentralisation.",
-    "page-layer-2-faq-ExpandableCard-4-title": "Pourquoi n'y a-t-il pas de réseaux Ethereum « officiels » ?",
-    "page-layer-2-faq-ExpandableCard-4-description": "Tout comme il n'y a pas de client Ethereum « officiel », il n'existe pas de couche 2 Ethereum « officielle ». Ethereum fonctionne sans autorisation - techniquement n'importe qui peut créer une couche 2 ! Plusieurs équipes implémenteront leur version d'une couche 2, et l'écosystème dans son ensemble bénéficiera d'une diversité d'approches de conception optimisées pour différents cas d'utilisation. À l'instar des multiples clients Ethereum développés par plusieurs équipes afin d'assurer la diversité du réseau, les couches 2 se développeront de la même manière à l'avenir.",
-    "page-layer-2-callout-1-title": "Explore différents réseaux",
-    "page-layer-2-callout-1-description": "Découvrez en quoi les réseaux diffèrent les uns des autres et les progrès réalisés dans leur développement.",
-    "page-layer-2-callout-2-title": "Envie d’en savoir plus ?",
-    "page-layer-2-callout-2-description": "Vous souhaitez connaître la technologie et les raisons derrière cette approche de mise à l’échelle ? Découvrez les réflexions et les différentes approches technologiques qui la sous-tendent.",
-    "page-layer-2-arbitrum-description": "Arbitrum One est un rollup optimiste à usage général, développé par Offchain Labs et gouverné par l'Arbitrum DAO.",
-    "page-layer-2-base-description": "Base est un rollup optimiste construit avec l’OP Stack. Il propose une solution économique et conviviale pour les développeurs, permettant à chacun, partout dans le monde, de construire sur la chaîne.",
-    "page-layer-2-optimism-description": "OP Mainnet est un rollup optimiste équivalent à l’EVM. Il se veut rapide, simple et sécurisé.",
-    "page-layer-2-blast-description": "Blast est un rollup optimiste compatible avec l’EVM, offrant un rendement natif intégré.",
-    "page-layer-2-zksync2-description": "ZKsync Era est un rollup ZK à usage général entièrement compatible avec l’EVM.",
-    "page-layer-2-linea-description": "Linea est un rollup ZK propulsé par le zkEVM de Consensys, conçu pour faire évoluer le réseau Ethereum.",
-    "page-layer-2-scroll-description": "Scroll est un rollup ZK qui étend les capacités d’Ethereum grâce à la technologie ZK et à la compatibilité avec l’EVM.",
-    "page-layer-2-starknet-description": "Starknet est un rollup ZK à usage général basé sur les STARKs et la machine virtuelle Cairo.",
-    "page-layer-2-mode-description": "Mode est un rollup optimiste basé sur l’OP Stack, qui construit l’économie AIFi.",
-    "page-layer-2-taiko-description": "Taiko est un rollup ZK-EVM décentralisé, équivalent à Ethereum, qui permet une communication inter-chaînes fluide."
+  "page-layer-2-hero-title": "Couche de niveau 2",
+  "page-layer-2-hero-header": "Réseaux Ethereum",
+  "page-layer-2-hero-description": "Utilisez Ethereum à moindre coût.",
+  "page-layer-2-hero-button-2-content": "En savoir plus",
+  "page-layer-2-period": ".",
+  "page-layer-2-calloutCard-1-title": "Frais de 0,01 $",
+  "page-layer-2-calloutCard-1-description": "Vous pouvez échanger, envoyer de l'argent à l'international ou utiliser des applications sans vous soucier des coûts élevés.",
+  "page-layer-2-calloutCard-2-title": "Transactions quasi instantanées",
+  "page-layer-2-calloutCard-2-description": "Que vous réalisiez un paiement rapide ou que vous pratiquiez la finance décentralisée (DeFi), toutes les transactions sont réalisées en seulement quelques secondes.",
+  "page-layer-2-calloutCard-3-title": "Soutenu par Ethereum",
+  "page-layer-2-calloutCard-3-description": "La blockchain décentralisée et éprouvée d'Ethereum fonctionne comme la couche de règlement pour d'autres réseaux plus récents.",
+  "page-layer-2-meta-title": "Introduction à la couche 2 d'Ethereum : avantages et utilisations",
+  "page-layer-2-meta-description": "Explorez les différentes couches de niveau 2 du réseau Ethereum",
+  "page-layer-2-powered-by-ethereum-title": "Alimenté par Ethereum",
+  "page-layer-2-powered-by-ethereum-description-1": "Ethereum n'est plus un réseau isolé.",
+  "page-layer-2-powered-by-ethereum-description-2": "Avec des centaines de blockchains désormais construites au-dessus de lui, Ethereum est devenu plus économique, plus rapide et plus accessible pour un usage quotidien.",
+  "page-layer-2-powered-by-ethereum-description-3": "Adoptez le futur en rejoignant l’un des nombreux réseaux fonctionnant grâce à Ethereum !",
+  "page-layer-2-man-and-dog-alt": "Un homme et un chien en train de jouer",
+  "page-layer-2-blockchain-transaction-cost": "Coût moyen d'une transaction sur la blockchain Ethereum",
+  "page-layer-2-networks-transaction-cost": "Coût moyen d'une transaction sur les réseaux basés sur Ethereum",
+  "page-layer-2-network-of-networks-title": "Le réseau des réseaux",
+  "page-layer-2-network-of-networks-description": "La solidité et la sécurité d’Ethereum en font une plateforme sur laquelle d’autres réseaux peuvent s'appuyer. À partir d'un compte unique, tout est compatible et se connecte de manière transparente.",
+  "page-layer-2-ethereum-logo-alt": "Ethereum",
+  "page-layer-2-ready-to-start-title": "Prêt à commencer ?",
+  "page-layer-2-ready-to-start-description": "Jetez un coup d'œil à tous les différents réseaux disponibles.",
+  "page-layer-2-ready-to-start-button": "Explorer les réseaux",
+  "page-layer-2-go": "Go",
+  "page-layer-2-walking-alt": "Marche",
+  "page-layer-2-why-do-we-need-multiple-networks-1": "Pourquoi avons-nous besoin de plusieurs réseaux sur Ethereum ?",
+  "page-layer-2-why-do-we-need-multiple-networks-2": "Pourquoi existe-t-il tous ces réseaux au lieu d’un seul réseau Ethereum ?",
+  "page-layer-2-faq-title": "Questions fréquemment posées",
+  "page-layer-2-faq-ExpandableCard-1-title": "Comment savoir si un réseau fait partie d’Ethereum ?",
+  "page-layer-2-faq-ExpandableCard-1-description-1": "Il existe de nombreuses façons de classer les réseaux en lien avec Ethereum. De nombreux réseaux affirment mettre Ethereum à l'échelle pour gagner en popularité. Il est toutefois important de savoir si le réseau stocke ses données sur le réseau principal Ethereum. Cela renforce grandement la sécurité des utilisateurs ainsi que la vision décentralisée et ouverte d’Ethereum. Les projets qui suivent ce modèle sont souvent appelés des « rollups ». Si les données sont stockées ailleurs, alors le projet n’est pas une extension directe d’Ethereum, mais plutôt un réseau indépendant. Découvrez quelques-uns des plus populaires",
+  "page-layer-2-faq-ExpandableCard-1-description-2": "Certaines industries spécifiques, comme celles des jeux vidéo ou des applications non financières, n’ont pas forcément besoin d’une relation aussi directe et étroite avec Ethereum, car d’autres technologies peuvent mieux convenir à leurs besoins.",
+  "page-layer-2-faq-ExpandableCard-2-title": "Tous ces réseaux sont-ils sûrs ?",
+  "page-layer-2-faq-ExpandableCard-2-description-1": "Bien qu’ils soient généralement conçus de manière à offrir des fonctionnalités de sécurité robustes, leur sûreté dépend de la technologie sous-jacente, de la sécurité des contrats intelligents, et",
+  "page-layer-2-faq-ExpandableCard-2-link": "maturité du réseau",
+  "page-layer-2-faq-ExpandableCard-2-description-2": "Les utilisateurs devraient faire preuve de vigilance, commencer par de petites transactions et se tenir informés des évolutions pour garantir une utilisation sécurisée.",
+  "page-layer-2-faq-ExpandableCard-3-title": "Pourquoi Ethereum ne peut-il pas faire évoluer sa propre chaîne au lieu de dépendre de ces réseaux ?",
+  "page-layer-2-faq-ExpandableCard-3-description": "Ethereum ne peut pas facilement faire évoluer sa propre chaîne principale, car elle doit rester sécurisée et décentralisée. Rendre la chaîne principale plus rapide pourrait la rendre moins sûre et plus centralisée. Les réseaux d'Ethereum apportent une solution en traitant les transactions en dehors de la chaîne principale, puis en utilisant celle-ci pour garantir la sécurité. Cela permet à Ethereum de gérer un plus grand nombre de transactions sans compromettre ni la sécurité ni la décentralisation.",
+  "page-layer-2-faq-ExpandableCard-4-title": "Pourquoi n'y a-t-il pas de réseaux Ethereum « officiels » ?",
+  "page-layer-2-faq-ExpandableCard-4-description": "Tout comme il n'y a pas de client Ethereum « officiel », il n'existe pas de couche 2 Ethereum « officielle ». Ethereum fonctionne sans autorisation - techniquement n'importe qui peut créer une couche 2 ! Plusieurs équipes implémenteront leur version d'une couche 2, et l'écosystème dans son ensemble bénéficiera d'une diversité d'approches de conception optimisées pour différents cas d'utilisation. À l'instar des multiples clients Ethereum développés par plusieurs équipes afin d'assurer la diversité du réseau, les couches 2 se développeront de la même manière à l'avenir.",
+  "page-layer-2-callout-1-title": "Explore différents réseaux",
+  "page-layer-2-callout-1-description": "Découvrez en quoi les réseaux diffèrent les uns des autres et les progrès réalisés dans leur développement.",
+  "page-layer-2-callout-2-title": "Envie d’en savoir plus ?",
+  "page-layer-2-callout-2-description": "Vous souhaitez connaître la technologie et les raisons derrière cette approche de mise à l’échelle ? Découvrez les réflexions et les différentes approches technologiques qui la sous-tendent.",
+  "page-layer-2-arbitrum-description": "Arbitrum One est un rollup optimiste à usage général, développé par Offchain Labs et gouverné par l'Arbitrum DAO.",
+  "page-layer-2-base-description": "Base est un rollup optimiste construit avec l’OP Stack. Il propose une solution économique et conviviale pour les développeurs, permettant à chacun, partout dans le monde, de construire sur la chaîne.",
+  "page-layer-2-optimism-description": "OP Mainnet est un rollup optimiste équivalent à l’EVM. Il se veut rapide, simple et sécurisé.",
+  "page-layer-2-blast-description": "Blast est un rollup optimiste compatible avec l’EVM, offrant un rendement natif intégré.",
+  "page-layer-2-zksync2-description": "ZKsync Era est un rollup ZK à usage général entièrement compatible avec l’EVM.",
+  "page-layer-2-linea-description": "Linea est un rollup ZK propulsé par le zkEVM de Consensys, conçu pour faire évoluer le réseau Ethereum.",
+  "page-layer-2-scroll-description": "Scroll est un rollup ZK qui étend les capacités d’Ethereum grâce à la technologie ZK et à la compatibilité avec l’EVM.",
+  "page-layer-2-starknet-description": "Starknet est un rollup ZK à usage général basé sur les STARKs et la machine virtuelle Cairo.",
+  "page-layer-2-mode-description": "Mode est un rollup optimiste basé sur l’OP Stack, qui construit l’économie AIFi.",
+  "page-layer-2-taiko-description": "Taiko est un rollup ZK-EVM décentralisé, équivalent à Ethereum, qui permet une communication inter-chaînes fluide.",
+  "page-layer-2-unichain-description": "Unichain est un L2 d'Ethereum natif pour la DeFi, conçu pour être la plaque tournante de la liquidité entre les chaînes.",
+  "page-layer-2-ink-description": "Ink est une blockchain de couche 2 de la pile OP d'Ethereum, conçue pour héberger la DeFi pour la Superchain ; une couche de base puissante pour le déploiement de protocoles DeFi innovants.",
+  "page-layer-2-zircuit-description": "Zircuit est un rollup ZK compatible EVM, doté d'une sécurité au niveau du séquenceur alimentée par l'IA pour détecter et empêcher les transactions malveillantes."
 }
diff --git a/src/intl/fr/page-learn.json b/src/intl/fr/page-learn.json
index 04fec1efc3f..4574d9fe6fc 100644
--- a/src/intl/fr/page-learn.json
+++ b/src/intl/fr/page-learn.json
@@ -1,6 +1,7 @@
 {
+  "about-ethereum-video-series": "Série de vidéos sur Ethereum",
   "toc-learn-hub": "Centre d'apprentissage",
-  "toc-what-is-crypto-ethereum": "Qu'est-ce qu'Ethereum ?",
+  "toc-what-is-crypto-ethereum": "Qu'est-ce qu'Ethereum ?",
   "toc-how-do-i-use-ethereum": "Comment utiliser Ethereum ?",
   "toc-what-is-ethereum-used-for": "À quoi sert Ethereum ?",
   "toc-strengthen-the-ethereum-network": "Renforcer le réseau Ethereum",
@@ -12,13 +13,13 @@
   "hero-button-lets-get-started": "C'est parti !",
   "page-learn-meta-title": "Ethereum : un guide d’apprentissage complet",
   "what-is-crypto-1": "Vous avez peut-être entendu parler de cryptomonnaies, de blockchains et de Bitcoin. Les liens ci-dessous vous aideront à apprendre ce qu'ils sont et comment ils s'articulent avec Ethereum.",
-  "what-is-crypto-2": "Les cryptomonnaies, comme le Bitcoin, permettent à n'importe qui de transférer de l'argent à l'échelle mondiale. Ethereum le permet également, mais il peut également exécuter du code qui permet aux gens de créer des applications et des organisations. Il est à la fois résilient et flexible : n'importe quel programme informatique peut être exécuté sur Ethereum. Apprenez-en davantage et découvrez comment commencer :",
+  "what-is-crypto-2": "Les cryptomonnaies, comme bitcoin, permettent à n'importe qui de transférer de l'argent à l'échelle mondiale. Ethereum le permet également, mais il peut également exécuter du code qui permet aux gens de créer des applications et des organisations. Il est à la fois résilient et flexible : n'importe quel programme informatique peut être exécuté sur Ethereum. Apprenez-en davantage et découvrez comment commencer :",
   "what-is-ethereum-card-title": "Qu'est-ce qu'Ethereum ?",
   "what-is-ethereum-card-description": "Si vous êtes nouveau, commencez ici pour savoir pourquoi Ethereum est important.",
   "what-is-ethereum-card-image-alt": "Illustration d'une personne jetant un coup d'œil à un bazar, destinée à représenter Ethereum.",
   "what-is-eth-card-title": "Qu'est-ce que l'ETH ?",
   "what-is-eth-description": "Ether (ETH) est la devise qui alimente le réseau et les applications Ethereum.",
-  "what-is-web3-card-title": "Qu'est-ce que le Web3 ?",
+  "what-is-web3-card-title": "Qu'est-ce que Web3 ?",
   "what-is-web3-card-description": "Le Web3 est un modèle pour Internet qui valorise la propriété de vos actifs et de votre identité.",
   "additional-reading-more-on-ethereum-basics": "En savoir plus sur les bases d'Ethereum",
   "guides-hub-desc": "Guides : instructions étape par étape sur l'utilisation d'Ethereum",
@@ -43,24 +44,24 @@
   "things-to-consider-banner-layer-2": "Couche de niveau 2",
   "additional-reading-more-on-using-ethereum": "En savoir plus sur l'utilisation d'Ethereum",
   "additional-reading-how-to-create-an-ethereum-account": "Comment créer un compte Ethereum",
-  "additional-reading-how-to-use-a-wallet": "Comment utiliser un wallet (portefeuille cryptographique)",
+  "additional-reading-how-to-use-a-wallet": "Comment utiliser un portefeuille",
   "additional-reading-layer-2": "Couche 2 : réduction des frais de transaction",
   "what-is-ethereum-used-for-1": "Ethereum a conduit à la création de nouveaux produits et services qui peuvent améliorer différents domaines de notre vie. Nous en sommes encore aux premières étapes, mais il y a beaucoup de choses à faire.",
-  "defi-card-title": "Finance Décentralisée (DeFi)",
+  "defi-card-title": "Finance décentralisée (DeFi)",
   "defi-card-description": "Explorez un système financier alternatif construit sans banques et ouvert à tous.",
   "defi-card-button": "Qu'est-ce que DeFi ?",
   "stablecoins-card-title": "Stablecoins",
   "stablecoins-card-description": "Les cryptomonnaies sont liées à la valeur d'une devise, d'un produit ou d'un autre instrument financier.",
   "stablecoins-card-button": "Que sont les stablecoins ?",
-  "nft-card-title": "Jetons non fongibles (NFTs)",
+  "nft-card-title": "Jetons non fongibles (NFT)",
   "nft-card-description": "Représente la propriété d’objets uniques, de l’art aux titres d’œuvre aux billets de concert.",
   "nft-card-button": "Que sont les NFT ?",
   "dao-card-title": "Organisations autonomes décentralisées (DAO)",
   "dao-card-description": "Activer de nouvelles façons de coordonner le travail sans boss.",
   "dao-card-button": "Que sont les DAO ?",
-  "dapp-card-title": "Applications décentralisées (dApps)",
+  "dapp-card-title": "applications Ethereum",
   "dapp-card-description": "Créer une économie numérique des services de pair à pair.",
-  "dapp-card-button": "Découvrir les dApps",
+  "dapp-card-button": "Qu'est-ce que les applications?",
   "emerging-use-cases-title": "Cas d'utilisation émergents",
   "emerging-use-cases-description": "Il y a également d'autres industries importantes en cours de création ou d'amélioration avec Ethereum:",
   "play-to-earn": "Jeux Play-to-earn (P2E)",
@@ -72,14 +73,14 @@
   "staking-ethereum-card-title": "Mise en jeu sur Ethereum",
   "staking-ethereum-card-description": "Apprenez à commencer à mettre votre ETH.",
   "staking-ethereum-card-button": "Commencer à miser",
-  "run-a-node-card-title": "Ajouter un nœud",
+  "run-a-node-card-title": "Exécuter un nœud",
   "run-a-node-card-description": "Jouez un rôle critique dans le réseau Ethereum en lançant un nœud.",
   "learn-about-ethereum-protocol-description": "Pour les utilisateurs les plus intéressés par la partie technique du réseau Ethereum.",
   "energy-consumption-card-title": "Energie consommée",
   "energy-consumption-card-description": "Quelle est la consommation d'énergie d'Ethereum ?",
   "energy-consumption-card-button": "Est-ce que Ethereum est vert ?",
   "ethereum-upgrades-card-title": "Feuille de route d'Ethereum",
-  "ethereum-upgrades-card-description": "La feuille de route Ethereums la rend plus évolutive, plus sécurisée et plus durable.",
+  "ethereum-upgrades-card-description": "La feuille de route d'Ethereum le rend plus évolutif, sécurisé et durable.",
   "ethereum-upgrades-card-button": "Explorer les données",
   "ethereum-whitepaper-card-title": "Livre blanc Ethereum",
   "ethereum-whitepaper-card-description": "La proposition originale d'Ethereum écrite par Vitalik Buterin en 2014.",
@@ -117,6 +118,8 @@
   "zeroknowledge-description": "Enfonce dans la technologie qui alimentera le web décentralisé émergent et la communauté qui construira ceci",
   "green-pill-title": "Green Pill",
   "green-pill-description": "Explore les systèmes crypto-économiques qui créent des externalités positives pour le monde",
+  "ethereum-basics-title": "Les bases d’Ethereum",
+  "ethereum-basics-description": "Apprends les bases de l’architecture du réseau Ethereum grâce à une série de vidéos faciles à comprendre.",
   "unchained-title": "Unchained",
   "unchained-description": "Pousse profondément dans les gens qui construisent l'internet décentralisé, les détails de cette technologie qui pourraient soutenir notre avenir, et certains des sujets les plus épineux dans les cryptomonnaies, tels que la réglementation, la sécurité et la confidentialité",
   "the-daily-gwei-title": "The Daily Gwei",
diff --git a/src/intl/fr/page-resources.json b/src/intl/fr/page-resources.json
new file mode 100644
index 00000000000..ba87c107492
--- /dev/null
+++ b/src/intl/fr/page-resources.json
@@ -0,0 +1,97 @@
+{
+  "page-resources-network-title": "Le réseau",
+  "page-resources-using-title": "Utiliser Ethereum",
+  "page-resources-scaling-title": "Mise à l'échelle d'Ethereum",
+  "page-resources-resilience-title": "Résilience d’Ethereum",
+  "page-resources-privacy-security-title": "Confidentialité et sécurité",
+  "page-resources-network-layer2-title": "Réseaux Ethereum - Couche 2",
+  "page-resources-network-layer2-chart-label": "Coût médian des transactions sur les réseaux Ethereum",
+  "page-resources-network-layer2-l2beat-description": "L2BEAT a été créé pour fournir des informations transparentes et vérifiables sur les technologies émergentes de seconde couche (L2) qui, conformément à la feuille de route d’Ethereum axée sur les rollups, visent à faire évoluer Ethereum à grande échelle.",
+  "page-resources-network-layer2-growthepie-description": "growthepie visualise l'utilisation et la croissance du réseau principal Ethereum et des couches 2. Frais en temps réel, données économiques, traction des applications, données sur les stablecoins, articles basés sur des données, et bien plus encore.",
+  "page-resources-block-explorers-title": "explorateurs de bloc",
+  "page-resources-block-explorers-chart-label": "Temps avant le prochain bloc",
+  "page-resources-block-explorers-blockscout-description": "Explorateur de blocs open source développé par Blockscout, offrant des données complètes sur la blockchain et des API pour les réseaux Ethereum.",
+  "page-resources-block-explorers-etherscan-description": "Etherscan est un explorateur de blocs et une plateforme d’analyse pour Ethereum, une plateforme décentralisée de contrats intelligents.",
+  "page-resources-block-explorers-beaconchain-description": "Explorateur Ethereum open source affichant le réseau principal Ethereum 🚀.",
+  "page-resources-block-explorers-txcity-description": "Un visualiseur sympa en temps réel des blocs Ethereum.",
+  "page-resources-block-explorers-panda-ops-description": "Tableau de bord en temps réel de la production de blocs de la chaîne Beacon d’Ethereum, réalisé par ethPandaOps.",
+  "page-resources-block-explorers-otterscan-description": "Un explorateur de blocs Ethereum ultra-rapide, local et auto-hébergé",
+  "page-resources-eth-asset-title": "L’actif ETH",
+  "page-resources-eth-asset-etherealize-description": "Ethereum est la blockchain la plus grande, la plus sécurisée et la plus ouverte au monde. Et Ethereum est ouverte aux affaires.",
+  "page-resources-eth-asset-ultrasound-description": "Ultra sound money est un mème d’Ethereum mettant l’accent sur la probable diminution de l’offre d’ETH.",
+  "page-resources-eth-asset-ethismoney-description": "ETH est une monnaie, et une communauté de convaincus qui détiennent, stakent et promeuvent l’ETH en tant que monnaie.",
+  "page-resources-gas-title": "Gaz",
+  "page-resources-gas-etherscan-description": "Suivez tous les indicateurs clés liés au gaz.",
+  "page-resources-gas-ethgastracker-description": "Surveillez les prix du gas sur le réseau Ethereum et les couches 2.",
+  "page-resources-gas-blocknative-description": "La prédiction des frais de gaz la plus précise du Web3.",
+  "page-resources-gas-gasfees-description": "Suivi des données des frais de gaz des réseaux Ethereum.",
+  "page-resources-defi-title": "DeFi",
+  "page-resources-defi-defillama-description": "DefiLlama est le plus grand agrégateur de TVL pour la DeFi (finance décentralisée).",
+  "page-resources-defi-eigenphi-description": "Vous voulez comprendre les transactions DeFi et les stratégies de trading ?",
+  "page-resources-defi-defiscan-description": "Informations vérifiables sur la maturité et les risques de la DeFi.",
+  "page-resources-stablecoins-title": "Stablecoins",
+  "page-resources-stablecoins-stablecoinswtf-description": "Le but de ce site est d’éduquer les degens au sujet des stablecoins.",
+  "page-resources-stablecoins-visa-description": "Le tableau de bord Visa Onchain Analytics met en lumière les mouvements des stablecoins adossés à des monnaies fiduciaires à travers les blockchains publiques dans le monde entier.",
+  "page-resources-stablecoins-rwa-description": "Explorez l’activité derrière les stablecoins adossés à des cryptomonnaies et à des actifs.",
+  "page-resources-nft-title": "NFT",
+  "page-resources-nft-etherscan-description": "Contrats NFT les plus populaires.",
+  "page-resources-nft-nftgo-description": "Données en temps réel du marché mondial des NFT.",
+  "page-resources-applications-title": "Applications",
+  "page-resources-applications-ecosystem-description": "Imprégnez-vous de l’écosystème d'Ethereum et familiarisez-vous avec des centaines d’applications et d’outils populaires.",
+  "page-resources-applications-farcaster-description": "Données issues de l’utilisation de Farcaster.",
+  "page-resources-applications-dappradar-description": "Explorez les meilleurs dApps, NFT, jeux, projets DeFi, jetons et airdrops. Suivez les classements, découvrez des analyses de marché, trouvez les projets tendances et débloquez des récompenses avec la boutique de dApps la plus complète au monde.",
+  "page-resources-adoption-title": "Adoption d'Ethereum",
+  "page-resources-adoption-ethereumadoption-description": "Une liste d’entités de premier plan en construction sur Ethereum.",
+  "page-resources-adoption-cryptowerk-description": "Analyse de l’adoption d’Ethereum basée sur la base de données des commerçants de Cryptwerk : carte, pays, entreprises, commerces, catégories, classement.",
+  "page-resources-adoption-reserves-description": "Un tableau de bord au sujet de l’initiative de Réserve Stratégique d’Ethereum.",
+  "page-resources-roadmap-title": "Feuille de route d'Ethereum",
+  "page-resources-roadmap-metric-label": "Dernière mise à niveau",
+  "page-resources-roadmap-ethroadmap-description": "Visualisation détaillée de la feuille de route d’Ethereum et de la prochaine mise à jour du réseau.",
+  "page-resources-blobs-title": "Blobs",
+  "page-resources-blobs-metric-total-label": "Nombre total de blobs",
+  "page-resources-blobs-metric-fee-label": "Frais de blob moyens",
+  "page-resources-blobs-blobscan-description": "Analyseur de blobs complet.",
+  "page-resources-blobs-blobsguru-description": "Explorateur de Blobs Ethereum : analysez les transactions L2 et les données de l’EIP-4844.",
+  "page-resources-nodes-title": "Nœuds",
+  "page-resources-nodes-nodewatch-description": "Aperçu des nœuds.",
+  "page-resources-nodes-ethernodes-description": "Statistiques du réseau principal d’Ethereum.",
+  "page-resources-nodes-etherscan-description": "Journalier.",
+  "page-resources-nodes-luckystaker-description": "Probabilité quotidienne de proposer un bloc.",
+  "page-resources-nodes-pectrified-description": "Statistiques du fork Pectra d’Ethereum pour les validateurs.",
+  "page-resources-nodes-validatorqueue-description": "Un tableau de bord affichant les files d’attente d’entrée et de sortie des validateurs Ethereum ainsi que les temps d’attente estimés.",
+  "page-resources-network-resilience-title": "Résilience du réseau",
+  "page-resources-network-resilience-neutralitywatch-description": "Moniteur de la censure d’Ethereum.",
+  "page-resources-network-resilience-sunshine-description": "Un tableau de bord qui mesure la santé de la décentralisation d’Ethereum.",
+  "page-resources-network-resilience-clientdiversity-description": "Améliorez la résilience d’Ethereum en utilisant un client minoritaire.",
+  "page-resources-network-resilience-supermajority-description": "Le risque de client super majoritaire dans la couche d’exécution d’Ethereum, en particulier l’utilisation des clients par les services de staking.",
+  "page-resources-attestations-title": "Attestations",
+  "page-resources-attestations-eas-description": "EAS permet à chacun de créer et de valider des attestations sur la chaîne et hors chaîne sur Ethereum.",
+  "page-resources-relays-title": "Relais",
+  "page-resources-relays-beaconchain-description": "Les validateurs peuvent utiliser des relais pour externaliser la production de blocs à des entités spécialisées dans l’extraction de revenus supplémentaires.",
+  "page-resources-relays-ratednetwork-description": "Part de marché des relais MEV, valeur totale relayée, valeur par bloc et autres statistiques du réseau Ethereum.",
+  "page-resources-relays-relayscan-description": "Analyses de MEV-Boost.",
+  "page-resources-mev-title": "MEV",
+  "page-resources-mev-mevboost-description": "Le but de ce site est d’éduquer les degens au sujet des stablecoins.",
+  "page-resources-mev-mevwatch-description": "Certains relais MEV-Boost sont régulés par l’OFAC et censureront certaines transactions. Utilisez cet outil pour observer l’effet produit sur les blocs Ethereum.",
+  "page-resources-wallets-title": "Portefeuilles",
+  "page-resources-wallets-wallet-beat-description": "Un tableau de bord simple et un outil de synthèse pour portefeuille Ethereum.",
+  "page-resources-wallets-bundlebear-description": "Tableaux de bord et analyses pour les comptes intelligents ERC-4337 et EIP-7702.",
+  "page-resources-zk-adoption-title": "Adoption des ZK",
+  "page-resources-zk-adoption-ethproofs-description": "Les SNARK qui font évoluer Ethereum.",
+  "page-resources-zk-adoption-l2beat-description": "Le ZK Catalog de L2BEAT est une ressource collaborative offrant des informations détaillées sur la technologie ZK utilisée par divers projets blockchain.",
+  "page-resources-mempool-title": "Mempool",
+  "page-resources-mempool-mempool-description": "Visualisations comparatives sélectionnées de la mempool d’Ethereum.",
+  "page-resources-meta-title": "Tableau de bord des ressources Ethereum",
+  "page-resources-meta-description": "Découvrez une liste de ressources sélectionnées par la communauté pour rester informé de tous les développements majeurs de l’écosystème d'Ethereum.",
+  "page-resources-hero-title": "Ressources",
+  "page-resources-hero-header": "Tableaux de bord Ethereum",
+  "page-resources-hero-description": "Découvrez une liste de ressources sélectionnées par la communauté pour rester informé de tous les développements majeurs de l’écosystème d'Ethereum.",
+  "page-resources-find-more": "Trouvez d’autres excellentes ressources sur",
+  "page-resources-contribute-title": "Contribuer",
+  "page-resources-contribute-description": "Ce tableau de bord est une page évolutive qui nécessite des mises à jour fréquentes. Aidez-nous à trouver les meilleures ressources pour offrir un aperçu de l’écosystème d'Ethereum.",
+  "page-resources-suggest-resource": "Suggérez une ressource",
+  "page-resources-found-bug": "Vous avez trouvé un bug",
+  "page-resources-whats-on-this-page": "Contenu de cette page",
+  "page-resources-banner-notification-message": "Ce tableau de bord des ressources est nouveau !",
+  "page-resources-share-feedback": "Veuillez nous faire part de vos commentaires"
+}
diff --git a/src/intl/fr/page-roadmap-vision.json b/src/intl/fr/page-roadmap-vision.json
index 3f4622e0413..7d7a41d6fea 100644
--- a/src/intl/fr/page-roadmap-vision.json
+++ b/src/intl/fr/page-roadmap-vision.json
@@ -1,5 +1,5 @@
 {
-  "page-roadmap-vision-2014": "Voir un article de blog datant 2014 détaillant la preuve d'enjeu",
+  "page-roadmap-vision-2014": "Voir un article de blog de 2014 détaillant la preuve d'enjeu",
   "page-roadmap-vision-2021": "Voir un article de blog 2021 sur l'évolution de la feuille de route Ethereum",
   "page-roadmap-vision-2022": "Voir un billet de blog de 2022 : Le Guide des Autostoppeurs sur Ethereum",
   "page-roadmap-vision-2021-updates": "Voir un article d'un blog de 2021 sur les mises à jour du protocole Ethereum",
@@ -14,7 +14,7 @@
   "page-roadmap-vision-problems": "Problèmes actuels",
   "page-roadmap-vision-scalability": "Évolutivité",
   "page-roadmap-vision-scalability-desc": "Ethereum doit pouvoir gérer plus de transactions par seconde sans augmenter la taille des nœuds du réseau. Les nœuds sont des acteurs vitaux au réseau qui stockent et exécutent la blockchain. L'augmentation de la taille des nœuds n'est pas pratique car seuls ceux qui disposent d'ordinateurs puissants et coûteux pourraient le faire. Pour évoluer, Ethereum a besoin d'exécuter plus de transactions par seconde, couplé à plus de nœuds. Plus de nœuds signifie plus de sécurité.",
-  "page-roadmap-vision-scalability-desc-3": "Les rollups de couche 2 font évoluer Ethereum en déplaçant les transactions hors chaîne et en publiant uniquement des données récapitulatives sur Ethereum. Ce regroupement augmente le débit d'Ethereum tout en réduisant considérablement les coûts pour les utilisateurs.",
+  "page-roadmap-vision-scalability-desc-3": "Les rollups de couche 2 font évoluer Ethereum en déplaçant les transactions hors chaîne et en publiant uniquement un résumé des données sur Ethereum. Ce regroupement augmente le débit d'Ethereum tout en réduisant considérablement les coûts pour les utilisateurs.",
   "page-roadmap-vision-scalability-desc-4": "Les rollups nécessitent un stockage à faible coût sur la couche 1 pour rendre les transactions aussi bon marché que possible pour les utilisateurs. Celui-ci sera fourni sous forme de blobs attachés aux blocs Ethereum. À terme, de nombreux blobs seront attachés aux blocs Ethereum, offrant ainsi un stockage bon marché pour de nombreux rollups.",
   "page-roadmap-vision-security": "Sécurité",
   "page-roadmap-vision-security-desc": "Les mises à niveau prévues améliorent la sécurité d'Ethereum contre les attaques coordonnées.",
diff --git a/src/intl/fr/page-roadmap.json b/src/intl/fr/page-roadmap.json
new file mode 100644
index 00000000000..009df779a22
--- /dev/null
+++ b/src/intl/fr/page-roadmap.json
@@ -0,0 +1,102 @@
+{
+  "page-roadmap-title": "Feuille de route d'Ethereum",
+  "page-roadmap-meta-title": "Feuille de route d'Ethereum | ethereum.org",
+  "page-roadmap-meta-description": "La voie vers davantage d'évolutivité, de sécurité et de durabilité pour Ethereum.",
+  "page-roadmap-banner-notification": "Le développement d’Ethereum est axé sur la communauté et sujet à changement.",
+  "page-roadmap-changes-coming-title": "Quels sont les changements à venir pour Ethereum ?",
+  "page-roadmap-changes-coming-description": "Ethereum est déjà une plateforme puissante, mais elle continue d'être améliorée. Un ensemble ambitieux d'améliorations permettra de faire évoluer Ethereum de sa forme actuelle vers une plateforme entièrement évolutive et extrêmement résiliente.",
+  "page-roadmap-cheaper-transactions-title": "Transactions plus abordables",
+  "page-roadmap-cheaper-transactions-description": "Les rollups sont trop coûteux et reposent sur des composants centralisés, ce qui incite les utilisateurs à accorder une confiance excessive à leurs opérateurs. La feuille de route inclut des correctifs pour ces deux problèmes.",
+  "page-roadmap-cheaper-transactions-button": "En savoir plus sur la réduction des frais",
+  "page-roadmap-extra-security-title": "Sécurité renforcée",
+  "page-roadmap-extra-security-description": "Ethereum est déjà très sécurisé, mais il peut être rendu encore plus fort, prêt à résister à toutes sortes d’attaques dans le futur.",
+  "page-roadmap-extra-security-button": "En savoir plus sur la sécurité",
+  "page-roadmap-better-user-experience-title": "Meilleure expérience utilisateur",
+  "page-roadmap-better-user-experience-description": "Une meilleure prise en charge des portefeuilles de contrats intelligents et des nœuds légers rendra l'utilisation d'Ethereum plus simple et plus sûre.",
+  "page-roadmap-better-user-experience-button": "En savoir plus sur l'expérience utilisateur",
+  "page-roadmap-future-proofing-title": "Pérenniser",
+  "page-roadmap-future-proofing-description": "Les chercheurs et développeurs d’Ethereum résolvent aujourd’hui les problèmes de demain, préparant le réseau pour les générations futures.",
+  "page-roadmap-future-proofing-button": "En savoir plus sur la pérennité",
+  "page-roadmap-why-need-title": "Pourquoi Ethereum a-t-il besoin d'une feuille de route ?",
+  "page-roadmap-why-need-description": "Ethereum bénéficie de mises à jour régulières qui améliorent son évolutivité, sa sécurité et sa durabilité. L'une de ses principales forces réside dans sa capacité d'adaptation aux nouvelles idées issues de la recherche et du développement. Cette adaptabilité lui confère la flexibilité nécessaire pour relever les défis émergents et suivre les avancées technologiques les plus avancées.",
+  "page-roadmap-how-defined-title": "Comment la feuille de route est déterminée",
+  "page-roadmap-how-defined-p1": "La feuille de route est principalement le résultat d'années de travail des chercheurs et des développeurs - car le protocole est très technique - mais toute personne motivée peut y participer.",
+  "page-roadmap-how-defined-p2": "Les idées naissent généralement de discussions sur des forums tels que <a href=\"https://ethresear.ch\">ethresear.ch</a>, <a href=\"https://ethereum-magicians.org\">Ethereum Magicians</a> ou le serveur Discord d'Eth R&D. Il peut s'agir de réponses à de nouvelles vulnérabilités découvertes, de suggestions d'organisations travaillant dans la couche applicative (comme les dApps et les plateformes d'échange) ou de frictions connues pour les utilisateurs finaux (comme les coûts ou les vitesses des transactions).",
+  "page-roadmap-how-defined-p3": "Une fois ces idées mûres, elles peuvent être proposées sous forme de <a href=\"https://eips.ethereum.org\">propositions d'amélioration d'Ethereum</a>. Ces propositions sont publiques, permettant à chaque membre de la communauté de s'exprimer à tout moment.",
+  "page-roadmap-governance-button": "En savoir plus sur la gouvernance d'Ethereum",
+  "page-roadmap-hero-alt": "Feuille de route d'Ethereum",
+  "page-roadmap-technical-upgrades-title": "Quelles améliorations techniques arrivent sur Ethereum ?",
+  "page-roadmap-danksharding-title": "Danksharding",
+  "page-roadmap-danksharding-description": "Danksharding rend les rollups L2 beaucoup moins chers pour les utilisateurs en ajoutant des « blobs » de données aux blocs Ethereum.",
+  "page-roadmap-single-slot-finality-title": "Finalité à créneau unique",
+  "page-roadmap-single-slot-finality-description": "Au lieu d'attendre quinze minutes, les blocs pourraient être proposés et finalisés au même endroit. C'est plus pratique pour les applications et plus difficile à attaquer.",
+  "page-roadmap-account-abstraction-title": "Abstraction de comptes",
+  "page-roadmap-account-abstraction-description": "L'abstraction de compte est une classe de mises à niveau qui prennent en charge les portefeuilles de contrats intelligents de manière native sur Ethereum, plutôt que de devoir utiliser un middleware complexe.",
+  "page-roadmap-statelessness-title": "Statelessness",
+  "page-roadmap-statelessness-description": "Les clients sans état pourront vérifier de nouveaux blocs sans avoir à stocker de grandes quantités de données. Ils bénéficieront ainsi de tous les avantages d'un nœud pour une fraction infime des coûts actuels.",
+  "page-roadmap-learn-more": "En savoir plus",
+  "page-roadmap-timeline-title": "Quel est le calendrier de ces mises à niveau ?",
+  "page-roadmap-blocks-alt": "Blocs Ethereum",
+  "page-roadmap-faq-1-title": "La feuille de route d'Ethereum évoluera-t-elle au fil du temps ?",
+  "page-roadmap-faq-1-p1": "Oui, presque sans aucun doute.",
+  "page-roadmap-faq-1-p1-continued": "La feuille de route présente le plan actuel de mise à niveau d'Ethereum, couvrant les projets à court et à long terme. Nous prévoyons qu'elle évoluera à mesure que de nouvelles informations et technologies seront disponibles.",
+  "page-roadmap-faq-1-p2": "La feuille de route d'Ethereum est un ensemble d'intentions visant à améliorer Ethereum ; il s'agit des meilleures hypothèses des chercheurs et des développeurs sur la voie optimale à suivre pour Ethereum.",
+  "page-roadmap-faq-2-title": "Quand la feuille de route sera-t-elle terminée ?",
+  "page-roadmap-faq-2-p1": "Certaines mises à niveau ont une priorité plus basse et ne seront probablement pas implémentées dans les 5 ou 10 prochaines années (par exemple la résistance quantique).",
+  "page-roadmap-faq-2-p1-strong": "Donner le timing précis de chaque mise à niveau est compliqué",
+  "page-roadmap-faq-2-p1-continued": "prévoir que de nombreux éléments de la feuille de route seront traités en parallèle et développés à des rythmes différents. L'urgence d'une mise à niveau peut également évoluer au fil du temps en fonction de facteurs externes (par exemple, une augmentation soudaine des performances et de la disponibilité des ordinateurs quantiques pourrait rendre la cryptographie résistante aux quanta plus urgente).",
+  "page-roadmap-faq-2-p2": "Une façon d'envisager le développement d'Ethereum est de le comparer à l'évolution biologique. Un réseau capable de s'adapter aux nouveaux défis et de maintenir sa forme physique a plus de chances de réussir qu'un réseau résistant au changement. Cependant, à mesure que le réseau gagne en performance, en évolutivité et en sécurité, moins de modifications du protocole seront nécessaires.",
+  "page-roadmap-faq-3-title": "Dois-je faire quelque chose pour me préparer à ces mises à niveau ?",
+  "page-roadmap-faq-3-p1": "Les mises à niveau n'ont généralement pas d'impact sur les utilisateurs finaux, si ce n'est en offrant une meilleure expérience utilisateur, un protocole plus sécurisé et peut-être davantage d'<i>options</i> d'interaction avec Ethereum. <strong>Les utilisateurs réguliers ne sont pas tenus de participer activement à une mise à niveau, ni de faire quoi que ce soit** pour sécuriser leurs actifs.</strong> Les opérateurs de <a href=\"/glossary/#node\">nœuds</a> devront mettre à jour leurs clients pour se préparer à une mise à niveau. Certaines mises à niveau peuvent entraîner des changements pour les développeurs d'applications. Par exemple, les mises à niveau liées à l'expiration de l'historique peuvent inciter les développeurs d'applications à récupérer des données historiques à partir de nouvelles sources.",
+  "page-roadmap-faq-4-title": "Qu'en est-il de la fragmentation ?",
+  "page-roadmap-faq-4-p1": "Le sharding consiste à fractionner la blockchain Ethereum de sorte que les sous-ensembles de <a href=\"/glossary/#validator\">validateurs</a> ne soient responsables que d'une fraction des données totales. À l'origine, cette approche était destinée à permettre à Ethereum de s'adapter. Cependant, les rollups de <a href=\"/glossary/#layer-2\">couche 2</a> se sont développés beaucoup plus rapidement que prévu et ont déjà permis une évolutivité importante, et le seront encore davantage après la mise en œuvre du Proto-Danksharding. Cela signifie que les « chaînes de sharding » ne sont plus nécessaires et ont été supprimées de la feuille de route.",
+  "page-roadmap-release-status-prod": "En production",
+  "page-roadmap-release-status-soon": "À venir",
+  "page-roadmap-release-status-dev": "En développement",
+  "page-roadmap-release-main-features": "Principales caractéristiques",
+  "page-roadmap-release-learn-more": "En savoir plus",
+  "page-roadmap-release-forkcast": "Suivre les modifications",
+  "page-roadmap-paris-pos-title": "Transition vers la preuve d'enjeu",
+  "page-roadmap-paris-pos-item-1": "Remplacement de l'exploitation minière à forte intensité énergétique par un consensus basé sur le staking",
+  "page-roadmap-paris-pos-item-2": "Réduction de la consommation d'énergie d'Ethereum d'environ 99,95 %",
+  "page-roadmap-paris-beacon-title": "Intégration de la chaîne Beacon",
+  "page-roadmap-paris-beacon-item-1": "Fusion de la chaîne Beacon avec le réseau principal Ethereum",
+  "page-roadmap-paris-beacon-item-2": "A permis la transition complète vers le mécanisme de consensus PoS",
+  "page-roadmap-paris-difficulty-title": "Retrait de la Difficulty Bomb",
+  "page-roadmap-paris-difficulty-item-1": "Suppression de la bombe de difficulté qui augmentait la difficulté de l'exploitation minière",
+  "page-roadmap-paris-difficulty-item-2": "Assurer une transition en douceur vers le nouveau mécanisme de consensus",
+  "page-roadmap-shapella-withdrawals-title": "Retraits de la mise en jeu",
+  "page-roadmap-shapella-withdrawals-item-1": "Permet aux validateurs de retirer leurs ETH mis en jeu et leurs récompenses",
+  "page-roadmap-shapella-withdrawals-item-2": "Introduction de capacités de retrait partiel et total",
+  "page-roadmap-shapella-eip4895-title": "EIP-4895 : Retraits push de la chaîne Beacon",
+  "page-roadmap-shapella-eip4895-item-1": "Ajout d'une nouvelle opération au niveau du système pour les retraits",
+  "page-roadmap-shapella-eip4895-item-2": "Assurer un traitement sécurisé et efficace des demandes de retrait",
+  "page-roadmap-shapella-eip3651-title": "EIP-3651 : Warm COINBASE",
+  "page-roadmap-shapella-eip3651-item-1": "Coûts de gaz réduits pour accéder à l'adresse COINBASE",
+  "page-roadmap-shapella-eip3651-item-2": "Amélioration de l'efficacité de certaines opérations de contrats intelligents",
+  "page-roadmap-dencun-danksharding-title": "Proto-danksharding (EIP-4844)",
+  "page-roadmap-dencun-danksharding-item-1": "Introduction de transactions blob pour réduire considérablement les coûts de transaction de rollup",
+  "page-roadmap-dencun-danksharding-item-2": "Ajout d'un nouveau type de transaction qui stocke les données temporairement et à moindre coût",
+  "page-roadmap-dencun-eip1153-title": "EIP-1153: Opcodes de stockage transitoire",
+  "page-roadmap-dencun-eip1153-item-1": "Ajout des codes d'opérations TSTORE et TLOAD pour le stockage temporaire pendant l'exécution des transactions",
+  "page-roadmap-dencun-eip1153-item-2": "Permet des modèles de contrats intelligents plus efficaces et réduit les coûts de gaz",
+  "page-roadmap-dencun-eip4788-title": "EIP-4788 : Racine du bloc de balises dans l'EVM",
+  "page-roadmap-dencun-eip4788-item-1": "Expose les informations de la couche de consensus aux contrats intelligents",
+  "page-roadmap-dencun-eip4788-item-2": "Permet de nouvelles applications minimisant la confiance et des ponts inter-chaînes",
+  "page-roadmap-pectra-eoa-title": "Améliorez les portefeuilles EOA avec la fonctionnalité de contrat intelligent",
+  "page-roadmap-pectra-eoa-item-1": "Les utilisateurs peuvent définir leur adresse pour qu'elle soit représentée par un code d'un contrat intelligent existant et bénéficier d'avantages tels que le regroupement des transactions, le parrainage des frais de transaction ou de meilleurs mécanismes de récupération",
+  "page-roadmap-pectra-balance-title": "Augmentation du solde effectif maximal",
+  "page-roadmap-pectra-balance-item-1": "Les stakers peuvent désormais choisir un montant arbitraire d'ETH à miser et recevoir des récompenses pour chaque ETH au-dessus du minimum",
+  "page-roadmap-pectra-blob-title": "Augmentation du débit des blobs",
+  "page-roadmap-pectra-blob-item-1": "Le nombre de blobs sera augmenté de 3 à 6 cibles, avec un maximum de 9, ce qui entraînera des frais moins élevés dans les rollups Ethereum",
+  "page-roadmap-fusaka-peerdas-title": "PeerDAS (échantillonnage de disponibilité des données peer-to-peer)",
+  "page-roadmap-fusaka-peerdas-item-1": "Permet une disponibilité plus efficace des données pour les rollups",
+  "page-roadmap-fusaka-peerdas-item-2": "Rend l'exécution d'un nœud plus accessible tout en maintenant la décentralisation",
+  "page-roadmap-fusaka-additional-title": "Fonctionnalités supplémentaires potentielles",
+  "page-roadmap-fusaka-additional-item-1": "Prise en charge des enclaves sécurisées sur les appareils mobiles pour améliorer l'expérience utilisateur",
+  "page-roadmap-fusaka-additional-item-2": "Améliorations du marché des frais blob",
+  "page-roadmap-fusaka-additional-item-3": "Améliorations supplémentaires de l'efficacité du validateur et des performances du réseau",
+  "page-roadmap-glamsterdam-discussed-title": "Prévu pour Glamsterdam",
+  "page-roadmap-glamsterdam-discussed-item-1": "Séparation consacrée entre le proposant et le constructeur (ePBS)",
+  "page-roadmap-glamsterdam-discussed-item-2": "Listes d'accès au niveau du bloc (BALs)"
+}
diff --git a/src/intl/fr/page-stablecoins.json b/src/intl/fr/page-stablecoins.json
index ff7dee52505..fd70ca7ebfe 100644
--- a/src/intl/fr/page-stablecoins.json
+++ b/src/intl/fr/page-stablecoins.json
@@ -1,5 +1,8 @@
 {
   "page-stablecoins-accordion-borrow-crypto-collateral": "Crypto-collatéral",
+  "page-stablecoins-usdc-banner-body": "USDC est le plus grand stablecoin adossé à une monnaie fiduciaire réglementé aux États-Unis. Sa valeur est indexée sur le dollar américain, il est émis par Circle et largement utilisé.",
+  "page-stablecoins-usdc-banner-learn-button": "En savoir plus sur USDC",
+  "page-stablecoins-usdc-banner-swap-button": "Obtenir des USDC",
   "page-stablecoins-accordion-borrow-crypto-collateral-copy": "Avec Ethereum, vous pouvez emprunter directement à d'autres utilisateurs sans échanger vos ETH. Cela peut vous donner un effet de levier – certains le font pour essayer d'accumuler plus d'ETH.",
   "page-stablecoins-accordion-borrow-crypto-collateral-copy-p2": "Mais étant donné que le prix de l'ETH est volatile, vous devrez fournir plus en garantie. Cela signifie que si vous voulez emprunter 100 stablecoins, vous aurez probablement besoin d'au moins 150 $ d’ETH, ce qui protège le système et les prêteurs.",
   "page-stablecoins-accordion-borrow-crypto-collateral-link": "Plus d'infos sur les stablecoins crypto-adossés",
@@ -23,10 +26,9 @@
   "page-stablecoins-accordion-buy-text-preview": "Beaucoup de plateformes d'échanges et de portefeuilles vous permettent d'acheter directement des stablecoins. Des restrictions géographiques s'appliqueront.",
   "page-stablecoins-accordion-buy-title": "Acheter",
   "page-stablecoins-accordion-buy-warning": "Les échanges centralisés ne peuvent lister que les stablecoins soutenus par fiat, comme les USDC, Tether et d'autres. Vous ne pourrez peut-être pas les acheter directement, mais vous devriez pouvoir les échanger contre des ETH ou d'autres cryptomonnaies que vous pouvez acheter sur la plateforme.",
-  "page-stablecoins-accordion-earn-project-1-description": "Travail principalement technique pour le mouvement des logiciels libres.",
+  "page-stablecoins-accordion-earn-project-1-description": "Hackathons en cours et à venir. La porte d’entrée de tous les développeurs vers la nouvelle frontière numérique.",
   "page-stablecoins-accordion-earn-project-2-description": "Technologie, contenu et autre travail pour la communauté MakerDao (l'équipe qui a créé Dai).",
   "page-stablecoins-accordion-earn-project-3-description": "Quand vous vous y connaissez vraiment, trouvez des bogues pour gagner du Dai.",
-  "page-stablecoins-accordion-earn-project-bounties": "Récompenses Gitcoin",
   "page-stablecoins-accordion-earn-project-bug-bounties": "Primes de bogues sur la couche de consensus",
   "page-stablecoins-accordion-earn-project-community": "Communauté MakerDao",
   "page-stablecoins-accordion-earn-projects-copy": "Ce sont des plateformes qui vous paieront avec des stablecoins pour votre travail.",
@@ -36,8 +38,6 @@
   "page-stablecoins-accordion-earn-requirements-description": "Les stablecoins sont une excellente méthode de paiement pour le travail et les services, parce que leur valeur est stable. Mais vous aurez besoin d'un portefeuille pour être payé.",
   "page-stablecoins-accordion-earn-text-preview": "Vous pouvez gagner des stablecoins en travaillant sur des projets dans l'écosystème Ethereum.",
   "page-stablecoins-accordion-earn-title": "Gagner",
-  "page-stablecoins-accordion-less": "Moins",
-  "page-stablecoins-accordion-more": "Plus",
   "page-stablecoins-accordion-requirements": "Ce dont vous aurez besoin",
   "page-stablecoins-accordion-swap-dapp-intro": "Si vous avez déjà des ETH et un <a href=\"/glossary/#wallet\">portefeuille</a>, vous pouvez utiliser ces DApps pour un échange contre des stablecoins.",
   "page-stablecoins-accordion-swap-dapp-link": "Plus d'informations sur les échanges décentralisés",
@@ -56,7 +56,6 @@
   "page-stablecoins-algorithmic-con-1": "Vous devez avoir confiance (ou être en mesure de lire) l'algorithme.",
   "page-stablecoins-algorithmic-con-2": "Votre solde de pièces changera en fonction de la quantité totale.",
   "page-stablecoins-algorithmic-description": "Ces stablecoins ne sont pas supportées par un autre actif. Au lieu de cela, un algorithme vendra des jetons si le prix tombe en dessous de la valeur désirée et fournira d'autres jetons si la valeur va au-delà du montant souhaité. Parce que le nombre de ces jetons en circulation change régulièrement, le nombre de jetons que vous possédez changera, mais reflètera toujours votre quote-part.",
-  "page-stablecoins-algorithmic-disclaimer": "Les stablecoins algorithmiques sont une technologie expérimentale. Vous devriez être conscient des risques avant de les utiliser.",
   "page-stablecoins-algorithmic-pro-1": "Aucune garantie n'est nécessaire.",
   "page-stablecoins-algorithmic-pro-2": "Contrôlé par un algorithme public.",
   "page-stablecoins-bank-apy": "0.05 %",
@@ -69,18 +68,13 @@
   "page-stablecoins-crypto-backed": "Crypto adossé",
   "page-stablecoins-crypto-backed-con-1": "Moins stable que les stablecoins adossées à la monnaie fiduciaire.",
   "page-stablecoins-crypto-backed-con-2": "Vous devez garder un œil sur la valeur du crypto collatéral.",
-  "page-stablecoins-crypto-backed-description": "Ces stablecoins sont adossées à d'autres crypto-actifs, comme l'ETH. Leur prix dépend de la valeur de l'actif sous-jacent (ou de la garantie), qui peut être volatile. Étant donné que la valeur de l'ETH peut fluctuer, ces pièces stables sont sur-collatéralisées pour s'assurer que le prix reste aussi stable que possible. Cela signifie qu'il est plus précis de dire qu'une stablecoin crypto-adossée à 1$ a en fait un actif de cryptomonnaie sous-jacent d'une valeur d'au moins 2 $. Donc, si le prix de l'ETH baisse, plus d'ETH doit être utilisé pour soutenir la stablecoin, sinon les stablecoins perdront leur valeur.",
+  "page-stablecoins-crypto-backed-description": "Ces stablecoins sont adossées à d'autres crypto-actifs, comme l'ETH. Leur prix dépend de la valeur de l'actif sous-jacent (ou de la garantie), qui peut être volatile. Étant donné que la valeur de l'ETH peut fluctuer, ces pièces stables sont sur-collatéralisées pour s'assurer que le prix reste aussi stable que possible. Cela signifie qu'il est plus précis de dire qu'une stablecoin crypto-adossée à 1$ a en fait un actif de cryptomonnaie sous-jacent d'une valeur d'au moins 2 $. Donc, si le prix de l'ETH baisse, plus d'ETH doit être utilisé pour soutenir la stablecoin, sinon les stablecoins perdront leur valeur. Notez que certains stablecoins adossés à des cryptomonnaies, comme le DAI, utilisent également des stablecoins centralisés dans leur mécanisme de garantie.",
   "page-stablecoins-crypto-backed-pro-1": "Transparent et entièrement décentralisé.",
   "page-stablecoins-crypto-backed-pro-2": "Rapide à convertir en d'autres actifs de cryptomonnaie.",
   "page-stablecoins-crypto-backed-pro-3": "Aucun tiers de confiance externe – tous les actifs sont contrôlés par des comptes Ethereum.",
-  "page-stablecoins-dai-banner-body": "Dai est probablement la stablecoin décentralisée la plus célèbre. Sa valeur est à peu près de un dollar et elle est largement acceptée dans les DApps.",
-  "page-stablecoins-dai-banner-learn-button": "En savoir plus sur Dai",
-  "page-stablecoins-dai-banner-swap-button": "Échanger des ETH pour Dai",
-  "page-stablecoins-dai-banner-title": "Dai",
-  "page-stablecoins-dai-logo": "Logo Dai",
   "page-stablecoins-editors-choice": "Choix de la rédaction",
   "page-stablecoins-editors-choice-intro": "Ce sont probablement les exemples les plus connus de stablecoins en ce moment et les pièces que nous avons trouvées utiles lors de l'utilisation de DApps.",
-  "page-stablecoins-explore-dapps": "Explorez des applications décentralisées",
+  "page-stablecoins-explore-dapps": "Découvrir les dApps",
   "page-stablecoins-fiat-backed": "Adossé à une monnaie fiduciaire",
   "page-stablecoins-fiat-backed-con-1": "Centralisé : les jetons doivent être émis par quelqu'un.",
   "page-stablecoins-fiat-backed-con-2": "Nécessite un audit pour s'assurer que l'entreprise dispose de réserves suffisantes.",
@@ -101,7 +95,7 @@
   "page-stablecoins-precious-metals": "Métaux précieux",
   "page-stablecoins-precious-metals-con-1": "Centralisé : les jetons doivent être émis par quelqu'un.",
   "page-stablecoins-precious-metals-con-2": "Vous devez faire confiance à l'émetteur de jetons et aux réserves de métal précieux.",
-  "page-stablecoins-precious-metals-description": "Sur le même principe que les jetons adossés à une monnaie fiduciaire, ces stablecoins utilisent quant à elles des ressources comme l'or pour maintenir leur valeur.",
+  "page-stablecoins-precious-metals-description": "Comme les stablecoins adossés à des monnaies fiduciaires, ces stablecoins utilisent à la place des ressources comme l’or pour maintenir leur valeur. Ils sont dits « stables » car leur prix est constamment indexé sur la valeur d’un autre actif, et ils s’apparentent à un suivi de propriété onchain d’<a href=\"/real-world-assets/\">actifs du monde réel</a>",
   "page-stablecoins-precious-metals-pro-1": "Protégé contre la volatilité des cryptomonnaies.",
   "page-stablecoins-prices": "Prix des stablecoins",
   "page-stablecoins-prices-definition": "Les stablecoins sont des cryptomonnaies sans volatilité. Elles partagent beaucoup des mêmes pouvoirs que l'ETH mais leur valeur est stable, plus comme une monnaie traditionnelle. Ainsi, vous avez accès à de l'argent stable que vous pouvez utiliser sur Ethereum. ",
@@ -109,7 +103,7 @@
   "page-stablecoins-research-warning": "Ethereum est une nouvelle technologie et la plupart des applications sont nouvelles. Assurez-vous d'être au courant du risque et de ne déposer que ce que vous pouvez vous permettre de perdre.",
   "page-stablecoins-research-warning-title": "Faites toujours vos propres recherches",
   "page-stablecoins-save-stablecoins": "Économisez avec des stablecoins",
-  "page-stablecoins-save-stablecoins-body": "Les stablecoins ont souvent un taux d'intérêt supérieur à la moyenne, car il y a beaucoup de demande pour les emprunter. Il existe des DApps qui vous permettent de gagner des intérêts sur vos stablecoins en temps réel en les déposant dans un groupe de prêts. Tout comme dans le monde bancaire, vous fournissez des jetons aux emprunteurs, mais vous pouvez retirer vos jetons et vos intérêts à tout moment.",
+  "page-stablecoins-save-stablecoins-body": "Les stablecoins ont souvent un taux d'intérêt supérieur à la moyenne, car il y a beaucoup de demande pour les emprunter. Il existe des dapps qui vous permettent de gagner des intérêts sur vos stablecoins en temps réel en les déposant dans un groupe de prêts. Tout comme dans le monde bancaire, vous fournissez des jetons aux emprunteurs, mais vous pouvez retirer vos jetons et vos intérêts à tout moment.",
   "page-stablecoins-saving": "Mettez à profit vos économies de stablecoin et gagnez quelques intérêts. Comme tout ce qui est en cryptomonnaie, le pourcentage annuel de rendement prédit (APY) peut changer au jour le jour en fonction de l'offre ou de la demande en temps réel.",
   "page-stablecoins-stablecoins-dapp-callout-description": "Découvrez les DApps d'Ethereum – les stablecoins sont souvent plus utiles pour les transactions quotidiennes.",
   "page-stablecoins-stablecoins-dapp-callout-image-alt": "Illustration d'un doge.",
@@ -118,6 +112,7 @@
   "page-stablecoins-stablecoins-dapp-description-2": "Prêtez des stablecoins et gagnez des intérêts et des $COMP, le jeton propre de Compound.",
   "page-stablecoins-stablecoins-dapp-description-3": "Une plateforme de trading où vous pouvez gagner des intérêts sur vos Dai et USDC.",
   "page-stablecoins-stablecoins-dapp-description-4": "Une application conçue pour épargner des Dai.",
+  "page-stablecoins-stablecoins-dapp-description-5": "Un protocole de prêt et d’emprunt sur Ethereum prenant en charge de nombreuses options de stablecoins.",
   "page-stablecoins-stablecoins-feature-1": "Les stablecoins ne sont pas limitées par les frontières traditionnelles et peuvent être envoyées par Internet. Elles sont faciles à recevoir ou envoyer une fois que vous avez un <a href=\"/glossary/#account\">compte Ethereum</a>.",
   "page-stablecoins-stablecoins-feature-2": "La demande pour les stablecoins est élevée, vous pouvez donc gagner des intérêts en prêtant les vôtres. Assurez-vous de bien connaître et comprendre les risques encourus avant de prêter.",
   "page-stablecoins-stablecoins-feature-3": "Les stablecoins peuvent être échangées contre des ETH et d'autres jetons Ethereum. De nombreuses <a href=\"/glossary/#dapp\">DApps</a> dépendent des stablecoins.",
@@ -126,6 +121,7 @@
   "page-stablecoins-stablecoins-table-header-column-1": "Devise",
   "page-stablecoins-stablecoins-table-header-column-2": "Capitalisation boursière",
   "page-stablecoins-stablecoins-table-header-column-3": "Type de collatéral",
+  "page-stablecoins-stablecoins-table-header-column-4": "Adosser",
   "page-stablecoins-stablecoins-table-type-crypto-backed": "Crypto",
   "page-stablecoins-stablecoins-table-type-fiat-backed": "Monnaie fiduciaire",
   "page-stablecoins-stablecoins-table-type-precious-metals-backed": "Métaux précieux",
@@ -136,32 +132,64 @@
   "page-stablecoins-top-coins-intro": "La capitalisation boursière est",
   "page-stablecoins-top-coins-intro-code": "le nombre total de jetons qui existent, multiplié par la valeur d'un jeton. Cette liste évolue constamment et les projets énumérés ici ne sont pas nécessairement soutenus par l'équipe ethereum.org.",
   "page-stablecoins-types-of-stablecoin": "Comment ça fonctionne : les types de stablecoin",
-  "page-stablecoins-usdc-banner-body": "L'USDC est probablement le stablecoin adossé à un fiat le plus célèbre. Sa valeur est d'environ un dollar et il est soutenu par Circle et Coinbase.",
-  "page-stablecoins-usdc-banner-learn-button": "En savoir plus sur USDC",
-  "page-stablecoins-usdc-banner-swap-button": "Échanger des ETH pour USDC",
-  "page-stablecoins-usdc-banner-title": "USDC",
   "page-stablecoins-usdc-logo": "Le logo USDC",
+  "page-stablecoins-usdt-banner-body": "Tether USD (USDT) est le plus grand stablecoin adossé à une monnaie fiduciaire en termes de capitalisation boursière. Sa valeur est indexée sur 1 dollar américain et ses réserves sont gérées par Tether Limited.",
+  "page-stablecoins-usdt-banner-swap-button": "Échanger des ETH pour des USDT",
+  "page-stablecoins-usdt-banner-learn-button": "En savoir plus sur USDT",
+  "page-stablecoins-usdt-logo": "Le logo USDT",
+  "page-stablecoins-usds-banner-body": "USDS est le successeur de Dai, entièrement adossé à des cryptomonnaies et conçu pour l’épargne et les récompenses onchain. Il est largement utilisé dans la DeFi tout en permettant aux utilisateurs de garder un contrôle total sur leurs fonds.",
+  "page-stablecoins-usds-banner-swap-button": "Échanger des ETH pour des USDS",
+  "page-stablecoins-usds-banner-learn-button": "En savoir plus sur USDS",
+  "page-stablecoins-usds-logo": "Le logo USDS",
+  "page-stablecoins-gho-banner-body": "GHO est un stablecoin décentralisé à collatéral multiple créé par Aave. Il utilise un modèle hybride combinant une garantie en cryptomonnaies avec une approche de gouvernance communautaire.",
+  "page-stablecoins-gho-banner-swap-button": "Échanger des ETH pour des GHO",
+  "page-stablecoins-gho-banner-learn-button": "En savoir plus sur GHO",
+  "page-stablecoins-gho-logo": "Le logo GHO",
+  "page-stablecoins-glo-banner-body": "Le GLO Dollar (USDGLO) est un stablecoin qui reverse tous ses bénéfices à des biens publics et des œuvres caritatives. En détenant ou en utilisant le GLO Dollar, vous contribuez à financer des causes telles que la lutte contre la pauvreté et le soutien à l’open source—sans coût supplémentaire pour vous.",
+  "page-stablecoins-glo-banner-swap-button": "Acheter des GLO",
+  "page-stablecoins-glo-banner-learn-button": "En savoir plus sur GLO",
+  "page-stablecoins-glo-logo": "Le logo USDGLO",
+  "page-stablecoins-hai-banner-title": "HAI",
+  "page-stablecoins-hai-banner-body": "HAI est un stablecoin décentralisé adossé à l’ETH, développé par Let’s Get HAI, axé sur la résistance à la censure et les biens publics. Il est conçu avec une gouvernance minimale et privilégie la stabilité tout en respectant les valeurs de décentralisation.",
+  "page-stablecoins-hai-banner-swap-button": "Créez des HAI avec des ETH",
+  "page-stablecoins-hai-banner-learn-button": "En savoir plus sur HAI",
+  "page-stablecoins-hai-logo": "Le logo HAI",
+  "page-stablecoins-lusd-banner-title": "LUSD",
+  "page-stablecoins-lusd-banner-body": "LUSD est un stablecoin décentralisé issu de Liquity, adossé exclusivement à l’ETH avec un ratio de collatéralisation minimal de 110 %. Il propose des emprunts sans intérêt, des liquidations algorithmiques et une gouvernance minimale, ce qui le rend hautement résistant à la censure.",
+  "page-stablecoins-lusd-banner-swap-button": "Échanger des ETH pour des LUSD",
+  "page-stablecoins-lusd-banner-learn-button": "En savoir plus sur LUSD",
+  "page-stablecoins-lusd-logo": "Le logo LUSD",
   "page-stablecoins-why-stablecoins": "Pourquoi les stablecoins ?",
   "page-stablecoins-how-they-work-button": "Comment ça marche ?",
   "page-stablecoins-why-stablecoins-body": "L'ETH, comme le Bitcoin, a un prix volatile parce que c'est une nouvelle technologie. Vous pouvez donc ne pas vouloir le dépenser trop souvent. Les stablecoins reflètent la valeur des monnaies traditionnelles pour vous donner accès à de l'argent stable que vous pouvez utiliser sur Ethereum.",
   "page-stablecoins-more-defi-button": "En savoir plus sur la finance décentralisée (DeFi)",
   "page-stablecoins-tools-title": "En savoir plus sur les stablecoins",
   "page-stablecoins-tools-stablecoinswtf-description": "Stablecoins.wtf propose un tableau de bord avec des données historiques du marché, des statistiques et du contenu éducatif pour les stablecoins les plus connus.",
-  "page-apps-ready-button": "Aller",
+  "page-stablecoins-tools-stablepulse-description": "Offre une vue claire, précise et peu filtrée de l’écosystème des stablecoins, avec des analyses couvrant les tokens et les blockchains.",
+  "page-stablecoins-tools-stablesinfo-description": "Tableau de bord et classement en direct des stablecoins, suivi de l'offre et des données sur la chaîne pour tous les principaux stablecoins et chaînes.",
+  "page-stablecoins-tools-dune-description": "Tableau de bord fournissant des informations en temps réel sur l’offre, la liquidité, le volume d’échange et l’adoption des stablecoins à travers les blockchains.",
+  "page-stablecoins-tools-visa-description": "Tableau de bord visualisant les mouvements, l’offre et l’utilisation des stablecoins adossés à des monnaies fiduciaires sur les blockchains publiques.",
+  "page-stablecoins-tools-stablewars-description": "Tableau de bord analytique et classement, suivant les soldes, transferts et évaluations des stablecoins sur plusieurs blockchains.",
+  "page-apps-ready-button": "Go",
   "pros": "Avantages",
   "cons": "Inconvénients",
-  "1inch-logo": "Logo 1inch",
-  "aave-logo": "Logo Aave",
+  "1inch-logo": "Logo de 1incho",
+  "aave-logo": "Logo de Aave",
   "binance-logo": "Logo Binance",
   "bittrex-logo": "Logo Bittrex",
+  "buidlbox-logo": "Logo de Buildbox",
   "coinbase-logo": "Logo Coinbase",
   "coinmama-logo": "Logo Coinmama",
   "compound-logo": "Logo Compound",
   "example-projects": "Exemples de projets",
+  "page-stablecoins-filter-by-type": "Filtrer par type",
+  "page-stablecoins-reset-list": "Réinitialiser la liste",
+  "page-stablecoins-show-more": "Afficher plus",
+  "page-stablecoins-no-results": "Aucun stablecoin ne correspond aux filtres actuels",
   "gemini-logo": "Logo Gemini",
-  "gitcoin-logo": "Logo Gitcoin",
   "makerdao-logo": "Logo MakerDao",
   "matcha-logo": "Logo Matcha",
+  "sparkfi-logo": "Logo de Spark Protocol",
   "summerfi-logo": "Logo de Summer.fi",
   "uniswap-logo": "Logo Uniswap",
   "page-stablecoins-go-to": "Aller à"
diff --git a/src/intl/fr/page-staking-deposit-contract.json b/src/intl/fr/page-staking-deposit-contract.json
index 892c66e5b9b..13d23b7e150 100644
--- a/src/intl/fr/page-staking-deposit-contract.json
+++ b/src/intl/fr/page-staking-deposit-contract.json
@@ -8,7 +8,7 @@
   "page-staking-deposit-contract-confirm-address": "Confirmer pour révéler l'adresse",
   "page-staking-deposit-contract-copied": "Adresse copiée",
   "page-staking-deposit-contract-copy": "Copier l'adresse",
-  "page-staking-deposit-contract-blockexplorer": "Voir le contrat sur Etherscan",
+  "page-staking-deposit-contract-blockexplorer": "Voir le contrat sur Blockscout",
   "page-staking-deposit-contract-h2": "Ce n'est pas ici qu'il faut miser",
   "page-staking-deposit-contract-launchpad": "Miser en utilisant la plateforme de lancement",
   "page-staking-deposit-contract-launchpad-2": "Utiliser la plateforme de lancement",
diff --git a/src/intl/fr/page-staking.json b/src/intl/fr/page-staking.json
index f129763a9ce..bbf14270718 100644
--- a/src/intl/fr/page-staking.json
+++ b/src/intl/fr/page-staking.json
@@ -12,7 +12,7 @@
   "comp-withdrawal-credentials-error": "Oups ! Vérifiez le numéro d'index du validateur et réessayez.",
   "comp-withdrawal-credentials-upgraded-1": "L'index du validateur {validatorIndex} est prêt à recevoir des récompenses !",
   "comp-withdrawal-credentials-upgraded-2": "Retrait des informations d'identification liées à l'adresse d'exécution :",
-  "comp-withdrawal-credentials-not-upgraded-1": "Ce validateur de {network} doit être mis à jour.",
+  "comp-withdrawal-credentials-not-upgraded-1": "Ce validateur {network} doit être mis à niveau.",
   "comp-withdrawal-credentials-not-upgraded-2": "Des instructions sur la façon de mettre à niveau peuvent actuellement être trouvées sur la <a href=\"https://launchpad.ethereum.org/withdrawals\" target=\"_blank\" rel=\"noopener noreferrer\">plateforme de lancement de mise en jeu</a>",
   "comp-withdrawal-credentials-verify": "Vérifier sur {network}",
   "page-staking-withdrawals-when": "Expédié !",
@@ -28,7 +28,7 @@
   "page-staking-hero-title": "Comment mettre en jeu vos ETH",
   "page-staking-hero-header": "Gagnez des récompenses en sécurisant Ethereum",
   "page-staking-hero-subtitle": "Tout utilisateur possédant n'importe quelle quantité d'ETH peut aider à sécuriser le réseau et gagner des récompenses.",
-  "page-staking-dropdown-home": "Accueil mise en jeu",
+  "page-staking-dropdown-home": "Page d'accueil de la mise en jeu",
   "page-staking-dropdown-solo": "Mise en jeu à domicile",
   "page-staking-more-on-solo": "En savoir plus sur la mise en jeu à domicile",
   "page-staking-learn-more-solo": "En savoir plus sur la mise en jeu individuelle",
@@ -49,7 +49,7 @@
   "page-staking-guide-title-somer-esat": "Somer Esat",
   "page-staking-guide-title-rocket-pool": "Opérateurs de nœud Rocket Pool",
   "page-staking-guide-title-stakewise": "Opérateurs de nœuds StakeWise",
-  "page-staking-guide-title-lido-csm":"Opérateurs de nœuds Lido CSM",
+  "page-staking-guide-title-lido-csm": "Opérateurs de nœuds Lido CSM",
   "page-staking-guide-description-linux": "Linux (CLI)",
   "page-staking-guide-description-mac-linux": "Linux, macOS (CLI)",
   "page-staking-guide-description-mac-linux-windows": "Linux, Windows, MacOS (CLI)",
@@ -151,10 +151,10 @@
   "page-staking-how-solo-works-item-3": "Synchronisez le client de consensus",
   "page-staking-how-solo-works-item-4": "Générer vos clés et les charger dans votre client validateur",
   "page-staking-how-solo-works-item-5": "Contrôler et entretenez votre nœud",
-  "page-staking-launchpad-widget-start": "Commencer à mettre en jeu sur le {network}",
   "page-staking-launchpad-widget-mainnet-label": "Réseau principal",
+  "page-staking-launchpad-widget-start": "Commencer à miser sur {network}",
   "page-staking-launchpad-widget-span": "Choisir un réseau",
-  "page-staking-launchpad-widget-p1": "Les validateurs solos doivent <strong>tester leur configuration</strong> et leurs compétences opérationnelles sur le réseau de test Hoodi avant de risquer des fonds. N'oubliez pas qu'il est important de choisir un <a href=\"/developers/docs/nodes-and-clients/client-diversity/\">client minoritaire</a> car cela améliore la sécurité du réseau et limite votre risque.",
+  "page-staking-launchpad-widget-p1": "Les validateurs solos doivent <strong>tester leur configuration</strong> et leurs compétences opérationnelles sur le réseau de test {{network}} avant de risquer des fonds. N'oubliez pas qu'il est important de choisir un <a href=\"/developers/docs/nodes-and-clients/client-diversity/\">client minoritaire</a> car cela améliore la sécurité du réseau et limite votre risque.",
   "page-staking-launchpad-widget-p2": "Si vous maîtrisez cette technique, vous pouvez tout configurer en utilisant la ligne de commande et en vous servant seulement de la plateforme de lancement de la mise en jeu.",
   "page-staking-launchpad-widget-p3": "Pour faciliter les choses, découvrez quelques-uns des outils et des guides ci-dessous : ils peuvent vous aider, avec la plateforme de lancement de la mise en jeu, à configurer vos clients en toute simplicité.",
   "page-staking-launchpad-widget-link": "Outils logiciels et guide",
@@ -165,7 +165,7 @@
   "page-staking-stats-box-metric-1": "Nombre total d'ETH mis en jeu",
   "page-staking-stats-box-metric-2": "Nombre total de validateurs",
   "page-staking-stats-box-metric-3": "TAP actuel",
-  "page-staking-stats-box-metric-1-tooltip": "Somme des ETH en jeu sur la chaîne de balises, sans inclure les soldes de plus de 32 ETH",
+  "page-staking-stats-box-metric-1-tooltip": "Somme des ETH éligibles en jeu sur la Chaîne phare",
   "page-staking-stats-box-metric-2-tooltip": "Nombre de comptes de validateur actuellement activés sur la Chaîne Beacon",
   "page-staking-stats-box-metric-3-tooltip": "Rendement financier annuel moyen par validateur sur la dernière période de 24 heures",
   "page-staking-section-comparison-subtitle": "Il n'y a pas de solution unique pour la mise en jeu et chacune d'entre elle a ses particularités. Nous allons comparer ici certains des risques, récompenses et exigences de chaque solution de mise en jeu.",
@@ -191,7 +191,7 @@
   "page-staking-section-comparison-solo-requirements-li1": "Vous devez déposer 32 ETH",
   "page-staking-section-comparison-solo-requirements-li2": "Maintenir un matériel qui exécute à la fois un <a href=\"/glossary/#execution-client\">client d'exécution</a> Ethereum et un <a href=\"/glossary/#consensus-client\">client de consensus</a> tout en étant connecté à l'internet",
   "page-staking-section-comparison-solo-requirements-li3": "La <a href=\"https://hoodi.launchpad.ethereum.org\" target=\"_blank\">Plateforme de lancement de la mise en jeu</a> vous guidera à travers le processus et le matériel nécessaire",
-  "page-staking-section-comparison-saas-requirements-li1": "Deposit 32 ETH and generate your keys with assistance",
+  "page-staking-section-comparison-saas-requirements-li1": "Déposer 32 ETH et générer vos clés avec assistance",
   "page-staking-section-comparison-saas-requirements-li2": "Stockez vos clés en toute sécurité",
   "page-staking-section-comparison-saas-requirements-li3": "Le reste est pris en charge, mais les services spécifiques peuvent varier",
   "page-staking-section-comparison-pools-requirements-li1": "Besoin en ETH moins élevé, certains projets n'exigent que 0,01 ETH",
@@ -232,9 +232,9 @@
   "page-staking-meta-title": "Mise en jeu d'Ethereum : comment ça fonctionne ?",
   "page-staking-withdrawals-important-notices": "Informations importantes",
   "page-staking-withdrawals-important-notices-desc": "Les retraits ne sont pas encore disponibles. Veuillez lire la <a href=\"https://blog.ethereum.org/2021/12/01/eth2-merge-and-post-merge-faq/\" target=\"_blank\">FAQ de Merge Eth2 et post-merge</a> pour plus d'informations.",
-  "page-upgrades-merge-btn": "Plus d'infos sur la fusion",
+  "page-upgrades-merge-btn": "Plus d'informations sur la fusion",
   "subscribe-to-ef-blog": "<a href=\"https://blog.ethereum.org/category/protocol/#subscribe\" target=\"_blank\">Abonnez-vous au Blog EF</a> pour recevoir des notifications par e-mail pour les dernières annonces de protocole.",
   "page-staking-comparison-with-other-options": "Comparaison avec d'autres options",
   "page-staking-any-amount": "Tout montant",
-  "page-staking-network-testnet": "réseau de test {network}"
+  "page-staking-network-testnet": "Réseau de test {network}"
 }
diff --git a/src/intl/fr/page-start.json b/src/intl/fr/page-start.json
new file mode 100644
index 00000000000..6cb9f0c06b5
--- /dev/null
+++ b/src/intl/fr/page-start.json
@@ -0,0 +1,38 @@
+{
+  "page-start-meta-title": "Commencer avec crypto",
+  "page-start-meta-description": "Votre passerelle vers le monde d'Ethereum",
+  "page-start-hero-alt": "Commencer avec crypto",
+  "page-start-title": "Débuter avec Ethereum",
+  "page-start-subtitle": "Ethereum représente bien plus que de simples échanges de jetons sur une plateforme d'échange. Entrez dans ce nouveau monde et apprenez toutes les bases en quelques étapes seulement.",
+  "page-start-share-section-title": "Connaissez-vous quelqu’un qui aurait besoin d’aide pour se lancer ?",
+  "page-start-share-section-description": "Des milliards de personnes sont dans l’impossibilité d’ouvrir des comptes bancaires ou d’utiliser librement leur argent. Le système financier d’Ethereum est toujours ouvert et impartial.",
+  "page-start-man-doge-alt": "Man Doge",
+  "page-start-share-modal-trigger": "Partager cette page",
+  "page-start-share-modal-title": "Partager cette page",
+  "page-start-share-modal-description": "Partagez cette page avec vos amis et votre famille.",
+  "page-start-share-modal-copied": "Copié !",
+  "page-start-share-modal-share": "Partager",
+  "page-start-share-modal-twitter": "Twitter",
+  "page-start-share-modal-tweet-text": "Je me suis connecté à Ethereum sur ethereum.org ! Essayez-le vous-même sur {url}",
+  "page-start-download-wallet-title": "Télécharge un portefeuille",
+  "page-start-download-wallet-description": "Un portefeuille est une application qui te permet de recevoir, d'envoyer des cryptomonnaies et de gérer ton compte Ethereum.",
+  "page-start-download-wallet-checkbox": "J’ai un portefeuille.",
+  "page-start-download-wallet-continue": "Continuer",
+  "page-start-download-wallet-get-wallet": "Obtenir un portefeuille",
+  "page-start-connect-wallet-title": "Connecte ton portefeuille",
+  "page-start-connect-wallet-description": "Vous pouvez utiliser ton nouveau portefeuille comme un compte unique dans toutes les applications et projets sur Ethereum. Aucun compte séparé n’est nécessaire.",
+  "page-start-connect-wallet-account-message": "Voici ton compte",
+  "page-start-connect-wallet-continue": "Continuons",
+  "page-start-connect-wallet-finance-alt": "Finance",
+  "page-start-apps-title": "Utilisons quelques applications",
+  "page-start-apps-description": "Il est temps de passer onchain et de profiter du vaste écosystème de projets qui s’offre à toi.",
+  "page-start-apps-explore-more": "En savoir plus",
+  "page-start-apps-go": "Go",
+  "page-start-apps-socials-tag": "SOCIAUX",
+  "page-start-apps-finance-tag": "FINANCE",
+  "page-start-apps-collectibles-tag": "OBJETS DE COLLECTION",
+  "page-start-apps-farcaster-description": "La plateforme sociale et communautaire de la crypto.",
+  "page-start-apps-aave-description": "Prêtez vos jetons pour gagner des intérêts et retirez à tout moment.",
+  "page-start-apps-uniswap-description": "Échangez vos jetons contre d’autres, partout dans le monde.",
+  "page-start-apps-opensea-description": "Achetez, vendez, découvrez, et échangez des produits en édition limitée."
+}
diff --git a/src/intl/fr/page-trillion-dollar-security.json b/src/intl/fr/page-trillion-dollar-security.json
new file mode 100644
index 00000000000..b6016d8ad3b
--- /dev/null
+++ b/src/intl/fr/page-trillion-dollar-security.json
@@ -0,0 +1,196 @@
+{
+  "page-trillion-dollar-security-meta-title": "Projet de Sécurité à un Billion de Dollars - Rapport de l'aperçu sur les défis de sécurité",
+  "page-trillion-dollar-security-meta-description": "Le projet 1TS est un effort à l'échelle de l'écosystème pour améliorer la sécurité d'Ethereum. Ce rapport examine les défis de sécurité existants auxquels l'écosystème est confronté.",
+  "page-trillion-dollar-security-subtitle": "Projet de Sécurité à un Billion de Dollars",
+  "page-trillion-dollar-security-title": "Aperçu des défis de sécurité",
+  "page-trillion-dollar-security-hero-paragraph-1": "Ethereum est l'écosystème blockchain le plus sécurisé, résilient et fiable. Au cours des 10 dernières années, l'écosystème Ethereum a développé la technologie, les normes et les connaissances qui soutiennent aujourd'hui un écosystème utilisé par des millions de personnes et qui abrite plus de 600 milliards de dollars en capital.",
+  "page-trillion-dollar-security-hero-paragraph-2": "Mais pour qu'Ethereum réussisse dans la prochaine phase d'adoption mondiale, de nombreuses améliorations doivent encore être apportées. Pour réaliser les ambitions de notre communauté, Ethereum doit devenir un écosystème où :",
+  "page-trillion-dollar-security-hero-paragraph-3": "<b>Des milliards d'individus sont à l'aise avec la détention de plus de 1 000 $ sur la chaîne</b>, ce qui représente collectivement des milliers de milliards de dollars sécurisés sur Ethereum.",
+  "page-trillion-dollar-security-hero-paragraph-4": "<b>Les entreprises, institutions et gouvernements se sentent à l'aise de stocker plus d'un billion de dollars de valeur dans un seul contrat ou application</b>, et de réaliser des transactions de montants comparables.",
+  "page-trillion-dollar-security-hero-paragraph-5": "Le projet <a>Sécurité à un Billion de Dollars (1TS)</a> est un effort à l'échelle de l'écosystème pour améliorer la sécurité d'Ethereum. Ce rapport est le premier livrable du projet 1TS. Au cours du dernier mois, nous avons recueilli les retours d'utilisateurs, de développeurs, d'experts en sécurité et d'institutions sur les plus grands défis et domaines à améliorer. Merci aux centaines de personnes et aux dizaines d'organisations qui ont pris le temps de partager leurs idées avec nous.",
+  "page-trillion-dollar-security-hero-paragraph-6": "Ce rapport résume nos conclusions, couvrant 6 domaines distincts :",
+  "page-trillion-dollar-security-report-card-title": "Rapport sur l'aperçu de la sécurité de l'écosystème Ethereum",
+  "page-trillion-dollar-security-download-report": "Télécharger le PDF",
+  "page-trillion-dollar-security-divider-heading": "Rapport sur l'aperçu de la sécurité de l'écosystème Ethereum",
+  "page-trillion-dollar-security-sticky-info": "Ceci est une information de section fixe pour {section}. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque euismod, urna eu tincidunt consectetur.",
+  "page-trillion-dollar-security-content-overview-title": "Aperçu",
+  "page-trillion-dollar-security-user-experience-title": "Expérience utilisateur (UX)",
+  "page-trillion-dollar-security-user-experience-description": "Problèmes affectant la capacité des utilisateurs à gérer de manière sécurisée les clés privées, à interagir avec les applications en chaîne et à signer des transactions.",
+  "page-trillion-dollar-security-smart-contract-title": "Sécurité de contrat intelligent",
+  "page-trillion-dollar-security-smart-contract-description": "Sécurité des composants de contrats intelligents des applications Ethereum et cycle de vie de la production logicielle qui les façonne.",
+  "page-trillion-dollar-security-infrastructure-title": "Sécurité de l'infrastructure et du cloud",
+  "page-trillion-dollar-security-infrastructure-description": "Problèmes liés à l'infrastructure (spécifique à la cryptographie et héritée) dont dépendent les applications Ethereum, comme les chaînes L2, les RPC, les services d'hébergement cloud, et plus encore.",
+  "page-trillion-dollar-security-consensus-title": "Protocole de consensus",
+  "page-trillion-dollar-security-consensus-description": "Les propriétés de sécurité du protocole de base, qui protège la blockchain Ethereum elle-même contre les attaques ou manipulations.",
+  "page-trillion-dollar-security-incident-title": "Surveillance, réponse aux incidents et atténuation",
+  "page-trillion-dollar-security-incident-description": "Les défis auxquels les utilisateurs et les organisations sont confrontés lorsqu'ils répondent à des violations de sécurité, en particulier pour récupérer des fonds ou gérer les conséquences.",
+  "page-trillion-dollar-security-social-title": "Couche sociale et gouvernance",
+  "page-trillion-dollar-security-social-description": "La gouvernance open source d'Ethereum, sa communauté et son écosystème d'organisations.",
+  "page-trillion-dollar-security-hero-closing-paragraph-1": "Ce premier rapport se concentre sur l'identification et la cartographie des problèmes et défis restant à relever. La prochaine étape consistera à choisir les problèmes prioritaires, à identifier des solutions et à travailler avec l'écosystème pour les résoudre.",
+  "page-trillion-dollar-security-hero-closing-paragraph-2": "Parce que l'écosystème Ethereum est décentralisé, sécuriser Ethereum ne peut pas être réalisé par une seule entité. La pile technologique d'Ethereum est construite et maintenue par des organisations indépendantes à travers le monde, allant des portefeuilles à l'infrastructure en passant par les outils pour développeurs. Bien que le projet 1TS soit coordonné par la Fondation Ethereum, nous avons besoin de votre aide pour sécuriser Ethereum.",
+  "page-trillion-dollar-security-hero-closing-paragraph-3": "Vous pouvez contribuer au projet de sécurité 1TS en partageant vos retours et idées :",
+  "page-trillion-dollar-security-feedback-question-1": "Y a-t-il des problèmes de sécurité Ethereum que vous voyez et qui ne sont pas inclus dans ce rapport ?",
+  "page-trillion-dollar-security-feedback-question-2": "Quelles sont, selon vous, les priorités les plus importantes parmi les problèmes recensés ci-dessous ?",
+  "page-trillion-dollar-security-feedback-question-3": "Quelles idées ou solutions proposez-vous pour résoudre ces problèmes ?",
+  "page-trillion-dollar-security-contact-paragraph": "Nous sommes impatients d'avoir de vos nouvelles sur l'adresse <a>trilliondollarsecurity@ethereum.org</a>.",
+  "page-trillion-dollar-security-section-1-intro": "La sécurité commence par l'interface que les gens utilisent pour interagir avec Ethereum. Cette frontière entre les utilisateurs et la blockchain elle-même est une source constante de défis de sécurité.",
+  "page-trillion-dollar-security-section-1-paragraph-1": "Une caractéristique déterminante des blockchains est la nature atomique des transactions : une fois qu'une mise à jour est enregistrée dans la blockchain, il n'y a aucune possibilité d'intervention ou de retour en arrière. Cela offre de fortes garanties de cohérence et de sécurité au niveau du protocole, mais expose les utilisateurs à un risque opérationnel accru : une seule erreur, une clé compromise ou une approbation précipitée peut entraîner une perte irréversible.",
+  "page-trillion-dollar-security-section-1-paragraph-2": "En conséquence, une part importante de la sécurité repose sur l'utilisateur. Pour utiliser Ethereum en toute sécurité, les individus et les organisations doivent détenir et gérer des clés de manière sécurisée, interagir avec des applications en chaîne et utiliser leurs clés pour signer des transactions afin de transférer des actifs ou de mettre à jour l'état d'Ethereum.",
+  "page-trillion-dollar-security-section-1-paragraph-3": "Chacune de ces exigences introduit des risques comme la compromission ou la perte de clés, des approbations précipitées ou mal informées, ou la compromission du logiciel de portefeuille sur lequel les utilisateurs comptent pour les informer et les guider dans leurs interactions avec Ethereum.",
+  "page-trillion-dollar-security-section-1-1-title": "1.1 Gestion des clés",
+  "page-trillion-dollar-security-section-1-1-paragraph-1": "De nombreux utilisateurs ne sont pas équipés pour gérer les clés cryptographiques en toute sécurité.",
+  "page-trillion-dollar-security-section-1-1-paragraph-2": "La plupart des portefeuilles logiciels largement utilisés reposent sur le stockage sécurisé par les utilisateurs de phrases de récupération représentant leur clé privée cryptographique sous-jacente, ce qui les conduit souvent à utiliser des solutions de contournement non sécurisées comme stocker les phrases de récupération en texte brut, sur des services cloud, ou les écrire sur papier.",
+  "page-trillion-dollar-security-section-1-1-paragraph-3": "Les portefeuilles matériels sont une alternative, permettant aux utilisateurs de gérer une clé cryptographique stockée dans un dispositif physique dédié. Cependant, les portefeuilles matériels ont leurs propres défauts et surfaces d'attaque. Les portefeuilles matériels peuvent être perdus, endommagés ou volés. De nombreux portefeuilles matériels ne sont pas open source et peuvent avoir des chaînes d'approvisionnement opaques, augmentant le risque d'une attaque de la chaîne d'approvisionnement où des dispositifs compromis sont vendus sur le marché.",
+  "page-trillion-dollar-security-section-1-1-paragraph-4": "Que les clés soient gérées dans un portefeuille logiciel ou matériel, de nombreux utilisateurs sont, à juste titre, nerveux à l'idée de l'auto-garde lorsqu'elle peut être compromise par un vol physique ou une agression.",
+  "page-trillion-dollar-security-section-1-1-paragraph-5": "Les utilisateurs professionnels et institutionnels font face à des défis supplémentaires en matière de gestion des clés. Si des employés individuels détiennent des clés (par exemple, dans le cadre d'un portefeuille multisig), l'organisation doit pouvoir les remplacer et en créer de nouvelles en raison des changements de personnel au fil du temps. Les exigences de conformité dans différentes industries et juridictions peuvent nécessiter des flux de travail personnalisés ou des pistes d'audit non pris en charge par les logiciels de portefeuille existants. Dans certains cas, les utilisateurs professionnels se tournent vers des dépositaires tiers pour les actifs numériques, ce qui peut introduire une autre couche de risques de sécurité à considérer.",
+  "page-trillion-dollar-security-section-1-2-title": "1.2 Signature aveugle et incertitude des transactions",
+  "page-trillion-dollar-security-section-1-2-paragraph": "Les utilisateurs approuvent régulièrement les transactions « à l’aveugle » sans comprendre ce qu’ils font. Les portefeuilles présentent souvent des données hexadécimales brutes, des adresses de contrat tronquées ou d'autres informations insuffisantes pour que l'utilisateur comprenne les conséquences d'une transaction donnée. Cela rend les utilisateurs de toutes sortes vulnérables aux contrats intelligents malveillants, au phishing, aux escroqueries, aux interfaces usurpées, aux compromissions de l'interface utilisateur et aux erreurs humaines de base.",
+  "page-trillion-dollar-security-section-1-3-title": "1.3 Gestion des approbations et des permissions",
+  "page-trillion-dollar-security-section-1-3-paragraph-1": "Dans de nombreuses applications Ethereum, il est courant que les utilisateurs accordent certaines permissions à l'application sous-jacente dans le cadre d'une utilisation normale. Par exemple, un utilisateur pourrait accorder à un échange décentralisé comme Uniswap la permission de déplacer ses jetons pour les échanger contre de l'ETH.",
+  "page-trillion-dollar-security-section-1-3-paragraph-2": "Ces approbations peuvent avoir des limites sur le montant, mais de nombreux portefeuilles accordent par défaut des approbations illimitées sans date d'expiration. Il n'existe aucun moyen pour les utilisateurs de gérer ou de réviser leurs approbations en cours depuis la plupart des portefeuilles.",
+  "page-trillion-dollar-security-section-1-3-paragraph-3": "Cela peut exposer les utilisateurs à des applications malveillantes ou à des interfaces compromises, car le modèle par défaut pour de nombreux utilisateurs est d'accorder des approbations illimitées qui peuvent être utilisées pour vider leurs fonds. Même si un utilisateur accorde une approbation à un contrat intelligent légitime, si ce contrat est ultérieurement compromis alors que l'approbation reste en place, le contrat compromis pourrait vider les fonds de l'utilisateur.",
+  "page-trillion-dollar-security-section-1-3-paragraph-4": "Cela représente également un risque pour les utilisateurs organisationnels. Par exemple, une organisation pourrait choisir d'accorder à un routeur DEX une allocation illimitée en USDC pour des raisons de commodité opérationnelle, ce qui les expose à des risques si le contrat du routeur est mis à jour.",
+  "page-trillion-dollar-security-section-1-4-title": "1.4 Interfaces web compromises",
+  "page-trillion-dollar-security-section-1-4-paragraph-1": "La plupart des utilisateurs n'interagissent pas directement avec un contrat intelligent, mais via une interface web sur leur appareil mobile ou leur navigateur web.",
+  "page-trillion-dollar-security-section-1-4-paragraph-2": "Ces interfaces peuvent être vulnérables aux attaques par des moyens connus tels que le détournement de DNS, l'injection de JavaScript malveillant, l'hébergement non sécurisé ou diverses dépendances tierces. Une interface utilisateur d'application compromise peut rediriger les utilisateurs de toutes sortes vers des contrats intelligents malveillants ou les amener à signer des transactions trompeuses.",
+  "page-trillion-dollar-security-section-1-5-title": "1.5 Confidentialité",
+  "page-trillion-dollar-security-section-1-5-paragraph-1": "La confidentialité peut atténuer ou amplifier les risques de sécurité pour les utilisateurs de toutes sortes.",
+  "page-trillion-dollar-security-section-1-5-paragraph-2": "Des protections de confidentialité plus faibles exposent les utilisateurs individuels à une variété de menaces ciblées comme le phishing, l'exploitation, les escroqueries ou les attaques physiques. De nombreux modèles d'interfaces utilisateurs courants exposent les utilisateurs, par exemple, la réutilisation d'adresses, les données KYC et d'autres fuites de métadonnées.",
+  "page-trillion-dollar-security-section-1-5-paragraph-3": "Pour les institutions et les entreprises, la confidentialité est souvent une exigence commerciale fondamentale pour des raisons de conformité ou pour certains cas d'utilisation. En plus de ces problèmes, cela peut créer une exposition à des risques de sécurité spécifiques. Par exemple, un utilisateur d'un système de chaîne d'approvisionnement construit sur Ethereum peut exiger de fortes garanties de confidentialité pour protéger les actifs de propriété intellectuelle qui pourraient être compromis si le système était transparent.",
+  "page-trillion-dollar-security-section-1-6-title": "1.6 Fragmentation",
+  "page-trillion-dollar-security-section-1-6-paragraph-1": "Il y a un manque de cohérence dans la manière dont différents portefeuilles gèrent les comportements de base comme l'affichage des transactions, la gestion des approbations ou l'étiquetage des contrats. Cette fragmentation de l'expérience utilisateur ajoute des frictions à la capacité des utilisateurs à apprendre à utiliser les portefeuilles en toute sécurité et augmente les risques.",
+  "page-trillion-dollar-security-section-1-6-paragraph-2": "Par exemple, les utilisateurs ne peuvent pas compter sur des indicateurs d'expérience utilisateur cohérents pour se protéger du phishing et de l'usurpation d'identité, car ils diffèrent selon les portefeuilles. Ils ne peuvent pas se faire d'idées fiables sur le fonctionnement d'Ethereum si chaque outil fonctionne différemment.",
+  "page-trillion-dollar-security-section-2-intro": "Les contrats intelligents sont les composants en chaîne des applications Ethereum : le code qui détient des fonds, définit les contrôles d'accès et applique la logique métier de l'application. Étant donné que les contrats intelligents sont généralement transparents et accessibles à tous, ils représentent une surface d'attaque critique lorsqu'on considère la sécurité dans l'écosystème Ethereum.",
+  "page-trillion-dollar-security-section-2-paragraph-1": "La sécurité des contrats intelligents s'est radicalement améliorée au cours de l'histoire d'Ethereum. Les premiers incidents de sécurité, comme le piratage de la DAO, ont motivé l'écosystème à se professionnaliser et à améliorer les garde-fous tout au long du cycle de vie du logiciel qui mène au déploiement du code en chaîne. Parmi les principales avancées, on peut citer :",
+  "page-trillion-dollar-security-section-2-list-1": "L'audit de sécurité est devenu une pratique standard, avec plusieurs entreprises de sécurité entrant dans l'écosystème et développant leur expertise.",
+  "page-trillion-dollar-security-section-2-list-2": "Les outils, les tests et les systèmes d'analyse statique ont mûri et sont devenus une pratique standard.",
+  "page-trillion-dollar-security-section-2-list-3": "Les bibliothèques de composants communs pré-audités ont fourni aux développeurs des blocs de construction sécurisés par défaut.",
+  "page-trillion-dollar-security-section-2-list-4": "Les techniques de vérification formelle ont été adoptées, en particulier pour les ponts, les systèmes de staking et les contrats de grande valeur.",
+  "page-trillion-dollar-security-section-2-list-5": "La culture de sécurité et les meilleures pratiques de l'écosystème se sont améliorées.",
+  "page-trillion-dollar-security-section-2-list-6": "La création de programmes de primes significatifs qui ont renforcé la couche applicative.",
+  "page-trillion-dollar-security-section-2-paragraph-2": "Cependant, il reste des faiblesses et des domaines à améliorer dans ce domaine.",
+  "page-trillion-dollar-security-section-2-1-title": "2.1 Vulnérabilités des contrats",
+  "page-trillion-dollar-security-section-2-1-paragraph": "Malgré les progrès dans la sécurité des contrats intelligents, il existe encore des vulnérabilités qui peuvent entraîner des problèmes de sécurité importants, notamment :",
+  "page-trillion-dollar-security-section-2-1-list-title-1": "Risque de mise à jour des contrats",
+  "page-trillion-dollar-security-section-2-1-list-desc-1": "Certains contrats sont conçus pour être modifiables après leur déploiement, afin de permettre à une équipe de développement de continuer à mettre à jour et à améliorer une application. Cependant, cela introduit des risques. Les mises à jour pourraient entraîner de nouvelles vulnérabilités ou la perte totale des fonds des utilisateurs en cas de mise à niveau malveillante.",
+  "page-trillion-dollar-security-section-2-1-list-title-2": "Réentrance",
+  "page-trillion-dollar-security-section-2-1-list-desc-2": "lorsqu'un contrat A appelle un contrat externe B avant de mettre à jour son propre état interne, et que le contrat B rappelle le contrat A d'origine avant que le premier appel ne soit terminé.",
+  "page-trillion-dollar-security-section-2-1-list-title-3": "Utilisation non sécurisée de bibliothèques externes",
+  "page-trillion-dollar-security-section-2-1-list-desc-3": "lorsqu'un contrat appelle une bibliothèque externe qui peut être non auditée, malveillante ou susceptible de mise à jour.",
+  "page-trillion-dollar-security-section-2-1-list-title-4": "Composants non audités",
+  "page-trillion-dollar-security-section-2-1-list-desc-4": "Bien que l'audit et l'utilisation de bibliothèques standard se soient améliorés, les développeurs s'appuient parfois sur des composants non audités dans leurs applications.",
+  "page-trillion-dollar-security-section-2-1-list-title-5": "Échecs de contrôle d'accès",
+  "page-trillion-dollar-security-section-2-1-list-desc-5": "lorsque les permissions sont mal configurées ou définies de manière trop large, permettant à des attaquants de réaliser des actions malveillantes.",
+  "page-trillion-dollar-security-section-2-1-list-title-6": "Accès non autorisé",
+  "page-trillion-dollar-security-section-2-1-list-desc-6": "lorsqu'une clé privée capable de contrôler le contrat est obtenue par un acteur malveillant.",
+  "page-trillion-dollar-security-section-2-1-list-title-7": "Ponts et interactions inter-chaînes",
+  "page-trillion-dollar-security-section-2-1-list-desc-7": "Les ponts et les protocoles inter-chaînes introduisent une complexité supplémentaire, et les attaquants peuvent exploiter les faiblesses dans la manière dont les messages inter-chaînes sont transmis ou validés.",
+  "page-trillion-dollar-security-section-2-1-list-title-8": "Délégation ou mauvaise utilisation de signatures de comptes externes (EOA)",
+  "page-trillion-dollar-security-section-2-1-list-desc-8": "Des applications malveillantes peuvent inciter les utilisateurs à signer une délégation complète de leur compte à une autre partie, permettant un vol. Les applications malveillantes peuvent également utiliser les messages signés par l'utilisateur de manière inattendue, par exemple dans une attaque par rejeu.",
+  "page-trillion-dollar-security-section-2-1-list-title-9": "Risque émergent de bogues introduits par la génération de code par IA ou les outils de refactorisation automatisée",
+  "page-trillion-dollar-security-section-2-2-title": "2.2 Expérience des développeurs, outils et langages de programmation",
+  "page-trillion-dollar-security-section-2-2-paragraph": "Les vulnérabilités finissent dans le code déployé en raison d'erreurs des développeurs. Les outils pour développeurs améliorés ont rendu beaucoup plus facile le déploiement de contrats intelligents sécurisés. Cependant, des problèmes subsistent.",
+  "page-trillion-dollar-security-section-2-2-list-title-1": "Manque de paramètres sécurisés par défaut dans les frameworks populaires",
+  "page-trillion-dollar-security-section-2-2-list-desc-1": "Certains outils privilégient la flexibilité ou la rapidité à la sécurité, en définissant des paramètres non sécurisés comme des approbations de jetons illimitées dans la fonction approve(), ou en omettant d'inclure des modèles de contrôle d'accès par défaut.",
+  "page-trillion-dollar-security-section-2-2-list-title-2": "Code personnalisé pour des contrôles opérationnels avancés",
+  "page-trillion-dollar-security-section-2-2-list-desc-2": "Les utilisateurs institutionnels ayant des exigences opérationnelles complexes doivent souvent construire des fonctionnalités requises de toutes pièces, augmentant le risque de vulnérabilités. Il manque des composants ou frameworks sécurisés standardisés pour les flux de travail de sécurité avancés.",
+  "page-trillion-dollar-security-section-2-2-list-title-3": "Couverture de test incohérente",
+  "page-trillion-dollar-security-section-2-2-list-desc-3": "à travers les piles d'outils, ainsi qu'un manque de normes autour de l'utilisation de techniques éprouvées comme le fuzzing ou la vérification d'invariants.",
+  "page-trillion-dollar-security-section-2-2-list-title-4": "Faible adoption des méthodes de vérification formelle",
+  "page-trillion-dollar-security-section-2-2-list-desc-4": "Les techniques de vérification formelle sont puissantes, mais elles sont complexes, coûteuses, nécessitent une expertise spécialisée et ne sont pas bien intégrées dans les flux de travail standard des développeurs, où elles pourraient être utilisées beaucoup plus tôt dans la production de logiciels pour vérifier la sécurité au stade des spécifications.",
+  "page-trillion-dollar-security-section-2-2-list-title-5": "Problèmes liés à la vérification des contrats",
+  "page-trillion-dollar-security-section-2-2-list-desc-5": "Les utilisateurs et les développeurs ne peuvent pas facilement évaluer la fiabilité des contrats déployés, l'étendue de leur validation de sécurité (par exemple, les audits de code) ou la présence de risques latents. Bien que des solutions existent à cet effet, de nombreux problèmes subsistent. Les outils qui traitent ces problèmes ne sont pas largement adoptés, les normes qui unifieraient les approches restent fragmentées, et certains des services existants sont eux-mêmes des dépendances centralisées.",
+  "page-trillion-dollar-security-section-2-2-list-title-6": "Risques liés aux compilateurs",
+  "page-trillion-dollar-security-section-2-2-list-desc-6": "Les compilateurs (les logiciels qui convertissent le code lisible par l'humain, comme Solidity, en bytecode utilisé par l'EVM) peuvent avoir des défauts qui introduisent des erreurs dans les contrats intelligents avant leur déploiement. L'écosystème Ethereum dépend aujourd'hui principalement du compilateur solc, ce qui signifie qu'un bogue pourrait avoir des effets généralisés.",
+  "page-trillion-dollar-security-section-2-2-list-title-7": "Diversité et profondeur des langages de programmation",
+  "page-trillion-dollar-security-section-2-2-list-desc-7": "Bien que Solidity dispose d'un écosystème d'outils approfondi, certains développeurs souhaitent des fonctionnalités de sécurité plus modernes, comme celles présentes dans d'autres langages de programmation, telles que la sécurité de la mémoire.",
+  "page-trillion-dollar-security-section-2-3-title": "2.3 Évaluation des risques du code en chaîne",
+  "page-trillion-dollar-security-section-2-3-paragraph": "Les institutions et les entreprises disposent de processus, normes et exigences existants pour évaluer la sécurité des technologies et systèmes dont elles dépendent. Cependant, les cadres existants ne s'appliquent souvent pas directement aux contrats intelligents, supposant généralement un code mutable, un contrôle centralisé des modifications et des lignes claires de reddition ou de responsabilité juridique. Les systèmes construits sur des contrats intelligents peuvent parfois briser ces hypothèses, rendant difficile pour les organisations d'adopter Ethereum et de gérer les risques de manière appropriée.",
+  "page-trillion-dollar-security-section-3-intro": "De nombreuses utilisations d'Ethereum dépendent de divers fournisseurs d'infrastructure, incluant à la fois des infrastructures spécifiques à la cryptographie (par exemple, les chaînes de couche 2, les fournisseurs de RPC) et des infrastructures traditionnelles de cloud et d'internet (par exemple, AWS, CDN, DNS).",
+  "page-trillion-dollar-security-section-3-paragraph-1": "Ces systèmes constituent une surface d'attaque à la fois pour la couche des portefeuilles et des applications (par exemple, les points d'accès RPC pour les portefeuilles) et pour le protocole Ethereum lui-même (par exemple, de nombreux validateurs sont hébergés sur une infrastructure cloud). La compromission de clés privées, le phishing et le manque de contrôles d'accès granulaires peuvent entraîner des pannes à grande échelle, des vols ou des modifications non autorisées, même si le protocole blockchain sous-jacent reste sécurisé.",
+  "page-trillion-dollar-security-section-3-1-title": "3.1 Chaînes de couche 2",
+  "page-trillion-dollar-security-section-3-1-paragraph": "Les chaînes de couche 2 (L2) servent d'extensions pour Ethereum, permettant des environnements plus rapides et à moindre coût tout en conservant certaines des garanties de sécurité caractéristiques du réseau principal d'Ethereum (selon leur conception spécifique). Cependant, elles présentent également leurs propres surfaces d'attaque distinctes, notamment :",
+  "page-trillion-dollar-security-section-3-1-list-title-1": "Complexité des actifs pontés multi-sauts",
+  "page-trillion-dollar-security-section-3-1-list-desc-1": "Lorsque des actifs transitent entre la L1 et plusieurs L2, ils sont exposés à plusieurs ensembles de contrats qui doivent tous être sécurisés. Des erreurs de comptabilité ou des pannes dans les chaînes L2 peuvent introduire des vulnérabilités exploitables par des attaquants.",
+  "page-trillion-dollar-security-section-3-1-list-title-2": "Les L2 de type rollup dépendent de systèmes de preuve pour garantir la correction des mises à jour d'état",
+  "page-trillion-dollar-security-section-3-1-list-desc-2": "Des bogues ou des mauvaises configurations dans ces systèmes peuvent bloquer ou empêcher la finalisation, ou permettre la finalisation de mises à jour d'état erronées, entraînant une perte de fonds pour les utilisateurs.",
+  "page-trillion-dollar-security-section-3-1-list-title-3": "Les conseils de sécurité sont des groupes de détenteurs de clés qui servent de mécanisme de secours pour mettre à jour le logiciel L2 ou répondre à certaines urgences",
+  "page-trillion-dollar-security-section-3-1-list-desc-3": "Les conseils de sécurité eux-mêmes posent des risques, car une compromission ou une collusion entre les membres pourrait mettre en danger les fonds des utilisateurs ou geler les actifs.",
+  "page-trillion-dollar-security-section-3-1-paragraph-2": "Consultez <a>L2Beat</a> pour un cadre détaillé et un tableau de bord de surveillance qui évalue et compare les performances et la sécurité des L2.",
+  "page-trillion-dollar-security-section-3-2-title": "3.2 Infrastructure RPC et nœuds",
+  "page-trillion-dollar-security-section-3-2-paragraph-1": "Les applications Ethereum dépendent d'un petit nombre de fournisseurs d'infrastructure pour l'accès RPC, les API et les services de nœuds. Cela inclut les fournisseurs d'infrastructure spécifiques à la cryptographie, ainsi que les services cloud traditionnels couramment utilisés pour héberger des nœuds (par exemple, AWS, Cloudflare, Hetzner).",
+  "page-trillion-dollar-security-section-3-2-paragraph-2": "Si ces fournisseurs d'infrastructure étaient hors ligne ou tentaient de censurer ou de limiter l'accès, de nombreux utilisateurs pourraient être empêchés d'accéder à Ethereum via leur portefeuille ou application, jusqu'à ce qu'ils puissent migrer vers un nouveau fournisseur RPC ou autre infrastructure. Certains de ces fournisseurs ont déjà suspendu ou fermé des comptes associés à des activités blockchain, soulevant des préoccupations quant à leur fiabilité à long terme pour les applications décentralisées.",
+  "page-trillion-dollar-security-section-3-3-title": "3.3 Vulnérabilités au niveau du DNS",
+  "page-trillion-dollar-security-section-3-3-paragraph": "Le système de noms de domaine (DNS) est une couche fondamentale d'internet, mais il est également centralisé et peut être compromis. De nombreux utilisateurs accèdent aux applications via des domaines web, qui sont susceptibles de :",
+  "page-trillion-dollar-security-section-3-3-list-1": "Détournement de DNS, où un attaquant insère une fausse interface malveillante.",
+  "page-trillion-dollar-security-section-3-3-list-2": "Saisie de domaine, où un gouvernement ou un registraire peut saisir des domaines.",
+  "page-trillion-dollar-security-section-3-3-list-3": "Phishing via des domaines similaires, où les attaquants enregistrent des noms presque identiques pour tromper les utilisateurs.",
+  "page-trillion-dollar-security-section-3-4-title": "3.4 Chaîne d'approvisionnement logicielle et bibliothèques",
+  "page-trillion-dollar-security-section-3-4-paragraph": "Les développeurs Ethereum s'appuient sur des bibliothèques open-source, souvent téléchargées directement depuis des services comme npm, crates.io ou GitHub. Si ces bibliothèques sont compromises, elles peuvent servir de vecteur pour des attaques telles que :",
+  "page-trillion-dollar-security-section-3-4-list-title-1": "Injection de paquets malveillants",
+  "page-trillion-dollar-security-section-3-4-list-desc-1": "où des attaquants compromettent un paquet largement utilisé ou en publient un sous un nom similaire",
+  "page-trillion-dollar-security-section-3-4-list-title-2": "Dépendances détournées",
+  "page-trillion-dollar-security-section-3-4-list-desc-2": "où les mainteneurs perdent le contrôle d'un projet et un acteur malveillant introduit du code nuisible",
+  "page-trillion-dollar-security-section-3-4-list-title-3": "Compromission des développeurs",
+  "page-trillion-dollar-security-section-3-4-list-desc-3": "où les paquets installés contiennent du code qui donne à l'attaquant le contrôle sur l'ordinateur du développeur.",
+  "page-trillion-dollar-security-section-3-5-title": "3.5 Services de livraison de frontend et risques associés",
+  "page-trillion-dollar-security-section-3-5-paragraph": "De nombreuses applications Ethereum servent leurs interfaces via un réseau de distribution de contenu (CDN) ou une plateforme d'hébergement basée sur le cloud (par exemple, Vercel, Netlify, Cloudflare). Si ces services sont compromis, ils peuvent servir de vecteur pour des attaques comme l'injection de JavaScript malveillant, où les attaquants servent une interface modifiée aux utilisateurs.",
+  "page-trillion-dollar-security-section-3-6-title": "3.6 Censure au niveau des fournisseurs de services Internet",
+  "page-trillion-dollar-security-section-3-6-paragraph-1": "Les fournisseurs de services Internet (ISP) ou les États-nations peuvent utiliser le contrôle de l'infrastructure internet sous-jacente pour censurer l'accès à Ethereum. Par exemple, ces attaques pourraient inclure :",
+  "page-trillion-dollar-security-section-3-6-list-1": "Blocage ou limitation du trafic vers les ports Ethereum courants",
+  "page-trillion-dollar-security-section-3-6-list-2": "Filtrage des requêtes DNS qui renvoient vers des services liés à Ethereum",
+  "page-trillion-dollar-security-section-3-6-list-3": "Géorestriction ou interdictions d'IP contre les nœuds Ethereum connus",
+  "page-trillion-dollar-security-section-3-6-list-4": "Inspection approfondie des paquets pour identifier et censurer le trafic lié au protocole Ethereum",
+  "page-trillion-dollar-security-section-3-6-paragraph-2": "De nombreuses techniques de base sont déjà utilisées par des gouvernements autoritaires à travers le monde pour supprimer l'accès à l'information, aux outils de protestation ou aux cryptomonnaies aujourd'hui.",
+  "page-trillion-dollar-security-section-4-intro": "Le protocole de consensus d'Ethereum définit comment le réseau met à jour l'état de la blockchain Ethereum et parvient à un accord. Ce protocole est à la base de ce qui fait d'Ethereum une plateforme fiable pour l'argent, la finance, l'identité, la gouvernance, les actifs du monde réel, et plus encore.",
+  "page-trillion-dollar-security-section-4-paragraph-1": "Le protocole de consensus d'Ethereum s'est révélé robuste en pratique, avec zéro temps d'arrêt depuis son lancement en 2015 et à travers plusieurs mises à jour. Cependant, il reste des domaines à améliorer à long terme pour rendre le système plus résilient et sécurisé.",
+  "page-trillion-dollar-security-section-4-1-title": "4.1 Fragilité du consensus et risques de récupération",
+  "page-trillion-dollar-security-section-4-1-paragraph": "Les règles de choix de fourche et de finalité d'Ethereum sont résilientes, mais elles ne sont pas invulnérables. Dans certaines conditions limites (comme un désaccord prolongé des validateurs, des bogues clients ou des partitions réseau), le consensus pourrait s'arrêter ou diverger temporairement. Dans des conditions extrêmes, cela pourrait entraîner des pénalités en cascade pour les validateurs par des fuites d'inactivité ou des slashings, ce qui pourrait à son tour provoquer une fuite de capital des validateurs.",
+  "page-trillion-dollar-security-section-4-2-title": "4.2 Diversité des clients",
+  "page-trillion-dollar-security-section-4-2-paragraph": "La diversité des clients, leader dans l'industrie d'Ethereum, protège le réseau contre les bogues dans un seul client. Cependant, la diversité des clients pourrait encore être améliorée avec une adoption accrue des clients minoritaires pour réduire encore plus ces risques.",
+  "page-trillion-dollar-security-section-4-3-title": "4.3 Centralisation du staking et dominance des pools",
+  "page-trillion-dollar-security-section-4-3-paragraph": "Une quantité significative du poids des validateurs est concentrée dans les protocoles de staking liquide, les services de garde et les grands opérateurs de nœuds. Cette concentration peut entraîner des risques tels que :",
+  "page-trillion-dollar-security-section-4-3-list-1": "Capture ou influence de la gouvernance. Si des entités contrôlant de grandes quantités de mise (ou des entités ayant le pouvoir légal d'influencer ces entités) se coordonnaient, elles pourraient avoir une influence démesurée sur les blocs proposés et attestés, pouvant censurer les utilisateurs ou influencer les mises à jour du protocole.",
+  "page-trillion-dollar-security-section-4-3-list-2": "Homogénéité dans le choix des clients et la configuration de l'infrastructure, ce qui peut augmenter les risques d'échecs corrélés.",
+  "page-trillion-dollar-security-section-4-4-title": "4.4 Sanctions sociales non définies et lacunes de coordination",
+  "page-trillion-dollar-security-section-4-4-paragraph": "Dans certains cas de défaillance extrême, Ethereum compterait sur le « slashing social » pour pénaliser les validateurs ayant agi de manière malveillante afin d’attaquer le réseau (voir section 6.1). Cependant, l’infrastructure, les normes et les processus attendus pour ce type de sanction sont peu développés. Il n’existe pas de mécanisme établi que la communauté pourrait utiliser pour mener ce processus.",
+  "page-trillion-dollar-security-section-4-5-title": "4.5 Vecteurs d’attaque économiques et de théorie des jeux",
+  "page-trillion-dollar-security-section-4-5-paragraph": "De nombreux vecteurs d’attaque économiques potentiels restent peu étudiés, notamment :",
+  "page-trillion-dollar-security-section-4-5-list-1": "Attaques de type griefing ou slash griefing. Les validateurs peuvent subir des coûts ou des pénalités de slashing non pas à cause de leurs propres erreurs, mais en raison d’un comportement hostile visant uniquement à nuire aux autres, au détriment de l'attaquant.",
+  "page-trillion-dollar-security-section-4-5-list-2": "Sorties stratégiques ou inactivité programmée. Les validateurs pourraient délibérément se déconnecter ou sortir à des moments critiques afin de maximiser leurs profits ou perturber le consensus avec des pénalités minimales.",
+  "page-trillion-dollar-security-section-4-5-list-3": "Collusion entre validateurs ou relais. Un comportement coordonné entre validateurs, ou entre relais et validateurs, pourrait réduire la décentralisation ou extraire la MEV (Miner Extractable Value).",
+  "page-trillion-dollar-security-section-4-5-list-4": "Exploitation des incitations dans des cas limites liés au MEV, à la séparation proposeur-constructeur ou à la conception du staking liquide. Certains acteurs peuvent manipuler des conditions rares du protocole pour obtenir des récompenses disproportionnées.",
+  "page-trillion-dollar-security-section-4-6-title": "4.6 Risque quantique",
+  "page-trillion-dollar-security-section-4-6-paragraph-1": "La cryptographie centrale d’Ethereum (par exemple les signatures sur courbes elliptiques comme secp256k1) pourrait un jour être déchiffrée par des ordinateurs quantiques. Bien que ce risque ne soit pas imminent, une menace crédible pourrait instantanément rendre vulnérables les portefeuilles, contrats et clés de staking existants. Ce défi futur affaiblit les garanties à long terme d’Ethereum envers ses utilisateurs.",
+  "page-trillion-dollar-security-section-4-6-paragraph-2": "Les trajectoires de migration vers une cryptographie résistante aux ordinateurs quantiques (par exemple, via des schémas de signature post-quantiques) doivent être conçues, testées et éventuellement intégrées au protocole des années avant leur nécessité. Les organisations de l’écosystème Ethereum, y compris la Fondation Ethereum, explorent activement ces options et surveillent les risques.",
+  "page-trillion-dollar-security-section-5-paragraph-1": "Même un écosystème blockchain idéal comportera des risques, des attaques et des vulnérabilités. Lorsque des problèmes surviennent, il doit exister des systèmes efficaces pour atténuer, détecter et répondre. Parmi les défis à relever, on trouve :",
+  "page-trillion-dollar-security-section-5-list-title-1": "Contacter l’équipe concernée",
+  "page-trillion-dollar-security-section-5-list-desc-1": "Il peut être difficile de contacter l’équipe dont l’application a été compromise. Cela peut entraîner des heures de retard, limitant la capacité des intervenants à récupérer les fonds.",
+  "page-trillion-dollar-security-section-5-list-title-2": "Faire remonter les problèmes auprès des organisations concernées",
+  "page-trillion-dollar-security-section-5-list-desc-2": "Lorsque le problème concerne une plateforme (comme un réseau social ou une bourse centralisée), il peut être difficile pour les intervenants de faire remonter l’incident s’ils ne disposent pas d’un contact préalable.",
+  "page-trillion-dollar-security-section-5-list-title-3": "Coordination de la réponse",
+  "page-trillion-dollar-security-section-5-list-desc-3": "Il est souvent difficile de savoir combien d’équipes d’intervention en cas d’incident assistent l’application concernée, ce qui peut entraîner des problèmes de communication ou des efforts inutiles, alors qu’une action coordonnée aurait pu être plus efficace.",
+  "page-trillion-dollar-security-section-5-list-title-4": "Manque de capacités de surveillance",
+  "page-trillion-dollar-security-section-5-list-desc-4": "Il peut être difficile de surveiller les problèmes onchain et offchain, ce qui permettrait d’alerter tôt et d’assurer une réponse rapide aux menaces.",
+  "page-trillion-dollar-security-section-5-list-title-5": "Accès à l’assurance",
+  "page-trillion-dollar-security-section-5-list-desc-5": "L’assurance est un outil essentiel pour limiter les pertes dans la plupart des systèmes traditionnels liés à l’argent, aux systèmes financiers, à l’identité et à d’autres informations précieuses. Cependant, aujourd’hui, peu d’options d’assurance sont disponibles auprès des services financiers traditionnels pour l’écosystème crypto.",
+  "page-trillion-dollar-security-section-6-intro": "La « couche sociale » d’Ethereum désigne l’ensemble des personnes, organisations, entreprises, processus de gouvernance et normes culturelles qui influencent le comportement de l’écosystème Ethereum. Cette couche sociale est elle-même vulnérable à certains types d’attaques ou de risques, pouvant à leur tour affecter la sécurité et la fiabilité d’Ethereum.",
+  "page-trillion-dollar-security-section-6-paragraph-1": "Ces risques ont tendance à être plus orientés sur le long terme et concernent Ethereum dans son ensemble, plutôt que la sécurité des utilisateurs ou applications individuels.",
+  "page-trillion-dollar-security-section-6-1-title": "6.1 Centralisation des stakes",
+  "page-trillion-dollar-security-section-6-1-paragraph-1": "La centralisation de grandes quantités de mise peut représenter un risque pour Ethereum dans son ensemble si les entités contrôlant cette mise décident de se livrer à des pratiques collusoires.",
+  "page-trillion-dollar-security-section-6-1-paragraph-2": "Cette centralisation économique crée un potentiel de capture de la gouvernance sociale. Si un petit groupe de validateurs contrôle une supermajorité dde la mise, ils pourraient :",
+  "page-trillion-dollar-security-section-6-1-list-1": "Se coordonner sur des forks ou y résister.",
+  "page-trillion-dollar-security-section-6-1-list-2": "Censurer certaines transactions ou certains contrats.",
+  "page-trillion-dollar-security-section-6-1-list-3": "Saper le consensus de la communauté en menaçant de se retirer ou de s’y opposer.",
+  "page-trillion-dollar-security-section-6-1-paragraph-3": "Si un tel scénario extrême devait se produire, la communauté Ethereum a suggéré que le « slashing social » pourrait être la solution. Le slashing social consiste à utiliser un consensus social hors chaîne pour décider de pénaliser les validateurs qui se comportent mal, afin de limiter leur pouvoir. Toutefois, il n’existe pas de normes, de procédures ni d’outils clairs pour mettre en œuvre de telles mesures (voir section 4.4).",
+  "page-trillion-dollar-security-section-6-2-title": "6.2 Centralisation des actifs hors chaîne",
+  "page-trillion-dollar-security-section-6-2-paragraph-1": "Ethereum héberge une quantité importante d’actifs du monde réel, lesquels sont détenus hors chaîne dans des comptes bancaires ou d’autres dépôts, puis échangés sur la chaîne via des jetons représentant une créance sur ces actifs hors chaîne. Par exemple, de nombreux grands stablecoins fonctionnent de cette manière.",
+  "page-trillion-dollar-security-section-6-2-paragraph-2": "Les institutions qui détiennent les dépôts hors chaîne peuvent exercer une influence sur l’écosystème Ethereum. Par exemple, dans un scénario extrême où il existe un fork conflictuel ou une mise à niveau du réseau, les gros dépositaires peuvent influencer la chaîne qui sera largement acceptée en choisissant de ne reconnaître les jetons que sur une seule des deux chaînes.",
+  "page-trillion-dollar-security-section-6-3-title": "6.3 Attaque ou pression réglementaire",
+  "page-trillion-dollar-security-section-6-3-paragraph": "Les gouvernements et les régulateurs pourraient faire pression sur diverses entités qui contrôlent des composants essentiels de la pile Ethereum afin de censurer ou d’interférer d’une autre manière avec le protocole Ethereum. Les utilisateurs institutionnels d’Ethereum pourraient également être affectés par ces pressions, ce qui entraînerait d’autres conséquences pour leurs propres utilisateurs (par exemple, une banque qui ne peut plus proposer certains produits cryptographiques en raison d’interdictions réglementaires).",
+  "page-trillion-dollar-security-section-6-4-title": "6.4 Capture organisationnelle de la gouvernance",
+  "page-trillion-dollar-security-section-6-4-paragraph-1": "La gouvernance open source et les processus de développement d’Ethereum sont portés par un ensemble diversifié et mondial d’équipes et d’entreprises qui maintiennent les logiciels clients principaux, l’infrastructure et les outils.",
+  "page-trillion-dollar-security-section-6-4-paragraph-2": "Diverses formes d’influence (acquisitions d’entreprises, dépendances au financement, emploi de contributeurs clés, conflits d’intérêts au sein d’organisations existantes) pourraient progressivement modifier la culture et les priorités de la gouvernance d’Ethereum. Cela pourrait mener à un alignement sur des intérêts commerciaux ou externes spécifiques, divergents de l’esprit communautaire et de la feuille de route établie, affaiblissant potentiellement la neutralité et la résilience d’Ethereum au fil du temps.",
+  "page-trillion-dollar-security-image-alt-hero": "Une visualisation futuriste montrant des nœuds de blockchain interconnectés et des éléments de sécurité, représentant une sécurité de mille milliards de dollars dans l’espace des actifs numériques",
+  "page-trillion-dollar-security-image-alt-report": "Image de couverture du rapport *Trillion Dollar Security* montrant une visualisation moderne de la sécurité numérique avec des éléments de blockchain et des connexions réseau"
+}
diff --git a/src/intl/fr/page-upgrades-get-involved.json b/src/intl/fr/page-upgrades-get-involved.json
index 9e76dcf4ec8..c0a93fba59f 100644
--- a/src/intl/fr/page-upgrades-get-involved.json
+++ b/src/intl/fr/page-upgrades-get-involved.json
@@ -8,12 +8,12 @@
   "page-upgrades-get-involved-bug-li": "problèmes de non-conformité de spécification",
   "page-upgrades-get-involved-bug-li-2": "bogues empêchant la finalité",
   "page-upgrades-get-involved-bug-li-3": "vecteurs de déni de service (DOS)",
-  "page-upgrades-get-involved-bug-li-4": "Et plus encore...",
+  "page-upgrades-get-involved-bug-li-4": "et plus encore...",
   "page-upgrades-get-involved-desc-1": "Exécuter un logiciel client signifie que vous serez un participant actif dans Ethereum. Votre client vous aidera à garder une trace des transactions et à vérifier les nouveaux blocs.",
   "page-upgrades-get-involved-desc-2": "Si vous avez des ETH, vous pouvez les mettre en jeu pour devenir un validateur et aider à sécuriser le réseau. En tant que validateur, vous pouvez gagner des récompenses en ETH.",
   "page-upgrades-get-involved-desc-3": "Rejoignez la communauté des testeurs ! Aidez à tester les mises à niveau d'Ethereum avant qu'elles ne soient publiées, trouvez des bogues et gagnez des récompenses.",
   "page-upgrades-get-involved-ethresearch-1": "Fragmentation",
-  "page-upgrades-get-involved-ethresearch-2": "La Fusion",
+  "page-upgrades-get-involved-ethresearch-2": "La fusion",
   "page-upgrades-get-involved-ethresearch-3": "Execution fragmentée",
   "page-upgrades-get-involved-ethresearch-4": "Tous les sujets de recherche",
   "page-upgrades-get-involved-how": "Comment voulez-vous vous impliquer ?",
@@ -42,6 +42,6 @@
   "page-upgrades-get-involved-written-nim": "Écrit en Nim",
   "page-upgrades-get-involved-written-rust": "Écrit en Rust",
   "page-upgrades-get-involved": "Participez à la mise à niveau d'Ethereum",
-  "page-upgrades-get-involved-2": "S’engager",
+  "page-upgrades-get-involved-2": "S'impliquer",
   "page-upgrades-bug-bounty-leaderboard-points": "points"
 }
diff --git a/src/intl/fr/page-upgrades-index.json b/src/intl/fr/page-upgrades-index.json
index 041e0320034..d4e3cecebd8 100644
--- a/src/intl/fr/page-upgrades-index.json
+++ b/src/intl/fr/page-upgrades-index.json
@@ -39,22 +39,22 @@
   "page-upgrades-beacon-chain-date": "La chaîne phare a été lancée le 1er décembre 2020",
   "page-upgrades-beacon-chain-desc": "La chaîne phare a apporté la mise en jeu à Ethereum, et posé les bases des futures mises à niveau. Elle coordonne la nouvelle preuve d'enjeu d'Ethereum.",
   "page-upgrades-beacon-chain-estimate": "La chaîne phare est active",
-  "page-upgrades-beacon-chain-title": "La Chaîne phare",
+  "page-upgrades-beacon-chain-title": "La chaîne phare",
   "page-upgrades-bug-bounty": "Voir le programme de primes au bogue",
   "page-upgrades-clients": "Découvrez les clients de consensus (précédemment appelés clients « d'Eth2 »)",
   "page-staking-deposit-contract-title": "Vérifiez l'adresse du contrat de dépôt",
   "page-upgrades-dive": "Plongez dans la vision",
   "page-upgrades-dive-desc": "De quelle manière rendons-nous Ethereum plus évolutif, plus sûr et plus durable (tout en gardant l'éthique fondamentale de décentralisation d'Ethereum) ?",
-  "page-upgrades-docking": "La Fusion",
+  "page-upgrades-docking": "La fusion",
   "page-upgrades-merge-answer-1": "La Fusion a eu lieu le 15 septembre 2022 lorsque Ethereum est passé au consensus par mise en jeu. La Chaîne Phare a fusionné avec le réseau principal, dépréciant officiellement la preuve de travail sur Ethereum, et réduisant la consommation d'énergie d'Ethereum de ~99,95 %.",
-  "page-upgrades-merge-btn": "Plus d'infos sur la fusion",
+  "page-upgrades-merge-btn": "Plus d'informations sur la fusion",
   "page-upgrades-merge-desc": "Le réseau principal Ethereum a fusionné avec la chaîne phare de preuve d'enjeu, marquant ainsi la fin du minage à forte intensité énergétique.",
   "page-upgrades-merge-estimate": "La Fusion est en ligne",
   "page-upgrades-merge-mainnet": "Qu'est-ce que le réseau principal ?",
   "page-upgrades-eth-blog": "blog ethereum.org",
   "page-upgrades-explore-btn": "Explorez les améliorations",
   "page-upgrades-get-involved": "Participez à la mise à niveau d'Ethereum",
-  "page-upgrades-get-involved-2": "S’impliquer",
+  "page-upgrades-get-involved-2": "S'impliquer",
   "page-upgrades-head-to-ethresearch": "Visitez ethresear.ch",
   "page-upgrades-help": "Souhaitez-vous aider à mettre à niveau Ethereum ?",
   "page-upgrades-help-desc": "Il existe de nombreuses opportunités pour participer aux mises à niveau d'Ethereum, aider à réaliser des tests, et même gagner des récompenses.",
@@ -181,7 +181,7 @@
   "page-upgrades-what-happened-to-eth2-3": "Pour limiter la confusion, la communauté a mis à jour ces termes :",
   "page-upgrades-what-happened-to-eth2-3-1": "« Eth1 » est maintenant « la couche d'exécution », qui gère les transactions et les exécutions.",
   "page-upgrades-what-happened-to-eth2-3-2": "« Eth2 » est maintenant la « couche de consensus », qui gère le consensus de la preuve d'enjeu.",
-  "page-upgrades-what-happened-to-eth2-4": "Ces mises à jour d'ordre terminologique ne concernent que les conventions de nommage ; les objectifs et la feuille de route d'Ethereum restent inchangés.",
+  "page-upgrades-what-happened-to-eth2-4": "Ces mises à jour terminologiques ne modifient que les conventions de nomenclature. Elles ne modifient pas les objectifs ou la feuille de route d'Ethereum.",
   "page-upgrades-what-happened-to-eth2-5": "En savoir plus sur le changement de nom « Eth2 »",
   "page-upgrades-why-cant-we-just-use-eth2-title": "Pourquoi ne pas juste utiliser Eth2 ?",
   "page-upgrades-why-cant-we-just-use-eth2-mental-models-title": "Mentalités",
@@ -204,5 +204,5 @@
   "docs-nav-proof-of-stake": "Preuve d'enjeu",
   "docs-nav-proof-of-work": "Preuve de travail",
   "page-upgrades-get-involved-ethresearch-1": "Fragmentation",
-  "page-upgrades-get-involved-ethresearch-2": "La Fusion"
+  "page-upgrades-get-involved-ethresearch-2": "La fusion"
 }
diff --git a/src/intl/fr/page-upgrades.json b/src/intl/fr/page-upgrades.json
index 014c2ae1d4f..73f410f960d 100644
--- a/src/intl/fr/page-upgrades.json
+++ b/src/intl/fr/page-upgrades.json
@@ -7,9 +7,9 @@
   "page-upgrades-pbs": "Pas imminent - attendez 2024/25",
   "page-upgrades-post-merge-banner-tutorial-ood": "Ce tutoriel est obsolète depuis la fusion et peut ne pas fonctionner. Veuillez éditer un PR sur GitHub si vous souhaitez contribuer.",
   "page-upgrades-upgrades-guide": "Guide des mises à niveau d'Ethereum",
-  "page-upgrades-upgrades-docking": "La Fusion",
+  "page-upgrades-upgrades-docking": "La fusion",
   "page-upgrades-shard-title": "Fragmentation",
-  "page-upgrades-upgrades-beacon-chain": "La Chaîne phare",
+  "page-upgrades-upgrades-beacon-chain": "La chaîne phare",
   "consensus-beaconscan-title": "beaconscan",
   "consensus-beaconscan-in-title": "beaconcha.in",
   "consensus-beaconcha-in-desc": "Explorateur open source de la chaîne phare",
@@ -19,5 +19,5 @@
   "consensus-explore": "Explorer les données",
   "consensus-run-beacon-chain": "Exécuter un client de consensus",
   "consensus-run-beacon-chain-desc": "Ethereum a besoin qu'un maximum de clients s'exécutent. Aidez ce bien public Ethereum !",
-  "read-more": "En savoir plus"
+  "read-more": "Voir plus"
 }
diff --git a/src/intl/fr/page-wallets-find-wallet.json b/src/intl/fr/page-wallets-find-wallet.json
index e698db3d15d..e5b12ab8e77 100644
--- a/src/intl/fr/page-wallets-find-wallet.json
+++ b/src/intl/fr/page-wallets-find-wallet.json
@@ -36,7 +36,7 @@
   "page-find-wallet-token-importing-desc": "Importer n'importe quel jeton ERC-20 à utiliser dans le portefeuille",
   "page-find-wallet-buy-crypto": "Achetez des cryptomonnaies",
   "page-find-wallet-buy-crypto-desc": "Acheter des cryptomonnaies avec fiat directement dans le portefeuille \n *Note : l'achat de cryptomonnaies peut être spécifique a la région",
-  "page-find-wallet-sell-for-fiat": "Vendre pour des fiat",
+  "page-find-wallet-sell-for-fiat": "Vendre en monnaie fiduciaire",
   "page-find-wallet-sell-for-fiat-desc": "Vendre des cryptomonnaies à fiat dans le portefeuille \n *Note : le retrait de cryptomonnaies peut être spécifique à la région",
   "page-find-wallet-multisig": "Multi-signatures",
   "page-find-wallet-multisig-desc": "Portefeuilles nécessitant plusieurs signatures pour autoriser une transaction",
@@ -84,5 +84,8 @@
   "page-find-wallet-social-links": "Liens",
   "page-find-wallet-empty-results-title": "Aucun résultat",
   "page-find-wallet-empty-results-desc": "Il n'y a pas de portefeuilles qui correspondent à vos critères, réessayez en supprimant certains filtres.",
-  "page-find-wallet-see-wallets": "Voir les portefeuilles"
+  "page-find-wallet-privacy": "Confidentialité",
+  "page-find-wallet-privacy-desc": "Portefeuilles qui prennent en charge les transactions privées intégrées",
+  "page-find-wallet-see-wallets": "Voir les portefeuilles",
+  "page-find-wallet-search-languages": "Rechercher des langues..."
 }
diff --git a/src/intl/fr/page-wallets.json b/src/intl/fr/page-wallets.json
index 4b5f690d72a..b60bab6b14e 100644
--- a/src/intl/fr/page-wallets.json
+++ b/src/intl/fr/page-wallets.json
@@ -7,7 +7,7 @@
   "page-wallets-blog": "Blog de Coinbase",
   "page-wallets-bookmarking": "Ajoutez votre portefeuille aux favoris",
   "page-wallets-bookmarking-desc": "Si vous utilisez un portefeuille en ligne, ajoutez le site à vos favoris pour vous protéger contre les tentatives de phishing.",
-  "page-wallets-cd": "<b>Les portefeuilles matériels</b> sont des appareils qui vous permettent de conserver votre cryptomonnaie hors ligne – ce qui est très sécurisé",
+  "page-wallets-cd": "<b>Les portefeuilles matériels physiques</b> sont des appareils qui vous permettent de conserver votre cryptomonnaie hors ligne – ce qui est très sécurisé",
   "page-wallets-desc-2": "Les portefeuilles sont ce que la plupart des gens utilisent pour gérer leurs actifs numériques et leur identité.",
   "page-wallets-desc-2-link": "Plus d'infos sur ETH",
   "page-wallets-desc-3": "Votre portefeuille est un outil pour interagir avec votre compte Ethereum. Cela signifie que vous pouvez changer de fournisseur de portefeuille à tout moment. De nombreux portefeuilles vous permettent également de gérer plusieurs comptes Ethereum à partir d'une seule application.",
diff --git a/src/intl/fr/page-what-is-ether.json b/src/intl/fr/page-what-is-ether.json
new file mode 100644
index 00000000000..de210b02ec2
--- /dev/null
+++ b/src/intl/fr/page-what-is-ether.json
@@ -0,0 +1,100 @@
+{
+  "page-what-is-ether-meta-title": "Qu'est-ce que l'Ether (ETH) ? (Un guide complet) | ethereum.org",
+  "page-what-is-ether-meta-description": "L'ether (ETH) est la cryptomonnaie native d'Ethereum. Découvrez à quoi il sert, comment et où l'acheter, sa quantité en circulation et ce qui affecte son prix.",
+  "page-what-is-ether-twitter-meta-description": "L'ether (ETH) est la cryptomonnaie native d'Ethereum. Découvrez à quoi il sert, comment et où l'acheter, sa quantité en circulation et plus encore.",
+  "page-what-is-ether-title": "Qu'est-ce que l'Ether (ETH) ?",
+  "page-what-is-ether-hero-description-1": "L'ether (ETH) est la cryptomonnaie native qui alimente le réseau Ethereum. Il est utilisé pour payer les frais de transaction (appelés « gaz ») pour l'utilisation du réseau et des applications qui y sont bâties, pour sécuriser le réseau par la mise en jeu (staking), et sert de monnaie numérique pour les paiements et les investissements, sans être contrôlé par une entité, une organisation ou un gouvernement central. L'ETH est l'une des plus grandes cryptomonnaies par capitalisation boursière.",
+  "page-what-is-ether-what-is-ether-description-1": "L'ether, communément appelé ETH, est le carburant qui alimente la blockchain Ethereum. Contrairement au bitcoin, qui sert principalement de monnaie numérique, l'ether a de multiples usages au sein de l'écosystème Ethereum.",
+  "page-what-is-ether-what-is-ether-description-2": "<strong>En tant que cryptomonnaie native d'Ethereum, l'ETH est utilisé pour :</strong>",
+  "page-what-is-ether-what-is-ether-description-3": "Payer les frais de transaction (gaz) pour l'utilisation du réseau et de ses applications",
+  "page-what-is-ether-what-is-ether-description-4": "Sécuriser le réseau Ethereum grâce à la mise en jeu (staking)",
+  "page-what-is-ether-what-is-ether-description-5": "L'ETH a été introduit en 2015 lors du lancement d'Ethereum et est depuis devenu l'un des <assets>actifs les plus précieux au monde</assets>.",
+  "page-what-is-ether-what-is-ether-description-6": "Pour les consommateurs",
+  "page-what-is-ether-what-is-ether-description-7": "L'ETH permet des paiements mondiaux sans banques, des achats de jetons non fongibles (NFT) et l'accès à des applications de finance décentralisée (DeFi). Il est résistant à la censure et offre une fonctionnalité transfrontalière 24h/24 et 7j/7.",
+  "page-what-is-ether-what-is-ether-description-8": "Pour les développeurs",
+  "page-what-is-ether-what-is-ether-description-9": "L'ETH sert à payer les frais de transaction lors du déploiement de contrats intelligents sur le réseau principal Ethereum. C'est également la principale devise utilisée dans de nombreuses applications de l'écosystème Ethereum.",
+  "page-what-is-ether-what-is-ether-description-10": "Pour les investisseurs",
+  "page-what-is-ether-what-is-ether-description-11": "L'ETH fonctionne comme une réserve de valeur et un actif générateur de rendement grâce à la mise en jeu (staking). Il offre une exposition à la croissance du Web3 et à l'économie numérique en expansion.",
+  "page-what-is-ether-what-is-ether-description-12": "En savoir plus sur la mise en jeu (staking) d'ETH",
+  "page-what-is-ether-how-to-buy-eth": "Comment acheter des ETH",
+  "page-what-is-ether-how-to-buy-eth-description-1": "Acheter de l'ETH est simple, avec plusieurs options selon vos besoins et votre emplacement. <strong>Commencez toujours par une plateforme de confiance</strong> offrant une sécurité renforcée.",
+  "page-what-is-ether-how-to-buy-eth-description-2": "Pour les consommateurs, achetez de l'ETH via des plateformes d'échange de cryptomonnaies ou des applications de portefeuille.",
+  "page-what-is-ether-how-to-buy-eth-description-3": "<strong>Aparté</strong>",
+  "page-what-is-ether-how-to-buy-eth-description-4": "Lorsque vous achetez de l'ETH, vous entendrez parler de « <strong>compte/adresse</strong> » et de « <strong>portefeuille</strong> ».",
+  "page-what-is-ether-how-to-buy-eth-description-5": "Considérez votre <strong>compte comme votre adresse e-mail</strong>, où les gens vous envoient de l'argent.",
+  "page-what-is-ether-how-to-buy-eth-description-6": "Considérez votre <strong>portefeuille comme votre application de messagerie</strong>, où vous consultez vos soldes et effectuez des paiements.",
+  "page-what-is-ether-how-to-buy-eth-description-7": "Vous pouvez acheter de l'ETH avec :",
+  "page-what-is-ether-how-to-buy-eth-description-8": "<strong>Cartes de crédit/débit</strong> : instantanément mais avec des frais plus élevés",
+  "page-what-is-ether-how-to-buy-eth-description-9": "<strong>Virements bancaires</strong> : plus lents mais avec des frais moins élevés",
+  "page-what-is-ether-how-to-buy-eth-description-10": "<strong>PayPal</strong> ou services similaires là où ils sont disponibles",
+  "page-what-is-ether-how-to-buy-eth-description-11": "<strong>Pour les entreprises</strong>, les plateformes d'échange proposent des comptes d'entreprise avec des limites plus élevées, une meilleure assistance, des fonctionnalités de conformité, des remises sur volume et une sécurité renforcée.",
+  "page-what-is-ether-how-to-buy-eth-description-12": "Autres manières d'obtenir de l'ETH :",
+  "page-what-is-ether-how-to-buy-eth-description-13": "<strong>Recevoir des paiements</strong> de personnes que vous connaissez",
+  "page-what-is-ether-how-to-buy-eth-description-14": "<strong>Fournir des liquidités</strong> sur des protocoles de finance décentralisée",
+  "page-what-is-ether-how-to-buy-eth-description-15": "<strong>Mettre en jeu de l'ETH</strong> pour gagner des récompenses tout en sécurisant le réseau Ethereum",
+  "page-what-is-ether-how-to-buy-eth-description-16": "En savoir plus sur comment et où acheter de l'ETH",
+  "page-what-is-ether-how-to-send-and-receive-eth": "Comment envoyer et recevoir de l'ETH",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-1": "<strong>L'envoi d'ETH</strong> nécessite un portefeuille et une adresse de destinataire. Saisissez leur adresse, spécifiez le montant, vérifiez les frais de transaction, et confirmez. Les transactions arrivent généralement en moins de 30 secondes et ne peuvent pas être annulées une fois confirmées.",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-2": "<strong>La réception d'ETH</strong> nécessite de partager votre adresse Ethereum ou votre code QR avec l'expéditeur. Les fonds apparaissent dans votre portefeuille après la confirmation du réseau, la plupart des portefeuilles fournissant des notifications.",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-3": "<strong>Besoin d'aide ?</strong> Lisez le guide <howToUseWallet>Comment utiliser un portefeuille</howToUseWallet>.",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-4": "Lorsque vous achetez de l'ETH, vous entendrez parler de « <strong>compte/adresse</strong> » et de « <strong>portefeuille</strong> ».",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-5": "Considérez votre <strong>compte comme votre adresse e-mail</strong>, où les gens vous envoient de l'argent.",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-6": "Considérez votre <strong>portefeuille comme votre application de messagerie</strong>, où vous consultez vos soldes et effectuez des paiements.",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-7": "Pour des montants plus importants, envisagez d'utiliser des portefeuilles matériels pour plus de sécurité.",
+  "page-what-is-ether-how-to-send-and-receive-eth-description-8": "Découvrez ce qu'est Ethereum et comment cela fonctionne.",
+  "page-what-is-ether-how-to-send-and-receive-eth-callout": "Ne partagez votre adresse Ethereum qu'avec des contacts de confiance. Comme Ethereum est un registre public, ils peuvent voir votre solde et vos transactions. Ils ne peuvent pas accéder à vos fonds, mais la confidentialité est recommandée.",
+  "page-what-is-ether-how-long-does-it-take-to-send-eth": "Combien de temps faut-il pour envoyer de l'ETH ?",
+  "page-what-is-ether-how-long-does-it-take-to-send-eth-description-1": "Les transactions d'ETH se terminent généralement en moins de 30 secondes. Le réseau Ethereum traite des blocs toutes les 12 secondes, bien que les transactions puissent être mises en file d'attente en cas de congestion.",
+  "page-what-is-ether-how-long-does-it-take-to-send-eth-description-2": "Les transactions atteignent la « finalité » après environ 15 minutes, contre une moyenne de 60 minutes pour Bitcoin.",
+  "page-what-is-ether-how-long-does-it-take-to-send-eth-description-3": "En période de trafic réseau élevé, vous pouvez accélérer les transactions en payant des frais de transaction plus élevés, ce qui vous place en tête de file. Les frais sont partagés entre les validateurs et un mécanisme de brûlage (burning).",
+  "page-what-is-ether-how-much-does-it-cost-to-send-eth": "Combien coûte l'envoi d'ETH ?",
+  "page-what-is-ether-how-much-does-it-cost-to-send-eth-description-1": "Les transactions Ethereum nécessitent des <strong>frais de transaction payés en ETH</strong>. Les frais sont calculés en fonction du travail de calcul requis (mesuré en « gaz ») et de la demande actuelle du réseau. Le prix du gaz fluctue avec le trafic du réseau, ce qui rend les transactions moins coûteuses pendant les périodes creuses.",
+  "page-what-is-ether-l2s": "Présentation des L2 : mise à l'échelle d'Ethereum",
+  "page-what-is-ether-l2s-description-1": "À mesure que la popularité d'Ethereum augmente, il devient difficile de maintenir des frais de transaction bas. Les réseaux de <strong>couche 2 (L2)</strong> répondent à ce problème.",
+  "page-what-is-ether-l2s-description-2": "Les L2 comme <optimism>Optimism</optimism> et <arbitrum>Arbitrum</arbitrum> offrent des <strong>frais 10 à 100 fois moins chers</strong> tout en héritant de la sécurité d'Ethereum. Ils traitent les transactions hors chaîne et publient les données sur Ethereum.",
+  "page-what-is-ether-l2s-description-3": "Considérez-les comme des voies rapides qui permettent des transactions plus rapides et moins chères, en parallèle de l'autoroute principale qu'est Ethereum.",
+  "page-what-is-ether-l2s-description-4": "Les <strong>transferts sur L2 coûtent généralement moins de 0,01 $</strong>, ce qui rend Ethereum accessible à des millions d'utilisateurs supplémentaires grâce à des intégrations avec des entreprises comme Robinhood, PayPal et Shopify.",
+  "page-what-is-ether-what-is-the-eth-supply": "Quelle est l'offre d'ETH ?",
+  "page-what-is-ether-what-is-the-eth-supply-description-1": "Contrairement au plafond fixe de 21 millions de Bitcoin, l'ETH a une mécanique d'offre dynamique :",
+  "page-what-is-ether-what-is-the-eth-supply-description-2": "De nouveaux ETH sont émis pour récompenser les validateurs du réseau à un taux limité calculé par le protocole",
+  "page-what-is-ether-what-is-the-eth-supply-description-3": "Une partie de chaque frais de transaction est définitivement « brûlée » (supprimée de l'existence)",
+  "page-what-is-ether-what-is-the-eth-supply-description-4": "Cela crée des périodes alternées d'inflation et de déflation en fonction de l'utilisation du réseau",
+  "page-what-is-ether-what-is-the-eth-supply-description-5": "<strong>Équilibre attendu</strong> : Le système équilibre la sécurité du réseau avec la préservation de la valeur à long terme. Une utilisation élevée entraîne une déflation ; une faible utilisation entraîne une inflation.",
+  "page-what-is-ether-what-is-the-eth-supply-description-6": "Sources des données : <etherscan>Etherscan</etherscan>, <ultrasound>Ultrasound Money</ultrasound>",
+  "page-what-is-ether-what-is-the-distribution-of-eth": "Quelle est la distribution de l'ETH ?",
+  "page-what-is-ether-what-is-the-distribution-of-eth-description-1": "La propriété est largement répartie sur des <etherscan>dizaines de millions d'adresses</etherscan>, ce qui empêche la concentration du contrôle et renforce la décentralisation.",
+  "page-what-is-ether-breakdown": "Répartition de la distribution de l'ether",
+  "page-what-is-ether-breakdown-description-1": "<strong>Ether en jeu (staked)</strong> : Des dizaines de millions d'ETH <beaconchain>verrouillés</beaconchain> pour la sécurité du réseau",
+  "page-what-is-ether-breakdown-description-2": "<strong>Plateformes d'échange</strong> : les plateformes centralisées <unchained>détiennent 13 à 16 %</unchained> de l'offre",
+  "page-what-is-ether-breakdown-description-3": "<strong>Contrats intelligents</strong> : Des montants importants dans des contrats intelligents, y compris des protocoles DeFi",
+  "page-what-is-ether-breakdown-description-4": "<strong>Fondation Ethereum</strong> : détient <ef>moins de 0,3 %</ef> de l'offre (contre 9 % en 2014)",
+  "page-what-is-ether-who-holds-most": "Qui en détient le plus ?",
+  "page-what-is-ether-who-holds-most-description-1": "Les adresses Ethereum avec les soldes d'ETH les plus élevés ne sont généralement pas celles de particuliers. La grande majorité de l'ether visible dans les adresses Ethereum du « top » représente les fonds collectifs et mis en commun de nombreuses personnes et entités différentes, et non les avoirs d'un seul individu.",
+  "page-what-is-ether-who-holds-most-description-2": "Les comptes ETH avec les soldes les plus élevés incluent généralement :",
+  "page-what-is-ether-who-holds-most-description-3": "Le contrat de dépôt de la Chaîne Phare : Le solde du contrat de dépôt représente tous les ETH qui ont été <staked>mis en jeu</staked> pour aider à sécuriser le réseau Ethereum. Bien qu'il s'agisse de l'adresse Ethereum avec le plus grand solde d'ETH, elle ne représente pas un compte de portefeuille Ethereum accessible. C'est un contrat intelligent qui accepte les dépôts d'ETH comme première étape pour participer à la mise en jeu (staking), puis gère les soldes de cet ether sur l'ensemble des validateurs actifs du réseau.",
+  "page-what-is-ether-who-holds-most-description-4": "Contrats intelligents : Beaucoup d'autres adresses Ethereum à solde élevé représentent les contrats intelligents qui alimentent les applications basées sur Ethereum, comme les adresses de contrat intelligent pour les protocoles de finance décentralisée (DeFi), les ponts, ou les organisations autonomes décentralisées (DAO). Ces soldes de contrat représentent l'ether que de nombreux portefeuilles ont déposé pour participer à leur application.",
+  "page-what-is-ether-who-holds-most-description-5": "Comptes omnibus : Ce sont de grands portefeuilles gérés par des plateformes d'échange, des plateformes et des fonds (comme Coinbase, Robinhood ou Binance). Lorsqu'un utilisateur achète de l'ETH sur une plateforme d'échange, il est souvent conservé dans l'un de ces comptes massifs aux côtés de l'ETH détenu par des milliers d'autres clients de la plateforme.",
+  "page-what-is-ether-who-holds-most-description-6": "Vous pouvez consulter une liste en direct des adresses de portefeuille Ethereum avec les soldes d'ETH les plus élevés sur <etherscan>Etherscan ici</etherscan>.",
+  "page-what-is-ether-distribution": "Pourquoi la distribution est-elle importante pour la décentralisation",
+  "page-what-is-ether-distribution-description-1": "Une large distribution empêche le contrôle centralisé. La véritable décentralisation dépend du nombre de nœuds et de validateurs indépendants qui maintiennent le réseau.",
+  "page-what-is-ether-what-makes-eth-valuable": "Qu'est-ce qui donne de la valeur à l'ETH ?",
+  "page-what-is-ether-what-makes-eth-valuable-description-1": "L'ETH tire sa valeur de plusieurs sources :",
+  "page-what-is-ether-what-makes-eth-valuable-description-2": "<strong>Utilité du réseau</strong> : toutes les transactions Ethereum nécessitent de l'ETH pour les frais de gaz, ce qui crée une demande constante qui croît avec l'adoption du réseau.",
+  "page-what-is-ether-what-makes-eth-valuable-description-3": "<strong>Récompenses de mise en jeu (staking)</strong> : les validateurs d'ETH gagnent des rendements tout en sécurisant le réseau, ce qui séduit à la fois les investisseurs individuels et institutionnels.",
+  "page-what-is-ether-what-makes-eth-valuable-description-4": "<strong>Réserve de valeur</strong> : beaucoup considèrent l'ETH comme du « pétrole numérique », un actif rare avec une réelle utilité qui alimente l'économie numérique.",
+  "page-what-is-ether-what-makes-eth-valuable-description-5": "<strong>Dynamique de l'offre</strong> : le brûlage des frais crée une pression déflationniste pendant les périodes de forte utilisation. Depuis 2021, des <ultrasound>millions d'ETH ont été définitivement retirés</ultrasound> de la circulation.",
+  "page-what-is-ether-what-is-wrapping-eth": "Qu'est-ce que l'encapsulation d'ETH (wrapping) ?",
+  "page-what-is-ether-what-is-wrapping-eth-description-1": "L'ETH encapsulé (WETH) est un jeton ERC-20 qui représente l'ETH sur une base de 1:1. De nombreuses applications décentralisées et réseaux L2 sont conçus pour gérer les jetons ERC-20, mais l'ETH natif n'est pas un jeton ERC-20. L'« encapsulation » (wrapping) consiste à verrouiller de l'ETH dans un contrat intelligent et à émettre une représentation ERC-20 de cet ETH verrouillé (WETH), ce qui permet de l'utiliser dans toutes les applications et sur tous les L2 qui ne peuvent accepter que des jetons ERC-20.",
+  "page-what-is-ether-what-is-wrapping-eth-description-2": "Les utilisations courantes incluent :",
+  "page-what-is-ether-what-is-wrapping-eth-description-3": "Paires de trading sur les plateformes d'échange décentralisées comme <uniswap>Uniswap</uniswap>",
+  "page-what-is-ether-what-is-wrapping-eth-description-4": "Garantie sur les plateformes de prêt comme <aave>Aave</aave>",
+  "page-what-is-ether-what-is-wrapping-eth-description-5": "Enchères sur les places de marché NFT comme <opensea>OpenSea</opensea>",
+  "page-what-is-ether-what-is-wrapping-eth-description-6": "Le WETH peut être désencapsulé en ETH à tout moment avec des frais minimes. Le WETH est détruit, et l'ETH qu'il représentait est libéré du contrat intelligent. La plupart des applications gèrent le processus d'encapsulation et de désencapsulation de manière transparente.",
+  "page-what-is-ether-what-is-wrapping-eth-description-7": "En savoir plus sur l'ETH encapsulé (WETH)",
+  "page-what-is-ether-gas-table-transaction-type": "Type de transaction",
+  "page-what-is-ether-gas-table-typical-cost-range": "Fourchette de coût en direct",
+  "page-what-is-ether-gas-table-estimated-gas-units": "Unités de gaz estimées",
+  "page-what-is-ether-gas-table-row-1-1": "Transferts d'ETH",
+  "page-what-is-ether-gas-table-row-2-1": "Échange de jetons",
+  "page-what-is-ether-gas-table-row-3-1": "Transactions DeFi/NFT complexes"
+}
\ No newline at end of file
diff --git a/src/intl/fr/page-what-is-ethereum.json b/src/intl/fr/page-what-is-ethereum.json
index c1b0f1e51aa..d16637618a0 100644
--- a/src/intl/fr/page-what-is-ethereum.json
+++ b/src/intl/fr/page-what-is-ethereum.json
@@ -43,7 +43,7 @@
   "page-what-is-ethereum-how-intro-4": "S'ils le font correctement, ils gagnent des ETH. S'ils trichent, ils perdent une partie de leur mise.",
   "page-what-is-ethereum-how-intro-5": "Voici un exemple :",
   "page-what-is-ethereum-how-example-1-title": "Lorsque vous envoyez 10 $ en stablecoins à un ami sur Ethereum :",
-  "page-what-is-ethereum-how-example-1-step-1": "Vous ouvrez votre portefeuille, ajoutez l'adresse du compte et le montant, puis cliquez sur envoyer.",
+  "page-what-is-ethereum-how-example-1-step-1": "Ouvrez votre portefeuille, ajoutez l'adresse du compte de destination et le montant, puis cliquez sur Envoyer.",
   "page-what-is-ethereum-how-example-1-step-2": "Votre portefeuille signe le paiement et le diffuse sur le réseau.",
   "page-what-is-ethereum-how-example-1-step-3": "Le paiement attend dans la file d'attente publique (mempool) jusqu'à ce que le validateur de bloc proposé le sélectionne.",
   "page-what-is-ethereum-how-example-1-step-4": "Le validateur de bloc proposé l'ajoute au prochain bloc des transactions, le diffuse et perçoit une commission (récompense).",
@@ -155,7 +155,7 @@
   "page-what-is-ethereum-when-who-learn-more": "En savoir plus sur l'histoire d'Ethereum",
   "page-what-is-ethereum-roadmap-title": "Quelle est la feuille de route d’Ethereum pour 2025 ?",
   "page-what-is-ethereum-roadmap-intro-1": "En fait, Ethereum ne suit pas de feuille de route fixe. Il suit une vision partagée.",
-  "page-what-is-ethereum-roadmap-intro-2": "Les mises à niveau du réseau sont réalisées sous forme de propositions EIP et développées publiquement par des contributeurs du monde entier. Aucune équipe centrale ne décide de la suite des opérations ; mais une communauté d'individus qui construisent ce qu'ils jugent utile en fonction des besoins des utilisateurs.",
+  "page-what-is-ethereum-roadmap-intro-2": "Les mises à niveau du réseau sont réalisées sous forme d'EIP et développées publiquement par des contributeurs du monde entier. Aucune équipe centrale ne décide de ce qui se passe, il s'agit simplement de personnes qui développent ce qu'elles jugent utile en fonction des besoins des utilisateurs.",
   "page-what-is-ethereum-roadmap-intro-3": "Pectra est la dernière mise à jour effectuée en mai 2025. Elle a amélioré la prise en charge et les fonctionnalités du portefeuille, offert plus de flexibilité aux stakers et facilité l'exécution des dApps sur les L2. L'objectif était d'améliorer la convivialité sans compromettre la sécurité ni la décentralisation.",
   "page-what-is-ethereum-roadmap-priorities-intro": "<a>En se tournant vers l'avenir</a>, les priorités d'Ethereum incluent :",
   "page-what-is-ethereum-roadmap-priority-1": "Rendre le protocole principal et ses L2 plus rapides et moins chers pour tout le monde",
diff --git a/src/intl/fr/page-what-is-the-ethereum-network.json b/src/intl/fr/page-what-is-the-ethereum-network.json
new file mode 100644
index 00000000000..c09b288b98c
--- /dev/null
+++ b/src/intl/fr/page-what-is-the-ethereum-network.json
@@ -0,0 +1,89 @@
+{
+  "page-what-is-ethereum-network-meta-title": "Qu'est-ce que le réseau Ethereum ? | ethereum.org",
+  "page-what-is-ethereum-network-meta-description": "Comprenez ce qu'est le réseau Ethereum, la mise en jeu et la sécurité, les frais de réseau (alias gaz), les réseaux de mise à l'échelle de couche 2 et comment explorer les données du réseau en direct.",
+  "page-what-is-ethereum-network-twitter-meta-description": "Comprenez ce qu'est le réseau Ethereum, la mise en jeu et la sécurité, les frais de réseau, les réseaux de mise à l'échelle de couche 2 et comment explorer les données du réseau en direct.",
+  "page-what-is-ethereum-network-title": "Qu'est ce que le réseau Ethereum ?",
+  "page-what-is-ethereum-network-description-1": "Le réseau Ethereum est l'infrastructure physique et numérique qui sous-tend Ethereum.",
+  "page-what-is-ethereum-network-description-2": "Cela inclut les nœuds qui stockent les données, les validateurs qui traitent les transactions, les logiciels qui exécutent les contrats intelligents et les réseaux de couche 2 qui mettent Ethereum à l'échelle au-delà de la chaîne principale.",
+  "page-what-is-ethereum-network-section-network-fees-title": "Que sont les frais de réseau Ethereum (alias les frais de gaz) ?",
+  "page-what-is-ethereum-network-section-staking-title": "Qu'est-ce que la mise en jeu et comment sécurise-t-elle le réseau ?",
+  "page-what-is-ethereum-network-section-layer-2s-title": "Que sont les couches 2 d'Ethereum et comment mettent-elles le réseau à l'échelle ?",
+  "page-what-is-ethereum-network-section-live-network-data-title": "Comment explorer les données du réseau Ethereum en direct",
+  "page-what-is-ethereum-network-read-next-title": "Lire la suite",
+  "page-what-is-ethereum-network-read-next-item-1": "Que sont les portefeuilles ?",
+  "page-what-is-ethereum-network-read-next-item-2": "Qu'est-ce que l'ether (ETH) ?",
+  "page-what-is-ethereum-network-read-next-item-3": "Qu'est-ce que le Web3 ?",
+  "page-what-is-ethereum-network-read-next-item-4": "En apprendre plus sur le réseau Ethereum",
+  "page-what-is-ethereum-network-section-description-1": "Lorsque les gens parlent d'Ethereum, ils font généralement référence à plusieurs choses différentes. Il y a l'écosystème d'applications et d'actifs numériques, la plateforme logicielle open source et la devise native, l'ether (ETH).",
+  "page-what-is-ethereum-network-section-description-2": "Mais en dessous de tout cela se trouve le <strong>réseau Ethereum</strong> ; la fondation physique et numérique qui lie tout.",
+  "page-what-is-ethereum-network-section-description-3": "À la base, le réseau Ethereum est un ensemble de <strong>milliers d'ordinateurs indépendants appelés nœuds</strong>. Ces nœuds sont <strong>exploités par des personnes du monde entier</strong>. Ils travaillent ensemble pour stocker des données, exécuter des contrats intelligents et enregistrer chaque transaction sur un registre public et ouvert.",
+  "page-what-is-ethereum-network-section-description-4": "Le réseau Ethereum gère plusieurs tâches clés, telles que :",
+  "page-what-is-ethereum-network-section-description-5": "la mise à jour des comptes et des soldes des utilisateurs",
+  "page-what-is-ethereum-network-section-description-6": "l'exécution de contrats intelligents (programmes exécutant des applications)",
+  "page-what-is-ethereum-network-section-description-7": "le suivi de la propriété des actifs numériques (comme les stablecoins et les NFT)",
+  "page-what-is-ethereum-network-section-description-8": "le traitement de toutes les transactions qui transitent par Ethereum chaque jour",
+  "page-what-is-ethereum-network-section-description-9": "Heureusement, vous n'avez pas besoin de comprendre comment le réseau fonctionne pour l'utiliser.",
+  "page-what-is-ethereum-network-section-description-10": "La plupart des gens utilisent simplement le réseau via un <a>portefeuille numérique</a>. <strong>Un portefeuille</strong> est généralement une application Web ou mobile qui vous permet d'<strong>envoyer</strong> et de <strong>recevoir des ETH, de gérer vos actifs</strong> et d'utiliser des applications.",
+  "page-what-is-ethereum-network-section-description-11": "D'autres types d'utilisateurs comme les développeurs et les entreprises qui construisent sur Ethereum peuvent utiliser des API, des logiciels de nœuds ou déployer des contrats intelligents.",
+  "page-what-is-ethereum-network-section-description-12": "Le réseau Ethereum est différent des systèmes traditionnels en raison de sa conception. <strong>Le code et les données d'Ethereum sont stockés sur des nœuds décentralisés</strong> dans le monde entier, donc personne ne peut bloquer votre accès ou fermer votre application.",
+  "page-what-is-ethereum-network-section-description-13": "Et comme tout le monde peut y participer, cela ouvre la voie à un accès mondial et à l'innovation.",
+  "page-what-is-ethereum-network-section-description-14": "Ces qualités permettent des choses qui n'étaient pas possibles auparavant, comme :",
+  "page-what-is-ethereum-network-section-description-15": "la propriété des données",
+  "page-what-is-ethereum-network-section-description-16": "des médias sociaux sans déplateformisation",
+  "page-what-is-ethereum-network-section-description-17": "des systèmes financiers ouverts et transparents",
+  "page-what-is-ethereum-network-section-description-18": "Fondamentalement, le réseau Ethereum est une base pour la propriété numérique et la participation ouverte.",
+  "page-what-is-ethereum-network-section-description-19": "Vous entendrez peut-être des gens faire référence au <strong>réseau principal Ethereum (Mainnet)</strong>. C'est le même réseau Ethereum que des millions de personnes utilisent chaque jour, où de vrais actifs sont échangés et où de vraies applications vivent. Mais « Mainnet » aide à le distinguer des réseaux de couche 2 d'Ethereum et des réseaux de test (testnets) que les développeurs utilisent pour essayer de nouvelles fonctionnalités avant de les mettre en ligne.",
+  "page-what-is-ethereum-network-gas-section-description-1": "Chaque transaction sur Ethereum coûte une petite somme appelée frais de gaz. Que vous envoyiez des ETH, échangiez des jetons ou utilisiez une application, vous payez une petite quantité de gaz chaque fois que vous écrivez des données sur la blockchain.",
+  "page-what-is-ethereum-network-gas-section-description-2": "<strong>Les frais de gaz assurent le bon fonctionnement d'Ethereum</strong>. Sans eux, des acteurs malveillants pourraient spammer le réseau avec des transactions vides et le rendre inutilisable en raison d'une forte congestion, car il n'y aurait aucun moyen de prioriser les transactions en fonction des frais que les utilisateurs sont prêts à payer.",
+  "page-what-is-ethereum-network-gas-section-description-3": "Les frais de gaz d'Ethereum couvrent le coût des nombreuses ressources différentes qu'une transaction peut consommer, telles que le calcul, la bande passante ou le stockage. Tout cela est abstrait en une seule valeur pour les utilisateurs, mais une R&D approfondie est nécessaire pour déterminer combien chaque opération devrait coûter par rapport aux autres.",
+  "page-what-is-ethereum-network-gas-section-description-4": "Alors, que se passe-t-il lorsque vous payez du gaz ? Une partie est <strong>payée au validateur</strong> qui ajoute votre transaction à un « bloc » de transactions. Une autre partie est <strong>« brûlée », la retirant de la circulation</strong>.",
+  "page-what-is-ethereum-network-gas-section-description-5": "Cela aide à équilibrer l'offre et la demande, car <strong>lorsque le réseau est occupé, les frais augmentent</strong>. Lorsque les choses sont plus calmes, les frais diminuent.",
+  "page-what-is-ethereum-network-gas-section-description-6": "Depuis que le réseau a <blog>introduit le brûlage de frais</blog> en août 2021, <strong>des millions d'ETH <beaconchain>ont été brûlés</beaconchain></strong>. Vous pouvez explorer les derniers chiffres en utilisant les <ultrasound>tableaux de bord et explorateurs de réseau</ultrasound> construits par la communauté Ethereum.",
+  "page-what-is-ethereum-network-gas-section-description-7": "Alors, combien coûte une transaction ?",
+  "page-what-is-ethereum-network-gas-section-description-8": "Eh bien, <strong>les frais varient en fonction de ce que vous faites</strong>. Envoyer simplement des ETH peut coûter moins d'un dollar. L'échange de jetons sur un échange décentralisé (DEX) peut coûter quelques dollars ou plus, surtout si le réseau est occupé. Plus la transaction est complexe, plus elle coûte de gaz.",
+  "page-what-is-ethereum-network-gas-section-description-9": "Les frais de gaz sont l'une des parties les plus visibles de l'utilisation d'Ethereum, en particulier pour les nouveaux utilisateurs, mais tout cela contribue à rendre le réseau plus fiable et plus sûr.",
+  "page-what-is-ethereum-network-gas-section-description-10": "En savoir plus sur les frais de réseau d'Ethereum",
+  "page-what-is-ethereum-network-staking-section-description-1": "Le réseau Ethereum est sécurisé par un système appelé mise en jeu (staking). C'est ainsi qu'Ethereum <strong>vérifie les transactions, ajoute de nouveaux blocs</strong> et maintient le réseau <strong>à l'abri des attaques</strong>.",
+  "page-what-is-ethereum-network-staking-section-description-2": "À ses débuts, Ethereum utilisait un mécanisme de consensus (un moyen de s'accorder sur qui possède quoi) appelé preuve de travail. C'est le même mécanisme que Bitcoin utilise aujourd'hui.",
+  "page-what-is-ethereum-network-staking-section-description-3": "En septembre 2022, Ethereum est passé à un mécanisme de consensus de preuve d'enjeu plus sûr et plus économe en énergie.",
+  "page-what-is-ethereum-network-staking-section-description-4": "Alors, comment cela fonctionne-t-il ?",
+  "page-what-is-ethereum-network-staking-section-description-5": "En termes simples, les gens bloquent une partie de leurs ETH <strong>(mettent leurs ETH en jeu)</strong>, en guise de dépôt afin de pouvoir aider à <strong>sécuriser le réseau</strong>. Ces personnes sont appelées validateurs. Lorsque vous mettez des ETH en jeu, votre validateur est choisi pour vérifier et ajouter de nouvelles transactions. Si vous le faites honnêtement, vous <strong>gagnez des récompenses</strong>. Si vous <strong>essayez de tricher, vous perdez une partie de votre mise</strong>.",
+  "page-what-is-ethereum-network-staking-section-description-6": "La mise en jeu est la manière dont Ethereum s'engage de manière crédible envers la qualité de son service. Tout cet argent en jeu a le plus grand intérêt à ce qu'Ethereum reste sécurisé : parieriez-vous contre lui ?",
+  "page-what-is-ethereum-network-staking-section-description-7": "À peine deux ans après le lancement de la preuve d'enjeu, Ethereum a attiré <validators>plus d'un million de validateurs</validators> qui mettent en jeu <stakedEther>des millions d'ETH</stakedEther> pour sécuriser Ethereum. <strong>Cela rend Ethereum extrêmement coûteux et difficile à attaquer</strong>. En effet, pour attaquer le réseau, <strong>une entité a besoin d'au moins 1/3 de tous les ETH mis en jeu pour commencer à attaquer le réseau</strong>. Aujourd'hui, cela représente des dizaines de milliards de dollars, et même dans ce cas, l'attaque échouerait probablement car plus d'un tiers en désaccord avec le reste du réseau empêcherait la finalisation, mais la chaîne continuerait de croître avec l'autre version considérée comme la source de vérité. Plus de 1/2 change la version considérée comme la vérité, et plus de 2/3 permettrait de finaliser quelque chose avec lequel le reste n'est pas d'accord.",
+  "page-what-is-ethereum-network-staking-section-description-8": "C'est ce qui donne à Ethereum sa « <strong>sécurité économique</strong> ». Il ne s'agit pas seulement d'avoir la bonne technologie. Il s'agit de rendre les attaques trop coûteuses pour même être tentées.",
+  "page-what-is-ethereum-network-staking-section-description-9": "Pour aider à sécuriser le réseau Ethereum, vous pouvez le faire de deux manières principales.",
+  "page-what-is-ethereum-network-staking-section-description-10": "La première façon est d'exécuter un nœud. Les nœuds stockent tout l'historique de la blockchain, y compris toutes les transactions et les données des contrats intelligents. En se synchronisant avec d'autres nœuds, ils peuvent s'accorder sur l'état du réseau, s'assurant que les transactions sont légitimes et que les données des contrats intelligents sont disponibles.",
+  "page-what-is-ethereum-network-staking-section-description-11": "La deuxième façon est de mettre en jeu vos ETH. La manière la plus simple est de passer par un fournisseur de mise en jeu comme <lido>Lido</lido> ou <rocketpool>Rocketpool</rocketpool>, mais si vous avez les connaissances nécessaires, essayez d'exécuter un logiciel de validateur chez vous.",
+  "page-what-is-ethereum-network-staking-section-description-12": "En savoir plus sur la mise en jeu et comment la pratiquer",
+  "page-what-is-ethereum-network-staking-section-description-13": "Apprenez à exécuter un nœud",
+  "page-what-is-ethereum-network-layer-2s-section-description-1": "À mesure qu'Ethereum devient plus populaire, le réseau devient plus encombré. Lorsque la demande est élevée, les frais de gaz augmentent et les transactions prennent plus de temps. Pour résoudre ce problème, les développeurs ont construit une série de <strong>réseaux compagnons</strong> appelés couches 2.",
+  "page-what-is-ethereum-network-layer-2s-section-description-2": "Les couches 2, également appelées L2, sont d'autres réseaux qui <strong>fonctionnent au-dessus d'Ethereum</strong>. Elles traitent les transactions séparément, puis envoient un résumé pour être stocké sur Ethereum.",
+  "page-what-is-ethereum-network-layer-2s-section-description-3": "Vous pouvez les considérer comme des voies express sur une autoroute. Au lieu que chaque transaction passe par le réseau principal d'Ethereum, beaucoup d'entre elles utilisent ces routes plus rapides et moins chères.",
+  "page-what-is-ethereum-network-layer-2s-section-description-4": "Parmi les L2 les plus populaires, on trouve <strong>Base, Arbitrum, Optimism, zkSync</strong> et <strong>Starknet</strong>. Chacun d'eux fonctionne légèrement différemment, mais l'idée est la même : mettre Ethereum à l'échelle sans compromettre la sécurité.",
+  "page-what-is-ethereum-network-layer-2s-section-description-5": "Un simple transfert d'ETH sur Optimism ou zkSync peut <l2fees>coûter seulement 0,04 $</l2fees>, contre 0,3 à 1 $ sur le réseau principal d'Ethereum. D'autres transactions comme l'échange de jetons <l2fees>peuvent coûter seulement 0,20 $</l2fees>. Pour les utilisateurs, cela signifie des <strong>transactions plus rapides pour une fraction du prix</strong>.",
+  "page-what-is-ethereum-network-layer-2s-section-description-6": "En conséquence, les L2 se développent rapidement. Ensemble, ils détiennent <l2beat>des milliards de dollars d'actifs numériques</l2beat>.",
+  "page-what-is-ethereum-network-layer-2s-section-description-7": "Comme les L2 bénéficient de la sécurité d'Ethereum, les entreprises qui cherchent à créer des paiements et des applications mondiales ont commencé à construire sur Ethereum.",
+  "page-what-is-ethereum-network-layer-2s-section-description-8": "Par exemple, Robinhood a récemment <robinhood>lancé son propre L2</robinhood> pour explorer un règlement plus rapide pour les actions. PayPal <paypal>a déplacé son stablecoin PYUSD vers le L2 d'Ethereum Arbitrum</paypal>. Shopify permet désormais aux <shopify>commerçants d'accepter le stablecoin USDC</shopify> sur Base.",
+  "page-what-is-ethereum-network-layer-2s-section-description-9": "Pour les utilisateurs, le déplacement d'actifs entre Ethereum et les L2 est simple. Vous pouvez utiliser des ponts, construits par des L2 comme <superbridge>Superbridge par Optimism</superbridge> ou <portal>Portal par ZKsync</portal> pour déplacer des ETH et d'autres actifs. Vous pouvez même utiliser des outils tiers comme <hop>Hop</hop> et <across>Across</across> qui sont construits par des équipes indépendantes.",
+  "page-what-is-ethereum-network-layer-2s-section-description-10": "En savoir plus sur les réseaux de couche 2 d'Ethereum",
+  "page-what-is-ethereum-network-live-network-data-section-description-1": "Ethereum est transparent par conception. Chaque action sur le réseau, de l'envoi d'ETH à l'exécution d'un validateur, est enregistrée sur un registre public et ouvert que tout le monde peut consulter.",
+  "page-what-is-ethereum-network-live-network-data-section-description-2": "Cela contraste fortement avec le fonctionnement de la plupart des systèmes aujourd'hui :",
+  "page-what-is-ethereum-network-live-network-data-section-description-3": "les banques et les institutions publient leurs chiffres internes",
+  "page-what-is-ethereum-network-live-network-data-section-description-4": "les chiffres d'utilisation des applications sont jalousement gardés par les entreprises technologiques",
+  "page-what-is-ethereum-network-live-network-data-section-description-5": "les données économiques arrivent souvent en retard et sont révisées plus tard",
+  "page-what-is-ethereum-network-live-network-data-section-description-6": "Avec Ethereum, vous n'avez pas à faire confiance. Vous pouvez vérifier.",
+  "page-what-is-ethereum-network-live-network-data-section-description-7": "Vous n'avez pas besoin de comprendre tout cela pour utiliser Ethereum. Mais si vous êtes curieux de savoir combien de transactions ont été réglées en 2024, ou combien de nouvelles adresses Ethereum ont été créées au cours des six derniers mois, il existe des outils qui permettent à quiconque d'explorer le réseau en temps réel.",
+  "page-what-is-ethereum-network-live-network-data-section-description-8": "Voici quelques-unes des sources de données les plus utiles, et l'usage que vous pourriez en faire :",
+  "page-what-is-ethereum-network-live-network-data-section-description-9": "<etherscan>Etherscan</etherscan> : Vérifiez les transactions, l'activité du portefeuille et les contrats intelligents",
+  "page-what-is-ethereum-network-live-network-data-section-description-10": "<beaconcha>beaconcha.in</beaconcha> : Consultez les statistiques des validateurs, les niveaux de mise en jeu et la santé du réseau",
+  "page-what-is-ethereum-network-live-network-data-section-description-11": "<ultrasound>ultrasound.money</ultrasound> : Suivez l'offre d'ETH, l'émission et le brûlage en temps réel",
+  "page-what-is-ethereum-network-live-network-data-section-description-12": "<l2fees>l2fees.info</l2fees> : Comparez les coûts de transaction actuels sur Ethereum et les L2",
+  "page-what-is-ethereum-network-live-network-data-section-description-13": "<l2beat>L2Beat</l2beat> : Consultez la valeur sécurisée et les modèles de sécurité de toutes les principales L2",
+  "page-what-is-ethereum-network-live-network-data-section-description-14": "<growthepie>growthepie</growthepie> : Consultez toute l'activité et la croissance en chaîne sur Ethereum",
+  "page-what-is-ethereum-network-live-network-data-section-description-15": "<dune>Dune</dune> : Explorez des tableaux de bord personnalisés sur tous les actifs numériques à travers Ethereum",
+  "page-what-is-ethereum-network-live-network-data-section-description-16": "<tokenterminal>Token Terminal</tokenterminal> : Comparez les revenus des dapps, leur utilisation et les performances des protocoles",
+  "page-what-is-ethereum-network-live-network-data-section-description-17": "<nansen>Nansen</nansen> : Suivez les flux des portefeuilles, les mouvements des stablecoins et les tendances de la « smart money ».",
+  "page-what-is-ethereum-network-live-network-data-section-description-18": "Tous ces outils sont là si vous en avez besoin.",
+  "page-what-is-ethereum-network-live-network-data-section-description-19": "Que vous soyez un développeur, un chercheur, un investisseur ou simplement quelqu'un qui veut vérifier une transaction, le réseau ouvert d'Ethereum vous donne les données — en direct, sans permission et vérifiables.",
+  "page-what-is-ethereum-network-live-network-data-section-description-20": "Parcourir les tableaux de bord du réseau Ethereum et les explorateurs de blocs"
+}
\ No newline at end of file
diff --git a/src/intl/fr/table.json b/src/intl/fr/table.json
index 8229ae4ad4e..3853310f27b 100644
--- a/src/intl/fr/table.json
+++ b/src/intl/fr/table.json
@@ -1,7 +1,7 @@
 {
   "table-active": "actif",
   "table-filters": "Filtres",
-  "table-showing": "Affiché ",
+  "table-showing": "Affiche",
   "table-reset-filters": "Réinitialiser",
   "table-what-are-you-looking-for": "Que cherchez-vous ?"
 }
\ No newline at end of file
diff --git a/src/intl/fr/template-usecase.json b/src/intl/fr/template-usecase.json
index b50c0f2c131..44c8a4070c1 100644
--- a/src/intl/fr/template-usecase.json
+++ b/src/intl/fr/template-usecase.json
@@ -2,15 +2,19 @@
   "template-usecase-dropdown-ai-agents": "Agents IA",
   "template-usecase-dropdown-defi": "Finance décentralisée (DeFi)",
   "template-usecase-dropdown-nft": "Jetons non fongibles (NFT)",
-  "template-usecase-dropdown-dao": "Organisations Autonomes Décentralisées (DAO)",
+  "template-usecase-dropdown-dao": "Organisations autonomes décentralisées (DAO)",
+  "template-usecase-dropdown-apps": "applications Ethereum",
   "template-usecase-dropdown-payments": "Paiements Ethereum",
   "template-usecase-dropdown-prediction-markets": "Marchés prédictifs",
   "template-usecase-dropdown-social-networks": "Réseaux sociaux décentralisés",
+  "template-usecase-dropdown-restaking": "Re-mise en jeu",
   "template-usecase-dropdown-identity": "Identité décentralisée",
   "template-usecase-dropdown-desci": "La science décentralisée (DeSci)",
   "template-usecase-dropdown-refi": "Finance régénérative (ReFi)",
   "template-usecase-dropdown": "Cas d'utilisation d'Ethereum",
   "template-usecase-banner": "Les utilisations d'Ethereum sont en cours de développement et d'évolution. Si vous pensez à une information qui rendra les choses plus claires ou plus à jour, ajoutez la.",
   "template-usecase-edit-link": "Modifier la page",
-  "template-usecase-dropdown-aria": "Menu déroulant du cas d'utilisation"
+  "template-usecase-dropdown-aria": "Menu déroulant du cas d'utilisation",
+  "template-usecase-dropdown-onchain-gaming": "Jeux en chaîne",
+  "template-usecase-dropdown-rwa": "Actifs du monde réel (RWA)"
 }
diff --git a/src/scripts/i18n/post_import_sanitize.ts b/src/scripts/i18n/post_import_sanitize.ts
index e3ec46ded32..0a414ed1af3 100644
--- a/src/scripts/i18n/post_import_sanitize.ts
+++ b/src/scripts/i18n/post_import_sanitize.ts
@@ -269,9 +269,7 @@ function fixBrandTags(
 
     // Targeted replacement: find the exact quoted tag in frontmatter and replace
     // Match the tag with its surrounding quotes to avoid false positives
-    const quotedTagRe = new RegExp(
-      `(["'])${escapeRegex(transTag)}\\1`
-    )
+    const quotedTagRe = new RegExp(`(["'])${escapeRegex(transTag)}\\1`)
     if (quotedTagRe.test(updatedFm)) {
       updatedFm = updatedFm.replace(quotedTagRe, `$1${canonical}$1`)
       fixCount++
@@ -393,23 +391,17 @@ function fixEscapedBoldAndItalic(content: string): {
       if (lines[j].trimStart().startsWith("|")) continue
 
       // Fix escaped bold first: \*\*text\*\* → **text**
-      lines[j] = lines[j].replace(
-        /\\\*\\\*(.+?)\\\*\\\*/g,
-        (_, inner) => {
-          fixCount++
-          return `**${inner}**`
-        }
-      )
+      lines[j] = lines[j].replace(/\\\*\\\*(.+?)\\\*\\\*/g, (_, inner) => {
+        fixCount++
+        return `**${inner}**`
+      })
 
       // Fix escaped italic: \*text\* → *text*
       // Runs after bold fix, so remaining \* pairs are italic
-      lines[j] = lines[j].replace(
-        /\\\*(.+?)\\\*/g,
-        (_, inner) => {
-          fixCount++
-          return `*${inner}*`
-        }
-      )
+      lines[j] = lines[j].replace(/\\\*(.+?)\\\*/g, (_, inner) => {
+        fixCount++
+        return `*${inner}*`
+      })
     }
     parts[i] = lines.join("\n")
   }
@@ -475,9 +467,7 @@ function warnCodeFenceContentDrift(
 
   for (let i = 0; i < engFences.length; i++) {
     if (engFences[i].body !== transFences[i].body) {
-      const preview = transFences[i].body
-        .substring(0, 60)
-        .replace(/\n/g, "\\n")
+      const preview = transFences[i].body.substring(0, 60).replace(/\n/g, "\\n")
       warnings.push(
         `Code fence #${i + 1} content differs from English: "${preview}..."`
       )
@@ -487,6 +477,100 @@ function warnCodeFenceContentDrift(
   return warnings
 }
 
+/**
+ * Detects catastrophic code fence drift where Crowdin has structurally
+ * mangled the interleaving of prose and code blocks. Signals include:
+ * - Translated fence bodies contain natural language instead of code
+ * - Programming keywords appear outside code fences
+ * - Heading anchor IDs ({#id}) are detached from heading lines
+ */
+function warnCatastrophicCodeFenceDrift(
+  translatedContent: string,
+  englishContent: string
+): string[] {
+  const warnings: string[] = []
+
+  const extractCodeFences = (
+    content: string
+  ): Array<{ lang: string; body: string; lineCount: number }> => {
+    const fences: Array<{ lang: string; body: string; lineCount: number }> = []
+    const re = /```(\w*)\n([\s\S]*?)```/g
+    let match
+    while ((match = re.exec(content))) {
+      const body = match[2].trim()
+      fences.push({
+        lang: match[1] || "",
+        body,
+        lineCount: body.split("\n").length,
+      })
+    }
+    return fences
+  }
+
+  // Code keywords that should only appear inside fences
+  const codeKeywords =
+    /^(?:def |class |if |elif |else:|while |for |return |require |revert |import |from |call |log )/m
+
+  const engFences = extractCodeFences(englishContent)
+  const transFences = extractCodeFences(translatedContent)
+
+  // Check 1: Fence bodies that look like prose instead of code
+  if (engFences.length === transFences.length) {
+    let proseInFenceCount = 0
+    for (let i = 0; i < engFences.length; i++) {
+      const engHasCode = codeKeywords.test(engFences[i].body)
+      const transHasCode = codeKeywords.test(transFences[i].body)
+      const transIsShort = transFences[i].lineCount <= 2
+      const engIsLong = engFences[i].lineCount >= 3
+
+      if (engHasCode && !transHasCode && transIsShort && engIsLong) {
+        proseInFenceCount++
+      }
+    }
+
+    if (proseInFenceCount >= 1) {
+      warnings.push(
+        `CATASTROPHIC code fence drift: ${proseInFenceCount} fences contain prose instead of code. ` +
+          `File needs structural reconstruction from English source.`
+      )
+    }
+  }
+
+  // Check 2: Code keywords outside fences in translated content
+  const codeBlockPattern = /(```[\s\S]*?```|~~~[\s\S]*?~~~)/g
+  const parts = translatedContent.split(codeBlockPattern)
+  let codeOutsideFenceCount = 0
+
+  for (let i = 0; i < parts.length; i++) {
+    if (i % 2 === 1) continue // Skip code blocks
+    const globalKeywords =
+      /^(?:def |class |if |elif |else:|while |for |return |require |revert |import |from |call |log )/gm
+    const matches = parts[i].match(globalKeywords)
+    if (matches) codeOutsideFenceCount += matches.length
+  }
+
+  if (codeOutsideFenceCount >= 3) {
+    warnings.push(
+      `CATASTROPHIC code fence drift: ${codeOutsideFenceCount} code keyword occurrences found outside fences. ` +
+        `Code blocks may have been inverted with prose.`
+    )
+  }
+
+  // Check 3: Detached heading anchor IDs
+  const anchorIdPattern = /\{#[\w-]+\}/g
+  const lines = translatedContent.split("\n")
+  for (const line of lines) {
+    const anchors = line.match(anchorIdPattern)
+    if (anchors && !line.match(/^#{1,6}\s/)) {
+      warnings.push(
+        `Detached heading anchor: "${anchors[0]}" not on a heading line: "${line.substring(0, 80)}"`
+      )
+    }
+  }
+
+  return warnings
+}
+
 /**
  * Fix broken markdown links where there's a space between ] and (.
  * Pattern: ] (https://... → ](https://...
@@ -1467,6 +1551,12 @@ function escapeMdxAngleBrackets(content: string): {
       fixCount++
       return "\\</>"
     })
+
+    // Escape < before word containing [ (e.g., <Stockage[4]) — never valid MDX
+    parts[i] = parts[i].replace(/(?<!\\)<([a-zA-Z]+\[)/g, (_, after) => {
+      fixCount++
+      return `\\<${after}`
+    })
   }
 
   return { content: parts.join(""), fixCount }
@@ -1528,6 +1618,30 @@ function restoreDroppedBackslashEscapes(
  * Removes excess closers from right-to-left (last occurrence first) so that
  * correctly-paired closers near their openers are preserved.
  */
+function fixBackslashBeforeClosingTag(content: string): {
+  content: string
+  fixCount: number
+} {
+  let fixCount = 0
+
+  // Split content to preserve code blocks (fenced and inline)
+  const codeBlockPattern = /(```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`]+`)/g
+  const parts = content.split(codeBlockPattern)
+
+  for (let i = 0; i < parts.length; i++) {
+    if (i % 2 === 1) continue // Skip code blocks
+
+    // Match backslash immediately before closing HTML tags like \</strong>
+    // Requires at least one letter in tag name — leaves \</> (JSX fragment) intact
+    parts[i] = parts[i].replace(/\\(<\/[a-zA-Z]+>)/g, (_, tag) => {
+      fixCount++
+      return tag
+    })
+  }
+
+  return { content: parts.join(""), fixCount }
+}
+
 function removeOrphanedClosingTags(content: string): {
   content: string
   fixCount: number
@@ -1717,6 +1831,10 @@ function processMarkdownFile(
     () => escapeMdxAngleBrackets(content),
     (n) => `Escaped ${n} raw angle brackets in prose`
   )
+  applyFix(
+    () => fixBackslashBeforeClosingTag(content),
+    (n) => `Fixed ${n} backslash-before-closing-tag artifacts`
+  )
   applyFix(
     () => removeOrphanedClosingTags(content),
     (n) => `Removed ${n} orphaned closing HTML tags`
@@ -1793,6 +1911,12 @@ function processMarkdownFile(
     const codeFenceWarnings = warnCodeFenceContentDrift(content, englishMd)
     issues.push(...codeFenceWarnings)
 
+    const catastrophicDriftWarnings = warnCatastrophicCodeFenceDrift(
+      content,
+      englishMd
+    )
+    issues.push(...catastrophicDriftWarnings)
+
     // Detect cross-script contamination
     if (locale) {
       const scriptWarnings = detectCrossScriptContamination(content, locale)
@@ -2128,7 +2252,9 @@ export const _testOnly = {
   fixCollapsedComponentLineBreaks,
   // Warnings
   warnPunctuationOnlyHeadings,
+  fixBackslashBeforeClosingTag,
   warnCodeFenceContentDrift,
+  warnCatastrophicCodeFenceDrift,
   detectCrossScriptContamination,
   // Utilities
   toAsciiId,
diff --git a/tests/unit/sanitizer/standalone-fixes.spec.ts b/tests/unit/sanitizer/standalone-fixes.spec.ts
index ef4cfd1a538..3ef37fd876e 100644
--- a/tests/unit/sanitizer/standalone-fixes.spec.ts
+++ b/tests/unit/sanitizer/standalone-fixes.spec.ts
@@ -24,6 +24,7 @@ const {
   extractHrefs,
   isInternalHref,
   splitIntoBlocks,
+  fixBackslashBeforeClosingTag,
 } = _testOnly
 
 test.describe("Standalone Fixes", () => {
@@ -406,4 +407,106 @@ test.describe("Standalone Fixes", () => {
       expect(blocks[2]).toBe("Block three")
     })
   })
+
+  test.describe("fixBackslashBeforeClosingTag", () => {
+    test("fixes backslash before </strong>", () => {
+      const input =
+        '<p className="mt-0"><strong>Bon à savoir\\</strong></p>'
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe(
+        '<p className="mt-0"><strong>Bon à savoir</strong></p>'
+      )
+      expect(fixCount).toBe(1)
+    })
+
+    test("fixes backslash before </em>", () => {
+      const input = "<em>some text\\</em>"
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe("<em>some text</em>")
+      expect(fixCount).toBe(1)
+    })
+
+    test("fixes backslash before </a>", () => {
+      const input = '<a href="/test">link text\\</a>'
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe('<a href="/test">link text</a>')
+      expect(fixCount).toBe(1)
+    })
+
+    test("fixes multiple occurrences", () => {
+      const input =
+        "<strong>text1\\</strong> and <strong>text2\\</strong>"
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe(
+        "<strong>text1</strong> and <strong>text2</strong>"
+      )
+      expect(fixCount).toBe(2)
+    })
+
+    test("leaves correct closing tags unchanged", () => {
+      const input = "<strong>Bon à savoir</strong>"
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe(input)
+      expect(fixCount).toBe(0)
+    })
+
+    test("skips code blocks", () => {
+      const input =
+        "```\n<strong>text\\</strong>\n```"
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe(input)
+      expect(fixCount).toBe(0)
+    })
+
+    test("does NOT strip backslash from JSX fragment \\</>", () => {
+      const input =
+        "nous utilisons un composant vide (`<> ...` \\</>`) pour en faire un seul composant."
+      const { content, fixCount } = fixBackslashBeforeClosingTag(input)
+      expect(content).toBe(input)
+      expect(fixCount).toBe(0)
+    })
+  })
+
+  test.describe("escapeMdxAngleBrackets — extended patterns", () => {
+    test("escapes bare < before word containing [", () => {
+      const input =
+        "| calldataload(4)<Stockage[4] calldataload(4) |"
+      const { content, fixCount } = escapeMdxAngleBrackets(input)
+      expect(content).toBe(
+        "| calldataload(4)\\<Stockage[4] calldataload(4) |"
+      )
+      expect(fixCount).toBe(1)
+    })
+
+    test("escapes multiple bare < before word[ patterns", () => {
+      const input =
+        "| <Stockage[4] foo | bar <Storage[2] baz |"
+      const { content, fixCount } = escapeMdxAngleBrackets(input)
+      expect(content).toBe(
+        "| \\<Stockage[4] foo | bar \\<Storage[2] baz |"
+      )
+      expect(fixCount).toBe(2)
+    })
+
+    test("leaves already-escaped \\<Word[ unchanged", () => {
+      const input = "| calldataload(4)\\<Storage[4] |"
+      const { content, fixCount } = escapeMdxAngleBrackets(input)
+      expect(content).toBe(input)
+      expect(fixCount).toBe(0)
+    })
+
+    test("skips <Word[ inside code blocks", () => {
+      const input = "```\n<Storage[4]\n```"
+      const { content, fixCount } = escapeMdxAngleBrackets(input)
+      expect(content).toBe(input)
+      expect(fixCount).toBe(0)
+    })
+
+    test("does not escape valid MDX component tags", () => {
+      const input = "<Card title=\"test\" />"
+      const { content, fixCount } = escapeMdxAngleBrackets(input)
+      expect(content).toBe(input)
+      expect(fixCount).toBe(0)
+    })
+  })
 })
diff --git a/tests/unit/sanitizer/warnings.spec.ts b/tests/unit/sanitizer/warnings.spec.ts
index 1f4419faa20..2d27bab768c 100644
--- a/tests/unit/sanitizer/warnings.spec.ts
+++ b/tests/unit/sanitizer/warnings.spec.ts
@@ -10,6 +10,7 @@ import { _testOnly } from "@/scripts/i18n/post_import_sanitize"
 const {
   warnPunctuationOnlyHeadings,
   warnCodeFenceContentDrift,
+  warnCatastrophicCodeFenceDrift,
   fixTranslatedHrefs,
   detectCrossScriptContamination,
 } = _testOnly
@@ -61,6 +62,113 @@ test.describe("Warning Functions", () => {
     })
   })
 
+  test.describe("warnCatastrophicCodeFenceDrift", () => {
+    test("detects prose inside fences that should contain code", () => {
+      const english = [
+        "Some prose here.",
+        "",
+        "```python",
+        "def foo(x, y):",
+        "  if x > y:",
+        "    return x",
+        "  return y",
+        "```",
+        "",
+        "More prose.",
+      ].join("\n")
+      const translated = [
+        "Du texte ici.",
+        "",
+        "```python",
+        "Voici une explication de la fonction.",
+        "```",
+        "",
+        "def foo(x, y):",
+        "  if x > y:",
+        "    return x",
+        "  return y",
+        "",
+        "Plus de texte.",
+      ].join("\n")
+      const warnings = warnCatastrophicCodeFenceDrift(translated, english)
+      expect(warnings.length).toBeGreaterThan(0)
+      expect(warnings[0]).toContain("CATASTROPHIC")
+    })
+
+    test("detects code keywords outside fences", () => {
+      const english = [
+        "```python",
+        "def unknown2e7ba6ef(uint256 _param1):",
+        "  require _param2 == addr(_param2)",
+        "  if currentWindow <= _param1:",
+        "    revert with 0, 'error'",
+        "```",
+      ].join("\n")
+      const translated = [
+        "```python",
+        "Voici ce que le decompilateur nous donne.",
+        "```",
+        "",
+        "def unknown2e7ba6ef(uint256 _param1):",
+        "  require _param2 == addr(_param2)",
+        "  if currentWindow <= _param1:",
+        "    revert with 0, 'error'",
+      ].join("\n")
+      const warnings = warnCatastrophicCodeFenceDrift(translated, english)
+      expect(warnings.length).toBeGreaterThan(0)
+      const hasCodeOutsideFence = warnings.some(
+        (w) => w.includes("code keyword") || w.includes("CATASTROPHIC")
+      )
+      expect(hasCodeOutsideFence).toBe(true)
+    })
+
+    test("no warning when fences match correctly", () => {
+      const content = [
+        "Some prose.",
+        "",
+        "```python",
+        "def foo():",
+        "  return 1",
+        "```",
+        "",
+        "More prose.",
+      ].join("\n")
+      const warnings = warnCatastrophicCodeFenceDrift(content, content)
+      expect(warnings).toHaveLength(0)
+    })
+
+    test("detects detached heading anchor IDs", () => {
+      const english = [
+        "### claim {#claim}",
+        "",
+        "Some text about claim.",
+      ].join("\n")
+      const translated = [
+        "### Du texte ici.",
+        "",
+        "claim {#claim} Le code est complexe.",
+      ].join("\n")
+      const warnings = warnCatastrophicCodeFenceDrift(translated, english)
+      const hasDetachedAnchor = warnings.some((w) =>
+        w.includes("anchor")
+      )
+      expect(hasDetachedAnchor).toBe(true)
+    })
+
+    test("no false positive on anchor IDs properly on heading lines", () => {
+      const content = [
+        "### La revendication {#claim}",
+        "",
+        "Some text about claim.",
+      ].join("\n")
+      const warnings = warnCatastrophicCodeFenceDrift(content, content)
+      const anchorWarnings = warnings.filter((w) =>
+        w.includes("anchor")
+      )
+      expect(anchorWarnings).toHaveLength(0)
+    })
+  })
+
   test.describe("fixTranslatedHrefs (warn-only)", () => {
     test("NEVER modifies content", () => {
       const english =