diff --git a/README.fr.md b/README.fr.md
new file mode 100644
index 0000000..f34c8b0
--- /dev/null
+++ b/README.fr.md
@@ -0,0 +1,51 @@
+# morph-examples
+[Read in English](./README.md)
+Ceci est le repo d'une série d'exemples de code qui aide les développeurs à s'intégrer à l'écosystème Morph.
+
+<!-- 
+[![Twitter Follow]()](https://twitter.com/Morphl2)
+[![Discord](https://img.shields.io/discord/984015101017346058?color=%235865F2&label=Discord&logo=discord&logoColor=%23fff)](https://discord.gg/)
+-->
+
+# Morph Examples
+
+Les exemples de code dans ce Repo vont de la mise en ligne de contrats simples sur Morph à la création d'applications décentralisées (dApps) complètes utilisant Morph comme solution de couche 2 (L2).
+D'autres exemples seront ajoutés à ce dépôt, et nous sommes ouverts aux suggestions d'exemples de code que vous aimeriez voir à l'avenir.
+
+## Getting Started
+
+### [contract-deploy-demo](https://github.com/morph-l2/morph-examples/tree/main/contract-deployment-demos)
+* [foundry-deploy](https://github.com/varun-doshi/morph-examples/tree/main/contract-deployment-demos/foundry-demo)
+* [hardhat-deploy](https://github.com/varun-doshi/morph-examples/tree/main/contract-deployment-demos/hardhat-demo)
+
+Ce répertoire contient des projets qui démontrent comment utiliser **Hardhat** ou **Foundry** pour déployer un contrat sur le réseau rollup de Morph.
+
+Ce projet contient un contrat simple qui verrouillera une certaine quantité d'Ether dans le contrat déployé pendant une durée déterminée.
+
+
+### [frontend-demo](https://github.com/varun-doshi/morph-examples/tree/main/frontend_examples/nextjs_wagmi_template)
+Ce répertoire contient une configuration Frontend simple vous permettant de connecter et d'interagir avec vos contrats intelligents directement depuis l'interface utilisateur.
+<!--
+
+## Miscellaneous
+
+### [create2-demo](https://github.com/morphl2/morph-examples/tree/main/contract-deploy-demo)
+
+This project demonstrates how to use the `create2` opcode and tests it across various networks.
+
+### [gas-estimation-demo](https://github.com/morphl2/morph-examples/tree/main/contract-deploy-demo)
+
+This project demonstrates how to use estimate gas on Morph
+
+-->
+
+## Chain Configuration
+
+```
+network:morphTestnet
+chainId:2810
+apiURL: 'https://explorer-api-holesky.morphl2.io/api?'
+browserURL: 'https://explorer-holesky.morphl2.io/'
+rpcURL: 'https://rpc-quicknode-holesky.morphl2.io'
+currencySymbol: ETH
+```
diff --git a/README.md b/README.md
index 01de207..24f38e5 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,6 @@
 # morph-examples
+[Lire en français](./README.fr.md)
+
 This is the repo of a series of code examples that helps developers onboard onto the Morph Ecosystem
 
 <!-- 
diff --git a/contract-deployment-demo/foundry-demo/lib/forge-std/README.fr.md b/contract-deployment-demo/foundry-demo/lib/forge-std/README.fr.md
new file mode 100644
index 0000000..25baa7d
--- /dev/null
+++ b/contract-deployment-demo/foundry-demo/lib/forge-std/README.fr.md
@@ -0,0 +1,250 @@
+# Forge Standard Library • [![CI status](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml/badge.svg)](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml)
+
+[Lire en Anglais](./README.md)
+
+Forge Standard Library est une collection de contrats et de bibliothèques utiles pour être utilisés avec [Forge and Foundry](https://github.com/foundry-rs/foundry). Elle utilise les "cheatcodes" de Forge pour faciliter et accélérer l'écriture des tests, tout en améliorant l'expérience utilisateur des cheatcodes.
+
+**Apprenez à utiliser Forge-Std avec le [📖 Foundry Book (Forge-Std Guide)](https://book.getfoundry.sh/forge/forge-std.html).**
+
+## Install
+
+```bash
+forge install foundry-rs/forge-std
+```
+
+## Contracts
+### stdError
+
+C'est un contrat d'aide pour les erreurs et les revers. Dans Forge, ce contrat est particulièrement utile pour le cheatcode`expectRevert` cheatcode, car il fournit toutes les erreurs intégrées du compilateur.
+
+Voir le contrat pour tous les codes d'erreur.
+
+#### Example usage
+
+```solidity
+
+import "forge-std/Test.sol";
+
+contract TestContract is Test {
+    ErrorsTest test;
+
+    function setUp() public {
+        test = new ErrorsTest();
+    }
+
+    function testExpectArithmetic() public {
+        vm.expectRevert(stdError.arithmeticError);
+        test.arithmeticError(10);
+    }
+}
+
+contract ErrorsTest {
+    function arithmeticError(uint256 a) public {
+        uint256 a = a - 100;
+    }
+}
+```
+
+### stdStorage
+
+C'est un contrat assez grand à cause des nombreuses surcharges pour rendre l'expérience utilisateur meilleure. C'est principalement une enveloppe autour des cheatcodes `record` et `accesses`. Il peut *toujours* trouver et écrire dans les emplacements de stockage associés à une variable sans connaître la disposition du stockage. La seule limite _majeur_ est que, même si un emplacement peut être trouvé pour des variables de stockage groupées, nous ne pouvons pas y écrire en toute sécurité. Si un utilisateur essaie d'écrire dans un emplacement groupé, l'exécution génère une erreur, sauf si l'emplacement est non initialisé (`bytes32(0)`).
+
+Cela fonctionne en enregistrant tous les `SLOAD`et `SSTORE` pendant un appel de fonction. S'il n'y a qu'un seul emplacement lu ou écrit, il le retourne immédiatement. Sinon, en arrière-plan, nous parcourons et vérifions chacun (en supposant que l'utilisateur ait passé un paramètre `depth`).  Si la variable est une structure, vous pouvez passer un paramètre `depth` qui est en gros la profondeur du champ.
+I.e.:
+```solidity
+struct T {
+    // depth 0
+    uint256 a;
+    // depth 1
+    uint256 b;
+}
+```
+
+#### Example usage
+
+```solidity
+import "forge-std/Test.sol";
+
+contract TestContract is Test {
+    using stdStorage for StdStorage;
+
+    Storage test;
+
+    function setUp() public {
+        test = new Storage();
+    }
+
+    function testFindExists() public {
+        // Lets say we want to find the slot for the public
+        // variable `exists`. We just pass in the function selector
+        // to the `find` command
+        uint256 slot = stdstore.target(address(test)).sig("exists()").find();
+        assertEq(slot, 0);
+    }
+
+    function testWriteExists() public {
+        // Lets say we want to write to the slot for the public
+        // variable `exists`. We just pass in the function selector
+        // to the `checked_write` command
+        stdstore.target(address(test)).sig("exists()").checked_write(100);
+        assertEq(test.exists(), 100);
+    }
+
+    // It supports arbitrary storage layouts, like assembly based storage locations
+    function testFindHidden() public {
+        // `hidden` is a random hash of a bytes, iteration through slots would
+        // not find it. Our mechanism does
+        // Also, you can use the selector instead of a string
+        uint256 slot = stdstore.target(address(test)).sig(test.hidden.selector).find();
+        assertEq(slot, uint256(keccak256("my.random.var")));
+    }
+
+    // If targeting a mapping, you have to pass in the keys necessary to perform the find
+    // i.e.:
+    function testFindMapping() public {
+        uint256 slot = stdstore
+            .target(address(test))
+            .sig(test.map_addr.selector)
+            .with_key(address(this))
+            .find();
+        // in the `Storage` constructor, we wrote that this address' value was 1 in the map
+        // so when we load the slot, we expect it to be 1
+        assertEq(uint(vm.load(address(test), bytes32(slot))), 1);
+    }
+
+    // If the target is a struct, you can specify the field depth:
+    function testFindStruct() public {
+        // NOTE: see the depth parameter - 0 means 0th field, 1 means 1st field, etc.
+        uint256 slot_for_a_field = stdstore
+            .target(address(test))
+            .sig(test.basicStruct.selector)
+            .depth(0)
+            .find();
+
+        uint256 slot_for_b_field = stdstore
+            .target(address(test))
+            .sig(test.basicStruct.selector)
+            .depth(1)
+            .find();
+
+        assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1);
+        assertEq(uint(vm.load(address(test), bytes32(slot_for_b_field))), 2);
+    }
+}
+
+// A complex storage contract
+contract Storage {
+    struct UnpackedStruct {
+        uint256 a;
+        uint256 b;
+    }
+
+    constructor() {
+        map_addr[msg.sender] = 1;
+    }
+
+    uint256 public exists = 1;
+    mapping(address => uint256) public map_addr;
+    // mapping(address => Packed) public map_packed;
+    mapping(address => UnpackedStruct) public map_struct;
+    mapping(address => mapping(address => uint256)) public deep_map;
+    mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct;
+    UnpackedStruct public basicStruct = UnpackedStruct({
+        a: 1,
+        b: 2
+    });
+
+    function hidden() public view returns (bytes32 t) {
+        // an extremely hidden storage slot
+        bytes32 slot = keccak256("my.random.var");
+        assembly {
+            t := sload(slot)
+        }
+    }
+}
+```
+
+### stdCheats
+
+C'est un wrapper autour de divers cheatcodes qui nécessitent des wrappers pour être plus conviviaux pour les développeurs. Actuellement, il n'y a que des fonctions liées à `prank`.En général, les utilisateurs peuvent s'attendre à ce que de l'ETH soit envoyé à une adresse lors de `prank`, mais ce n'est pas le cas pour des raisons de sécurité. Explicitement, cette fonction`hoax` ne doit être utilisée que pour les adresses ayant des soldes attendus, car elle va les écraser. Si une adresse possède déjà de l'ETH, vous devriez simplement utiliser  `prank`.Si vous souhaitez modifier ce solde explicitement, utilisez  `deal`. Si vous voulez faire les deux,  `hoax`est également adapté.
+
+
+#### Exemple d'utilisation :
+```solidity
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+
+// Inherit the stdCheats
+contract StdCheatsTest is Test {
+    Bar test;
+    function setUp() public {
+        test = new Bar();
+    }
+
+    function testHoax() public {
+        // we call `hoax`, which gives the target address
+        // eth and then calls `prank`
+        hoax(address(1337));
+        test.bar{value: 100}(address(1337));
+
+        // overloaded to allow you to specify how much eth to
+        // initialize the address with
+        hoax(address(1337), 1);
+        test.bar{value: 1}(address(1337));
+    }
+
+    function testStartHoax() public {
+        // we call `startHoax`, which gives the target address
+        // eth and then calls `startPrank`
+        //
+        // it is also overloaded so that you can specify an eth amount
+        startHoax(address(1337));
+        test.bar{value: 100}(address(1337));
+        test.bar{value: 100}(address(1337));
+        vm.stopPrank();
+        test.bar(address(this));
+    }
+}
+
+contract Bar {
+    function bar(address expectedSender) public payable {
+        require(msg.sender == expectedSender, "!prank");
+    }
+}
+```
+
+### Std Assertions
+
+Contient diverses assertions.
+
+### `console.log`
+
+L'utilisation suit le même format que [Hardhat](https://hardhat.org/hardhat-network/reference/#console-log).
+Il est recommandé d'utiliser  `console2.sol`comme indiqué ci-dessous, car cela affiche les logs décodés dans les traces Forge.
+
+```solidity
+// import it indirectly via Test.sol
+import "forge-std/Test.sol";
+// or directly import it
+import "forge-std/console2.sol";
+...
+console2.log(someValue);
+```
+
+Si vous avez besoin de compatibilité avec Hardhat, vous devez utiliser `console.sol`standard à la place. En raison d'un bug dans`console.sol`, les logs qui utilisent des types `uint256` ou `int256` ne seront pas correctement décodés dans les traces Forge.
+
+```solidity
+// import it indirectly via Test.sol
+import "forge-std/Test.sol";
+// or directly import it
+import "forge-std/console.sol";
+...
+console.log(someValue);
+```
+
+## Licence
+
+Forge Standard Library est proposé sous licence [MIT](LICENSE-MIT) ou [Apache 2.0](LICENSE-APACHE) .
diff --git a/contract-deployment-demo/foundry-demo/lib/forge-std/README.md b/contract-deployment-demo/foundry-demo/lib/forge-std/README.md
index 0cb8660..f8a3d4d 100644
--- a/contract-deployment-demo/foundry-demo/lib/forge-std/README.md
+++ b/contract-deployment-demo/foundry-demo/lib/forge-std/README.md
@@ -1,5 +1,8 @@
 # Forge Standard Library • [![CI status](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml/badge.svg)](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml)
 
+[Lire en français](./README.fr.md)
+
+
 Forge Standard Library is a collection of helpful contracts and libraries for use with [Forge and Foundry](https://github.com/foundry-rs/foundry). It leverages Forge's cheatcodes to make writing tests easier and faster, while improving the UX of cheatcodes.
 
 **Learn how to use Forge-Std with the [📖 Foundry Book (Forge-Std Guide)](https://book.getfoundry.sh/forge/forge-std.html).**
diff --git a/contract-deployment-demos/foundry-demo/README.fr.md b/contract-deployment-demos/foundry-demo/README.fr.md
new file mode 100644
index 0000000..1a46f10
--- /dev/null
+++ b/contract-deployment-demos/foundry-demo/README.fr.md
@@ -0,0 +1,115 @@
+[Read in English](./README.md)
+## Foundry
+
+**Foundry est un outil ultra-rapide, portable et modulaire pour le développement d'applications Ethereum, écrit en Rust.**
+
+Foundry se compose de :
+
+-   **Forge**: Framework de test Ethereum (comme Truffle, Hardhat et DappTools).
+-   **Cast**: Un outil multifonction pour interagir avec les contrats intelligents EVM, envoyer des transactions et obtenir des données de la blockchain.
+-   **Anvil**:Un nœud Ethereum local, similaire à Ganache et Hardhat Network.
+-   **Chisel**:  Un REPL (Read-Eval-Print Loop) pour Solidity rapide et pratique.
+
+## Exemple de démarche
+
+### Installer Foundry
+```bash
+curl -L https://foundry.paradigm.xyz | bash
+foundryup
+```
+
+Ensuite, allez dans le bon dossier de notre exemple :
+
+```bash
+cd contract-deployment-demos/foundry-demo
+```
+
+### Compiler
+
+```bash
+forge build
+```
+### Deployer
+
+Un script de déploiement et l'utilisation de variables d'environnement sont déjà configurés pour vous. Vous pouvez voir le script à script/Counter.s.sol.
+
+Renommez le fichier .env.example en .env et remplissez votre clé privée. L'URL RPC ainsi que l'URL du vérificateur sont déjà préremplies.
+
+Pour utiliser les variables dans votre fichier .env, exécutez la commande suivante :
+
+```shell
+source .env
+```
+
+Vous pouvez maintenant déployer sur Morph avec la commande suivante : 
+
+```shell
+forge script script/Counter.s.sol --rpc-url $RPC_URL --broadcast --private-key $DEPLOYER_PRIVATE_KEY --legacy
+```
+
+Ajustez selon les noms de vos propres scripts.
+
+### Vérifier 
+
+La vérification nécessite l'ajout de quelques options au script de vérification habituel. Vous pouvez vérifier en utilisant la commande suivante :
+
+```bash
+ forge verify-contract YourContractAddress Counter\
+  --chain 2810 \
+  --verifier-url $VERIFIER_URL \
+  --verifier blockscout --watch
+```
+
+Une fois la vérification réussie, vous pouvez consulter votre contrat et la transaction de déploiement sur[Morph Holesky Explorer](https://explorer-holesky.morphl2.io)
+
+### Cast
+
+```shell
+cast <subcommand>
+```
+
+### Help
+
+```shell
+forge --help
+anvil --help
+cast --help
+```
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+forge build
+```
+
+### Test
+
+```shell
+forge test
+```
+
+### Format
+
+```shell
+forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+forge snapshot
+```
+
+### Anvil
+
+```shell
+anvil
+```
+
+
diff --git a/contract-deployment-demos/foundry-demo/README.md b/contract-deployment-demos/foundry-demo/README.md
index 1d86ff0..dbb51e3 100644
--- a/contract-deployment-demos/foundry-demo/README.md
+++ b/contract-deployment-demos/foundry-demo/README.md
@@ -1,3 +1,4 @@
+[Lire en Francais](./README.fr.md)
 ## Foundry
 
 **Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
diff --git a/contract-deployment-demos/foundry-demo/lib/forge-std/README.fr.md b/contract-deployment-demos/foundry-demo/lib/forge-std/README.fr.md
new file mode 100644
index 0000000..99ed8ce
--- /dev/null
+++ b/contract-deployment-demos/foundry-demo/lib/forge-std/README.fr.md
@@ -0,0 +1,251 @@
+[Read in English](./README.md)
+# La Bibliothèque Standard de Forge • [![CI status](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml/badge.svg)](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml)
+
+est une collection de contrats et de bibliothèques utiles à utiliser avec  [Forge and Foundry](https://github.com/foundry-rs/foundry).  Elle utilise les "cheatcodes" de Forge pour faciliter et accélérer l’écriture des tests, tout en améliorant l’expérience utilisateur des cheatcodes.
+
+**Apprenez à utiliser Forge-Std avec le [📖 Foundry Book (Forge-Std Guide)](https://book.getfoundry.sh/forge/forge-std.html).**
+
+## Install
+
+```bash
+forge install foundry-rs/forge-std
+```
+
+## Contracts
+### stdError
+
+Ceci est un contrat d'aide pour gérer les erreurs et les "reverts" (annulations). Dans Forge, ce contrat est très utile pour le cheatcode`expectRevert` cheatcode,  car il fournit toutes les erreurs par défaut du compilateur.
+Consultez le contrat lui-même pour voir tous les codes d'erreurs.
+
+#### Exemple d'utilisation
+
+```solidity
+
+import "forge-std/Test.sol";
+
+contract TestContract is Test {
+    ErrorsTest test;
+
+    function setUp() public {
+        test = new ErrorsTest();
+    }
+
+    function testExpectArithmetic() public {
+        vm.expectRevert(stdError.arithmeticError);
+        test.arithmeticError(10);
+    }
+}
+
+contract ErrorsTest {
+    function arithmeticError(uint256 a) public {
+        uint256 a = a - 100;
+    }
+}
+```
+
+### stdStorage
+
+Ce contrat est assez volumineux car il surcharge plusieurs fonctions pour rendre l’expérience utilisateur meilleure. Principalement, il enveloppe les cheatcodes  `record` et `accesses` (accès).Il peut *always* trouver et écrire dans l'emplacement de stockage associé à une variable particulière sans connaître la structure exacte du stockage.
+
+L'exception principale est que, bien qu'il puisse trouver l'emplacement de variables stockées de manière compressée, il n'est pas possible d’écrire dans ces emplacements de manière sûre. Si un utilisateur tente de le faire, une erreur est levée, sauf si la variable n’est pas initialisée(`bytes32(0)`).
+
+Cela fonctionne en enregistrant tous les appels de`SLOAD`s et `SSTORE`s(écriture de stockage) pendant l’exécution d’une fonction. Si un seul emplacement de stockage est lu ou écrit, il est retourné immédiatement. Sinon, le contrat parcourt les emplacements pour vérifier (en supposant que l'utilisateur a passé un paramètre `depth` (profondeur)).
+
+I.e.:
+```solidity
+struct T {
+    // depth 0
+    uint256 a;
+    // depth 1
+    uint256 b;
+}
+```
+
+#### Exemple d'utilisation
+
+```solidity
+import "forge-std/Test.sol";
+
+contract TestContract is Test {
+    using stdStorage for StdStorage;
+
+    Storage test;
+
+    function setUp() public {
+        test = new Storage();
+    }
+
+    function testFindExists() public {
+        // Lets say we want to find the slot for the public
+        // variable `exists`. We just pass in the function selector
+        // to the `find` command
+        uint256 slot = stdstore.target(address(test)).sig("exists()").find();
+        assertEq(slot, 0);
+    }
+
+    function testWriteExists() public {
+        // Lets say we want to write to the slot for the public
+        // variable `exists`. We just pass in the function selector
+        // to the `checked_write` command
+        stdstore.target(address(test)).sig("exists()").checked_write(100);
+        assertEq(test.exists(), 100);
+    }
+
+    // It supports arbitrary storage layouts, like assembly based storage locations
+    function testFindHidden() public {
+        // `hidden` is a random hash of a bytes, iteration through slots would
+        // not find it. Our mechanism does
+        // Also, you can use the selector instead of a string
+        uint256 slot = stdstore.target(address(test)).sig(test.hidden.selector).find();
+        assertEq(slot, uint256(keccak256("my.random.var")));
+    }
+
+    // If targeting a mapping, you have to pass in the keys necessary to perform the find
+    // i.e.:
+    function testFindMapping() public {
+        uint256 slot = stdstore
+            .target(address(test))
+            .sig(test.map_addr.selector)
+            .with_key(address(this))
+            .find();
+        // in the `Storage` constructor, we wrote that this address' value was 1 in the map
+        // so when we load the slot, we expect it to be 1
+        assertEq(uint(vm.load(address(test), bytes32(slot))), 1);
+    }
+
+    // If the target is a struct, you can specify the field depth:
+    function testFindStruct() public {
+        // NOTE: see the depth parameter - 0 means 0th field, 1 means 1st field, etc.
+        uint256 slot_for_a_field = stdstore
+            .target(address(test))
+            .sig(test.basicStruct.selector)
+            .depth(0)
+            .find();
+
+        uint256 slot_for_b_field = stdstore
+            .target(address(test))
+            .sig(test.basicStruct.selector)
+            .depth(1)
+            .find();
+
+        assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1);
+        assertEq(uint(vm.load(address(test), bytes32(slot_for_b_field))), 2);
+    }
+}
+
+// A complex storage contract
+contract Storage {
+    struct UnpackedStruct {
+        uint256 a;
+        uint256 b;
+    }
+
+    constructor() {
+        map_addr[msg.sender] = 1;
+    }
+
+    uint256 public exists = 1;
+    mapping(address => uint256) public map_addr;
+    // mapping(address => Packed) public map_packed;
+    mapping(address => UnpackedStruct) public map_struct;
+    mapping(address => mapping(address => uint256)) public deep_map;
+    mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct;
+    UnpackedStruct public basicStruct = UnpackedStruct({
+        a: 1,
+        b: 2
+    });
+
+    function hidden() public view returns (bytes32 t) {
+        // an extremely hidden storage slot
+        bytes32 slot = keccak256("my.random.var");
+        assembly {
+            t := sload(slot)
+        }
+    }
+}
+```
+
+### stdCheats
+
+C'est un ensemble de "cheatcodes" divers qui nécessitent des enveloppes pour être plus conviviaux pour les développeurs. Actuellement, seules les fonctions liées à `prank`.  (tromperie) sont présentes. En général, les utilisateurs s'attendent à ce que de l'ETH soit ajouté à une adresse lors de l’utilisation de  `prank`,  mais ce n'est pas le cas pour des raisons de sécurité. Plus précisément, la fonction `hoax`doit seulement être utilisée pour une adresse ayant un solde attendu, car celui-ci sera écrasé. Si une adresse possède déjà de l'ETH, utilisez simplement`prank`. Si vous voulez changer explicitement ce solde, utilisez  `deal`. Si vous voulez faire les deux, `hoax` est aussi la bonne option.
+
+
+#### Exemple d'utilisation :
+```solidity
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+
+// Inherit the stdCheats
+contract StdCheatsTest is Test {
+    Bar test;
+    function setUp() public {
+        test = new Bar();
+    }
+
+    function testHoax() public {
+        // we call `hoax`, which gives the target address
+        // eth and then calls `prank`
+        hoax(address(1337));
+        test.bar{value: 100}(address(1337));
+
+        // overloaded to allow you to specify how much eth to
+        // initialize the address with
+        hoax(address(1337), 1);
+        test.bar{value: 1}(address(1337));
+    }
+
+    function testStartHoax() public {
+        // we call `startHoax`, which gives the target address
+        // eth and then calls `startPrank`
+        //
+        // it is also overloaded so that you can specify an eth amount
+        startHoax(address(1337));
+        test.bar{value: 100}(address(1337));
+        test.bar{value: 100}(address(1337));
+        vm.stopPrank();
+        test.bar(address(this));
+    }
+}
+
+contract Bar {
+    function bar(address expectedSender) public payable {
+        require(msg.sender == expectedSender, "!prank");
+    }
+}
+```
+
+### Std Assertions (Assertions Standard)
+
+Contient diverses assertions pour vérifier les résultats dans les tests.
+
+### `console.log`
+
+L'utilisation suit le même format que [Hardhat](https://hardhat.org/hardhat-network/reference/#console-log).
+Il est recommandé d'utiliser  `console2.sol` comme montré ci-dessous, car cela affichera les logs décodés dans les traces de Forge.
+
+```solidity
+// import it indirectly via Test.sol
+import "forge-std/Test.sol";
+// or directly import it
+import "forge-std/console2.sol";
+...
+console2.log(someValue);
+```
+
+Si vous avez besoin de compatibilité avec Hardhat, vous devez utiliser  `console.sol` à la place. En raison d'un bug dans  `console.sol`, les logs qui utilisent les types `uint256` ou `int256` ne seront pas correctement décodés dans les traces de Forge.
+
+```solidity
+// import it indirectly via Test.sol
+import "forge-std/Test.sol";
+// or directly import it
+import "forge-std/console.sol";
+...
+console.log(someValue);
+```
+
+## License
+
+La Forge Standard Library est proposée sous la licence  [MIT](LICENSE-MIT) or [Apache 2.0](LICENSE-APACHE) .
diff --git a/contract-deployment-demos/foundry-demo/lib/forge-std/README.md b/contract-deployment-demos/foundry-demo/lib/forge-std/README.md
index 0cb8660..4a60d55 100644
--- a/contract-deployment-demos/foundry-demo/lib/forge-std/README.md
+++ b/contract-deployment-demos/foundry-demo/lib/forge-std/README.md
@@ -1,3 +1,4 @@
+[Lire en Français](./README.fr.md)
 # Forge Standard Library • [![CI status](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml/badge.svg)](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml)
 
 Forge Standard Library is a collection of helpful contracts and libraries for use with [Forge and Foundry](https://github.com/foundry-rs/foundry). It leverages Forge's cheatcodes to make writing tests easier and faster, while improving the UX of cheatcodes.
diff --git a/contract-deployment-demos/hardhat-demo/README.fr.md b/contract-deployment-demos/hardhat-demo/README.fr.md
new file mode 100644
index 0000000..c3e894e
--- /dev/null
+++ b/contract-deployment-demos/hardhat-demo/README.fr.md
@@ -0,0 +1,100 @@
+# Démonstration de Déploiement de Contrat sur Morph
+[Read in English](./README.md)
+Ce projet montre comment utiliser Hardhat pour déployer un contrat sur le réseau de test Morph Holesky. Le projet contient un contrat simple qui verrouille une certaine quantité d'Ether pour un temps donné dans le contrat déployé.
+
+## Prérequis
+
+- Configuration réseau : https://docs.morphl2.io/docs/build-on-morph/build-on-morph/development-setup
+
+## Déployer avec Hardhat
+
+### Installer les dépendances
+
+Si ce n'est pas déjà fait, installez [nodejs](https://nodejs.org/en/download/) et [yarn](https://classic.yarnpkg.com/lang/en/docs/install).
+
+```bash
+cd contract-deployment-demos/hardhat-demo
+yarn install
+```
+Cela installera tout ce dont vous avez besoin, y compris Hardhat.
+
+
+### CCompiler
+
+Compilez votre contrat avec :
+
+```bash
+yarn compile
+```
+
+### Tester
+
+Cela exécutera le script de test dans test/Lock.ts :
+
+```bash
+yarn test
+```
+
+### Déployer
+
+ Créez un fichier `.env` en suivant l'exemple `.env.example` à la racine du projet. Remplacez `PRIVATE_KEY`par la clé privée de votre compte.
+
+Modifiez les paramètres réseau dans le fichier hardhat.config.ts avec les informations suivantes :
+
+   ```javascript
+    morphTestnet: {
+      url: process.env.MORPH_TESTNET_URL || "",
+      accounts:
+        process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
+    }
+   ```
+Ensuite, exécutez la commande suivante pour déployer le contrat sur le réseau de test Morph Holesky. Cela exécutera le script de déploiement qui définit les paramètres initiaux, vous pouvez éditer le script dans scripts/deploy.ts :
+```bash
+yarn deploy:morphTestnet
+```
+
+### Vérifier vos contrats sur Morph Explorer
+
+Pour vérifier votre contrat via Hardhat, ajoutez les configurations Etherscan et Sourcify dans votre fichier hardhat.config.js :
+
+```javascript
+module.exports = {
+  networks: {
+    morphTestnet: { ... }
+  },
+  etherscan: {
+    apiKey: {
+      morphTestnet: 'anything',
+    },
+    customChains: [
+      {
+        network: 'morphTestnet',
+        chainId: 2810,
+        urls: {
+          apiURL: 'https://explorer-api-holesky.morphl2.io/api? ',
+          browserURL: 'https://explorer-holesky.morphl2.io/',
+        },
+      },
+    ],
+  },
+};
+```
+Ensuite, exécutez la commande de vérification de Hardhat pour finaliser la vérification :
+
+```bash
+npx hardhat verify --network morphTestnet DEPLOYED_CONTRACT_ADDRESS <ConstructorParameter>
+```
+
+Par exemple :
+
+```bash
+npx hardhat verify --network morphTestnet 0x8025985e35f1bAFfd661717f66fC5a434417448E '0.00001'
+```
+
+
+Une fois réussie, vous pourrez consulter votre contrat et la transaction de déploiement sur [Morph Holesky Explorer](https://explorer-holesky.morphl2.io)
+   
+
+## Support
+
+Merci de participer au développement sur le réseau de test Morph Holesky ! Si vous rencontrez des problèmes, rejoignez notre [Discord](https://discord.com/invite/5SmG4yhzVZ)et trouvez-nous dans le canal #dev-help.
\ No newline at end of file
diff --git a/contract-deployment-demos/hardhat-demo/README.md b/contract-deployment-demos/hardhat-demo/README.md
index 0837088..df52184 100644
--- a/contract-deployment-demos/hardhat-demo/README.md
+++ b/contract-deployment-demos/hardhat-demo/README.md
@@ -1,5 +1,5 @@
 # Morph Contract Deployment Demo
-
+[Lire en Anglais](./README.fr.md)
 This project demonstrates how to use hardhat to deploy a contract on the Morph Holesky Testnet. This project contains a simple contract that will lock a certain amount of Ether in the deployed contract for a specified amount of time.
 
 ## Prerequisites
diff --git a/frontend_examples/nextjs_wagmi_template/README.fr.md b/frontend_examples/nextjs_wagmi_template/README.fr.md
new file mode 100644
index 0000000..3ba3739
--- /dev/null
+++ b/frontend_examples/nextjs_wagmi_template/README.fr.md
@@ -0,0 +1,33 @@
+Il s'agit d'un projet[Next.js](https://nextjs.org/)  démarré avec [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
+
+[Read in English](./README.md)
+
+## Démarrage
+
+Exécutez `cd frontend_examples/nextjs_wagmi_template`
+
+Exécutez `npm install`
+
+Ensuite, lancez le serveur de développement :
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Ouvrez [http://localhost:3000](http://localhost:3000) dans votre navigateur pour voir le résultat.
+
+Vous pouvez commencer à modifier la page en éditant le fichier  `pages/index.tsx`. La page se met à jour automatiquement à mesure que vous modifiez le fichier.
+
+## ABI et Contrat
+
+Ce modèle contient une ABI et une adresse de contrat prédéfinies pour un compteur simple déployé sur Morph. Vous pouvez mettre à jour ces valeurs selon vos besoins pour vous connecter à vos propres contrats. 
+
+
+
+
diff --git a/frontend_examples/nextjs_wagmi_template/README.md b/frontend_examples/nextjs_wagmi_template/README.md
index 2744076..1fc4db7 100644
--- a/frontend_examples/nextjs_wagmi_template/README.md
+++ b/frontend_examples/nextjs_wagmi_template/README.md
@@ -1,5 +1,7 @@
 This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
 
+[Lre en francais](./README.fr.md)
+
 ## Getting Started
 
 Run `cd frontend_examples/nextjs_wagmi_template`