Transfer
+``` + +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 `uGreeter
+Greeter
+ { + !readResults.isError && !readResults.isLoading && ++``` + +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 + +``` + +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 + +``` + +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 +
+
+```
+
+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
+
+
+}
+```
+
+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..1b3754c8925 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",
+ "solidité",
+ "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.
-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 :
-
+
-Cliquez ensuite sur le bouton compiler :
+Cliquez ensuite sur le bouton de compilation :
-
+
-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 » :
-
+
-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.
-
+
-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.
-
+
-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 :
-
+
-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.
-
+
-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 -> {attrs.name}
+
+ {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
+
+ { funs.length > 0 &&
+ <>
+ Fonctions :
+ -
+```
+
+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
+ (
- {f} ) + )} +``` + +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 +
Bonjour ${loginResponse.extract.nameID}
+ + + `) + 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(` + + + +``` + +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 + + + + `) + } +) + +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(` + + + + + + `) +}) +``` + +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 + + +Page de connexion
+ + + + +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(` + + + + + + + + `) +}) +``` + +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 `Veuillez signer
+ ++ + + +` +} +``` + +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 + + + +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..6eb11eeb0c2 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 --- - + -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 !_ - + -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. - + -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. - + -## 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..07d00faf0b3 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: [ "solidité", "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**. - + -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. - + _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  -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 :  @@ -446,30 +365,24 @@ L'adresse `From` devrait correspondre à l'adresse de votre compte MetaMask et l  -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**.  -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 = "
Current Message:
+Message actuel :
{message}
-New Message:
+Nouveau message :
setNewMessage(e.target.value)}
value={newMessage}
/>
- {status}
-- ℹ️ 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. ), } @@ -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) => { ✅{" "} - View the status of your transaction on Etherscan! + Consultez l'état de votre transaction sur Etherscan !
- ℹ️ 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. ), } @@ -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..c58bfca6db6 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" + [ + "solidité", + "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 » + - +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 ». + - +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." - + -## É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 = 1018 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 = 1018 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à
.env ! Veillez à ne jamais partager ou exposer votre fichier .env avec quiconque car vous compromettez vos secrets en le faisant. Si vous utilisez le contrôle de version, ajoutez votre .env à un fichier gitignore.
+Ne commitez pas le fichier .env ! Veillez à ne jamais partager ou exposer votre fichier .env avec quiconque, car vous compromettez vos secrets en le faisant. Si vous utilisez un système de contrôle de version, ajoutez votre fichier .env à un fichier gitignore.