translation lesson 2

fr/2/10-interactingcontracts.md

@@ -1,5 +1,5 @@
 ---
-title: What Do Zombies Eat?
+title: Que mangent les zombies ?
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -10,7 +10,7 @@ material:
 
         import "./zombiefactory.sol";
 
-        // Create KittyInterface here
+        // créer l'interface KittyInterface ici
 
         contract ZombieFeeding is ZombieFactory {
 
@@ -95,23 +95,23 @@ material:
       }
 ---
 
-It's time to feed our zombies! And what do zombies like to eat most?
+Il est temps de nourrir nos zombies ! Et qu'est ce que les zombies aiment manger par dessus tout ?
 
-Well it just so happens that CryptoZombies love to eat...
+Eh bien, il se trouve que les CryptoZombies adorent manger des...
 
 **CryptoKitties!** 😱😱😱
 
-(Yes, I'm serious 😆 )
+(Oui, Je suis sérieux 😆 )
 
-In order to do this we'll need to read the kittyDna from the CryptoKitties smart contract. We can do that because the CryptoKitties data is stored openly on the blockchain. Isn't the blockchain cool?!
+Pour pouvoir faire ça, nous allons avoir besoin de lire l'ADN des chatons (kittyDna) depuis le smart contract CryptoKitties. Nous pouvons le faire car les données de CryptoKitties sont stockées ouvertement sur la blockchain. C'est pas génial la blockchain ?!
 
-Don't worry — our game isn't actually going to hurt anyone's CryptoKitty. We're only *reading* the CryptoKitties data, we're not able to actually delete it 😉
+Ne vous en faites pas - notre jeu ne va faire de mal à aucun CryptoKitty. Nous allons seulement *lire* les données de CryptoKitties, nous ne sommes pas capables de les supprimer 😉
 
-## Interacting with other contracts
+## Interagir avec d'autres contrats
 
-For our contract to talk to another contract on the blockchain that we don't own, first we need to define an **_interface_**.
+Pour que notre contrat puisse parler avec un autre contrat que nous ne possédons pas sur la blockchain, nous allons avoir besoin de définir une **_interface_**.
 
-Let's look at a simple example. Say there was a contract on the blockchain that looked like this:
+Prenons un exemple simple. Imaginons un contrat comme celui-ci sur la blockchain :
 
 ```
 contract LuckyNumber {
@@ -126,35 +126,33 @@ contract LuckyNumber {
   }
 }
 ```
+Cela serait un simple contrat où n'importe qui pourrait stocker leur nombre porte-bonheur, et il serait associé à leur adresse Ethereum. Ensuite n'importe qui pourrait regarder leur nombre porte-bonheur en utilisant leur adresse.
 
-This would be a simple contract where anyone could store their lucky number, and it will be associated with their Ethereum address. Then anyone else could look up that person's lucky number using their address.
+Maintenant, imaginons que nous avons un contrat externe qui voudrait lire les données de ce contrat en utilisant la fonction `getNum`.
 
-Now let's say we had an external contract that wanted to read the data in this contract using the `getNum` function.
-
-First we'd have to define an **_interface_** of the `LuckyNumber` contract:
+Premièrement, nous devrions définir une **_interface_** du contract `LuckyNumber` :
 
 ```
 contract NumberInterface {
   function getNum(address _myAddress) public view returns (uint);
 }
 ```
 
-Notice that this looks like defining a contract, with a few differences. For one, we're only declaring the functions we want to interact with — in this case `getNum` — and we don't mention any of the other functions or state variables.
-
-Secondly, we're not defining the function bodies. Instead of curly braces (`{` and `}`), we're simply ending the function declaration with a semi-colon (`;`).
+Vous remarquerez que cela ressemble à la définition d'un contrat, avec quelques différences. Premièrement nous déclarons seulement les fonctions avec lesquelles nous souhaitons interagir - dans ce cas, `getNum` - et nous ne mentionnons aucune autre fonction ou variable.
 
-So it kind of looks like a contract skeleton. This is how the compiler knows it's an interface.
+Deuxièmement, nous ne définissons par de corps de fonction, à la place des `{` et `}`, nous finissons simplement la déclaration de la fonction avec un `;`.
 
-By including this interface in our dapp's code our contract knows what the other contract's functions look like, how to call them, and what sort of response to expect.
+C'est un peu comme un squelette d'un contrat. C'est comme ça que le compilateur sait que c'est une interface.
 
-We'll get into actually calling the other contract's functions in the next lesson, but for now let's declare our interface for the CryptoKitties contract.
+En incluant cette interface dans le code de notre dapp, notre contrat sait à quoi ressemble les fonctions de l'autre contrat, comment les appeler, et quelle type réponse en attendre.
 
-# Put it to the test
+Nous verrons comment appeler les fonctions de l'autre contrat dans la prochaine leçon, pour l'instant nous allons déclarer notre interface pour le contrat CryptoKitties.
 
-We've looked up the CryptoKitties source code for you, and found a function called `getKitty` that returns all the kitty's data, including its "genes" (which is what our zombie game needs to form a new zombie!).
+# A votre tour
 
-The function looks like this:
+Nous avons regardé le code source de CryptoKitties pour vous, et avons trouvé une fonction appelée `getKitty` qui retourne tous les données des chatons, "gènes" inclus (c'est ce dont nous avons besoin pour créer un nouveau zombie !).
 
+La fonction ressemble à :
 ```
 function getKitty(uint256 _id) external view returns (
     bool isGestating,
@@ -170,7 +168,7 @@ function getKitty(uint256 _id) external view returns (
 ) {
     Kitty storage kit = kitties[_id];
 
-    // if this variable is 0 then it's not gestating
+    // si cette variable est 0 alors il n'est pas en gestation
     isGestating = (kit.siringWithId != 0);
     isReady = (kit.cooldownEndBlock <= block.number);
     cooldownIndex = uint256(kit.cooldownIndex);
@@ -184,10 +182,10 @@ function getKitty(uint256 _id) external view returns (
 }
 ```
 
-The function looks a bit different than we're used to. You can see it returns... a bunch of different values. If you're coming from a programming language like Javascript, this is different — in Solidity you can return more than one value from a function.
+La fonction est un peu différente que ce dont nous avons l'habitude. Vous pouvez voir qu'elle retourne... un tas de différentes valeurs. Si vous venez d'un langage de prgramation comme Javascript, c'est différent - en Solidity une fonction peut retourner plus d'une valeur.
 
-Now that we know what this function looks like, we can use it to create an interface:
+Maintenant que nous savons à quoi ressemble notre fonction, nous pouvons l'utiliser pour créer une interface :
 
-1. Define an interface called `KittyInterface`. Remember, this looks just like creating a new contract — we use the `contract` keyword.
+1. Définissez une interface appelée `KittyInterface`. C'est comme déclarer un nouveau contrat - nous utilisons le mot clé `contract`.
 
-2. Inside the interface, define the function `getKitty` (which should be a copy/paste of the function above, but with a semi-colon after the `returns` statement, instead of everything inside the curly braces.
+2. Dans l'interface, définissez une fonction `getKitty` (qui devrait être un copier/coller de la fonction ci-dessus, mais avec un `;` après la déclaration `returns` au lieu de tout ce qu'il y a entre les {}).

fr/2/11-interactingcontracts2.md

@@ -1,5 +1,5 @@
 ---
-title: Using an Interface
+title: Utiliser une interface
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -28,7 +28,7 @@ material:
         contract ZombieFeeding is ZombieFactory {
 
           address ckAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
-          // Initialize kittyContract here using `ckAddress` from above
+          // initialisez kittyContract ici en utilisant `ckAddress` ci-dessus
 
           function feedAndMultiply(uint _zombieId, uint _targetDna) public {
             require(msg.sender == zombieToOwner[_zombieId]);
@@ -114,35 +114,34 @@ material:
       }
 ---
 
-Continuing our previous example with `NumberInterface`, once we've defined the interface as:
+Continuons notre exemple précédent avec `NumberInterface`, une fois que nous avons défini l'interface :
 
 ```
 contract NumberInterface {
   function getNum(address _myAddress) public view returns (uint);
 }
 ```
-
-We can use it in a contract as follows:
+Nous pouvons l'utiliser dans un contrat comme ceci :
 
 ```
 contract MyContract {
   address NumberInterfaceAddress = 0xab38...
-  // ^ The address of the FavoriteNumber contract on Ethereum
+  // ^ L'adresse du contrat FavoriteNumber sur Ethereum
   NumberInterface numberContract = NumberInterface(NumberInterfaceAddress)
-  // Now `numberContract` is pointing to the other contract
+  // Mainteant `numberContract` pointe vers l'autre contrat
 
   function someFunction() public {
-    // Now we can call `getNum` from that contract:
+    //Nous pouvons maintenant appeler `getNum` à partir de ce contrat :
     uint num = numberContract.getNum(msg.sender);
-    // ...and do something with `num` here
+    // ...et faire quelque chose avec ce `num`
   }
 }
 ```
 
-In this way, your contract can interact with any other contract on the Ethereum blockchain, as long they expose those functions as `public` or `external`.
+De cette manière, votre contrat peut interagir avec n'importe quel autre contrat sur la blockchain Ethereum, tant qu'ils exposent leurs fonctions comme `public` ou `external`.
 
-# Put it to the test
+# A votre tour
 
-Let's set up our contract to read from the CryptoKitties smart contract!
+Nous allons configurer notre contrat pour qu'il puisse lire le smart contract CryptoKitties !
 
-1. I've saved the address of the CryptoKitties contract in the code for you, under a variable named `ckAddress`. In the next line, create a `KittyInterface` named `kittyContract`, and initialize it with `ckAddress` — just like we did with `numberContract` above.
+1. J'ai sauvegardé l´adresse du contrat CryptoKitties dans le code pour vous, sous une variable appelée `ckAddress`. A la prochaine ligne, créer une `KittyInterface` nommée `kittyContract`, et initialisez la avec `ckAddress` - de la même manière que nous avons fait avec `numberContract` au dessus.

fr/2/12-multiplereturns.md

@@ -1,5 +1,5 @@
 ---
-title: Handling Multiple Return Values
+title: Gérer plusieurs valeurs de retour
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -38,7 +38,7 @@ material:
             _createZombie("NoName", newDna);
           }
 
-          // define function here
+          // definissez la fonction ici
 
         }
       "zombiefactory.sol": |
@@ -122,7 +122,7 @@ material:
       }
 ---
 
-This `getKitty` function is the first example we've seen that returns multiple values. Let's look at how to handle them:
+Cette fonction `getKitty` est le premier exemple que nous avons vu qui retourne plusieurs valeurs. Nous allons voir comment gérer cela :
 
 ```
 function multipleReturns() internal returns(uint a, uint b, uint c) {
@@ -133,30 +133,30 @@ function processMultipleReturns() external {
   uint a;
   uint b;
   uint c;
-  // This is how you do multiple assignment:
+  // C'est comme ca que vous faites une affectation multiple :
   (a, b, c) = multipleReturns();
 }
 
-// Or if we only cared about one of the values:
+// Ou si nous voulons seulement une des valeurs ci dessus :
 function getLastReturnValue() external {
   uint c;
-  // We can just leave the other fields blank:
+  // Nous pouvons laisser les autres champs vides :
   (,,c) = multipleReturns();
 }
 ```
 
-# Put it to the test
+# A votre tour
 
-Time to interact with the CryptoKitties contract!
+Il est temps d'interagir avec le contrat CryptoKitties !
 
-Let's make a function that gets the kitty genes from the contract:
+Nous allons créer une fonction qui récupère les gènes d'un chaton à partir du contrat :
 
-1. Make a function called `feedOnKitty`. It will take 2 `uint` parameters, `_zombieId` and `_kittyId`, and should be a `public` function.
+1. Créez une fonction appelée `feedOnKitty`. Elle prendra 2 paramètres `uint`, `_zombieId` et `_kittyId` et elle devra être `public`.
 
-2. The function should first declare a `uint` named `kittyDna`.
+2. La fonction devra d'abord déclarer un `uint` nommé `kittyDna`.
 
-  > Note: In our `KittyInterface`, `genes` is a `uint256` — but if you remember back to lesson 1, `uint` is an alias for `uint256` — they're the same thing.
+  > Remarque : Dans notre `KittyInterface`, `genes` est un `uint256` - mais si vous vous rappelez de la leçon 1, `uint` est un alias pour `uint256` - c'est la même chose.
 
-3. The function should then call the `kittyContract.getKitty` function with `_kittyId` and store `genes` in `kittyDna`. Remember — `getKitty` returns a ton of variables. (10 to be exact — I'm nice, I counted them for you!). But all we care about is the last one, `genes`. Count your commas carefully!
+3. La fonction devra ensuite appeler la fonction `kittyContract.getKitty` avec `_kittyId` et stocker les `genes` dans `kittyDna`. N'oubliez pas - `getKitty` retourne une tonne de variables. (10 pour être précis - je suis gentil, je les ai comptées pour vous !). Mais nous voulons récupérer seulement la dernière, `genes`. Comptez vos virgules soigneusement !
 
-4. Finally, the function should call `feedAndMultiply`, and pass it both `_zombieId` and `kittyDna`.
+4. Enfin, la fonction devra appeler `feedAndMultiply` avec `_zombieId` et `kittyDna`.

fr/2/13-kittygenes.md

@@ -1,5 +1,5 @@
 ---
-title: "Bonus: Kitty Genes"
+title: "Bonus : gènes de chatton"
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -30,20 +30,20 @@ material:
           address ckAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
           KittyInterface kittyContract = KittyInterface(ckAddress);
 
-          // Modify function definition here:
+          // modifiez la définition de la fonction ici :
           function feedAndMultiply(uint _zombieId, uint _targetDna) public {
             require(msg.sender == zombieToOwner[_zombieId]);
             Zombie storage myZombie = zombies[_zombieId];
             _targetDna = _targetDna % dnaModulus;
             uint newDna = (myZombie.dna + _targetDna) / 2;
-            // Add an if statement here
+            // ajoutez une déclaration `if` ici
             _createZombie("NoName", newDna);
           }
 
           function feedOnKitty(uint _zombieId, uint _kittyId) public {
             uint kittyDna;
             (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId);
-            // And modify function call here:
+            // et modifiez l'appel de la fonction ici :
             feedAndMultiply(_zombieId, kittyDna);
           }
 
@@ -133,40 +133,40 @@ material:
       }
 ---
 
-Our function logic is now complete... but let's add in one bonus feature.
+La logique de notre fonction est terminée... mais nous allons ajouter une fonctionnalité bonus.
 
-Let's make it so zombies made from kitties have some unique feature that shows they're cat-zombies.
+Nous allons faire que les zombies créés à partir de chattons aient une caractéristique unique, qui montrera qu'ils sont des zombie-chats.
 
-To do this, we can add some special kitty code in the zombie's DNA.
+Pour cela, nous allons ajouter un code spécial chatton à l'ADN du zombie.
 
-If you recall from lesson 1, we're currently only using the first 12 digits of our 16 digit DNA to determine the zombie's appearance. So let's use the last 2 unused digits to handle "special" characteristics.
+Si vous vous rappelez de la leçon 1, nous n'utilisons seulement les 12 premiers chiffres de notre ADN à 16 chiffres pour déterminer l'apparence du zombie. Nous allons utiliser les 2 derniers chiffres inutilisés pour gérer les caractéristiques "spéciales".
 
-We'll say that cat-zombies have `99` as their last two digits of DNA (since cats have 9 lives). So in our code, we'll say `if` a zombie comes from a cat, then set the last two digits of DNA to `99`.
+Les deux derniers chiffres de l'ADN d'un zombie-chat sont `99` (car les chats ont 9 vies). Dans notre code, nous allons dire **si** un zombie provient d'un chat, alors ces deux derniers chiffres d'ADN seront `99`.
 
-## If statements
+## déclaration `if` (si)
 
-If statements in Solidity look just like javascript:
+Les déclaration `if` en Solidity sont les mêmes qu'en Javascript :
 
 ```
 function eatBLT(string sandwich) public {
-  // Remember with strings, we have to compare their keccak256 hashes
-  // to check equality
+  // N'oubliez pas, avec les `string`, nous devons comparer
+  // leurs hachages keccak256 pour vérifier l'égalité
   if (keccak256(sandwich) == keccak256("BLT")) {
     eat();
   }
 }
 ```
 
-# Put it to the test
+# A votre tour
 
-Let's implement cat genes in our zombie code.
+Nous allons implémenter les gènes de chat dans notre code zombie.
 
-1. First, let's change the function definition for `feedAndMultiply` so it takes a 3rd argument: a `string` named `_species`
+1. Premièrement, changez la définition de fonction de `feedAndMultiply` qu'elle prenne un 3ème paramètres : un `string` nommé `_species`
 
-2. Next, after we calculate the new zombie's DNA, let's add an `if` statement comparing the `keccak256` hashes of `_species` and the string `"kitty"`
+2. Ensuite, après avoir calculé le nouvel ADN zombie, rajoutez un déclaration `if` pour comparer le hachage `keccak256` de `_species` et la chaîne de caractère `"kitty"`.
 
-3. Inside the `if` statement, we want to replace the last 2 digits of DNA with `99`. One way to do this is using the logic: `newDna = newDna - newDna % 100 + 99;`.
+3. Dans cette déclaration `if`, nous voulons remplacer les 2 derniers chiffres de l'ADN par `99`. Une façon de le faire et d'utiliser cette logique : `newDna = newDna - newDna % 100 + 99;`.
 
-  > Explanation: Assume `newDna` is `334455`. Then `newDna % 100` is `55`, so `newDna - newDna % 100` is `334400`. Finally add `99` to get `334499`.
+  > Explication : Si `newDna` est `334455`. Alors `newDna % 100` est `55`, donc `newDna - newDna % 100` est `334400`. Enfin on ajoute `99` pour avoir `334499`.
 
-4. Lastly, we need to change the function call inside `feedOnKitty`. When it calls `feedAndMultiply`, add the parameter `"kitty"` to the end.
+4. Enfin, nous avons besoin de changer l'appel de la fonction à l'intérieur de `feedOnKitty`. Quand elle appelle `feedAndMultiply`, ajoutez l'argument `"kitty"` à la fin.