diff --git a/content/tutorials/cross-chain-governance/10.index.md b/content/tutorials/cross-chain-governance/10.index.md
index 0af07eb2..94e3be10 100644
--- a/content/tutorials/cross-chain-governance/10.index.md
+++ b/content/tutorials/cross-chain-governance/10.index.md
@@ -6,8 +6,9 @@ description: Build and deploy a smart contract in L1 and send transactions that
 This tutorial shows you how to implement communication between L1 and L2 with the following example:
 
 - A **Governance** Solidity smart contract is deployed on layer 1. This contract has a function that sends a transaction
-  to ZKsync layer 2.
-- A **Counter** Solidity smart contract is deployed on ZKsync layer 2. This contract stores a number that is incremented
+  to ZKsync Era layer 2.
+- A **Counter** Solidity smart contract is deployed on ZKsync Era layer 2. This contract stores a number that is incremented
+
   by calling the `increment` method. The `Governance` contract on layer 1 calls this function.
 
 ## Prerequisites
@@ -52,7 +53,7 @@ The `L2-counter` code includes all ZKsync dependencies and configurations for L2
 2. Run the following to initialise and set up the L1 project:
 
 ```sh
-npx hardhat
+npx hardhat init
 ```
 
 Select the option **Create a Typescript project** and accept the defaults for everything else.
@@ -73,11 +74,11 @@ Make sure you use actual node (lts version) and actual npm version
 ::code-group
 
 ```bash [npm]
-npm i -D typescript ts-node @openzeppelin/contracts @matterlabs/zksync-contracts @nomicfoundation/hardhat-ethers @typechain/ethers-v6 @typechain/hardhat typechain ethers
+npm i -D typescript ts-node @openzeppelin/contracts @matterlabs/zksync-contracts @nomicfoundation/hardhat-ethers @typechain/ethers-v6 @typechain/hardhat typechain ethers dotenv
 ```
 
 ```bash [yarn]
-yarn add -D typescript ts-node @openzeppelin/contracts @matterlabs/zksync-contracts @nomicfoundation/hardhat-ethers @typechain/ethers-v6 @typechain/hardhat typechain ethers
+yarn add -D typescript ts-node @openzeppelin/contracts @matterlabs/zksync-contracts @nomicfoundation/hardhat-ethers @typechain/ethers-v6 @typechain/hardhat typechain ethers dotenv
 ```
 
 ::
@@ -130,68 +131,52 @@ contract Governance {
 
 ### Deploy L1 Governance Contract
 
-1. Create the file `L1-Governance/sepolia.json` and copy/paste the code below, filling in the relevant values.
+1. Create the file `L1-Governance/.env` and copy/paste the code below, filling in the relevant values.
   Find node provider urls [here](https://chainlist.org/chain/11155111).
   You have to connect your wallet to the network and add the network to the wallet in advance.
 
-    ```json [L1-Governance/sepolia.json]
-    {
-      "nodeUrl": "<SEPOLIA NODE URL>",
-      "deployerPrivateKey": "<YOUR PRIVATE KEY>"
-    }
+    ```txt [L1-Governance/.env]
+    NODE_RPC_URL=
+    PRIVATE_KEY=
     ```
 
 1. Replace the code in `hardhat.config.ts` with the following:
 
     ```ts
-    import "@nomicfoundation/hardhat-ethers";
     import { HardhatUserConfig } from "hardhat/config";
+    import "@nomicfoundation/hardhat-toolbox";
 
-    // import file with Sepolia params
-    const sepolia = require("./sepolia.json");
+    import dotenv from "dotenv";
+    dotenv.config();
 
     const config: HardhatUserConfig = {
-      solidity: {
-        version: "0.8.20",
-      },
+      solidity: "0.8.24",
       networks: {
-        // Sepolia network
-        sepolia: {
-          url: sepolia.nodeUrl,
-          accounts: [sepolia.deployerPrivateKey],
-        },
-      },
+            // Sepolia network
+            sepolia: {
+              url: process.env.NODE_RPC_URL,
+              accounts: [process.env.PRIVATE_KEY as any],
+            },
+          },
     };
 
     export default config;
     ```
 
-1. Navigate to the `scripts` folder and copy/paste the following code into the `deploy.ts` file (removing any previous
-   code):
+1. Create the file `Governance.ts` inside the `/ignition/modules` folder and copy/paste the following code into it:
 
     ```ts
-    // We require the Hardhat Runtime Environment explicitly here. This is optional
-    // but useful for running the script in a standalone fashion through `node <script>`.
-    //
-    // When running the script with `npx hardhat run <script>` you'll find the Hardhat
-    // Runtime Environment's members available in the global scope.
-    import { ethers } from "hardhat";
+    import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 
-    async function main() {
-      // We get the contract to deploy
-      const Governance = await ethers.getContractFactory("Governance");
+    const GovernanceModule = buildModule("GovernanceModule", (m) => {
+      
+      const governance = m.contract("Governance", [], {  });
 
-      const contract = await Governance.deploy();
-      const receipt = await contract.deploymentTransaction()?.wait();
+      return { governance };
+    });
 
-      console.log(`Governance contract was successfully deployed at ${receipt?.contractAddress}`);
-    }
+    export default GovernanceModule;
 
-    // We recommend always using this async/await pattern to properly handle errors.
-    main().catch((error) => {
-      console.error(error);
-      process.exitCode = 1;
-    });
     ```
 
 1. From the `L1-governance` folder root, compile and deploy the contract:
@@ -203,7 +188,7 @@ contract Governance {
     npx hardhat compile
 
     # deploy contract
-    npx hardhat run --network sepolia ./scripts/deploy.ts
+    npx hardhat ignition deploy ./ignition/modules/Governance.ts --network sepolia
     ```
 
     ```sh [yarn]
@@ -211,7 +196,7 @@ contract Governance {
     yarn hardhat compile
 
     # deploy contract
-    yarn hardhat run --network sepolia ./scripts/deploy.ts
+    yarn hardhat ignition deploy ./ignition/modules/Governance.ts --network sepolia
     ```
 
     ::
@@ -219,7 +204,15 @@ contract Governance {
     You should see the following output:
 
     ```sh
-    Governance contract was successfully deployed at 0xf28Df77fa8ff56cA3084bd11c1CAF5033A7b8C4A
+    Deploying [ GovernanceModule ]
+    Batch #1
+      Executed GovernanceModule#Governance
+
+    [ GovernanceModule ] successfully deployed 🚀
+
+    Deployed Addresses
+
+    GovernanceModule#Governance - 0xA7d27A1202bE1237919Cf2cb60970141100725b4
     ```
 
     Save the address to use in a later step.
diff --git a/content/tutorials/cross-chain-governance/20.L2-contract.md b/content/tutorials/cross-chain-governance/20.L2-contract.md
index 42fd0a9b..e3e8fddc 100644
--- a/content/tutorials/cross-chain-governance/20.L2-contract.md
+++ b/content/tutorials/cross-chain-governance/20.L2-contract.md
@@ -1,6 +1,7 @@
 ---
 title: L2 counter contract
-description: Deploy a contract in ZKsync that has a counter.
+description: Deploy a contract in ZKsync Era that has a counter.
+
 ---
 
 ## L2 Counter
@@ -13,23 +14,12 @@ Now that we have an address for the L1 governance contract, we can build, deploy
     npx zksync-cli create L2-counter --template hardhat_solidity
     ```
 
-    ::callout{icon="i-heroicons-light-bulb"}
-    In case of any issues on this step (f.e. you did not have a yarn), you may get
-    errors during the recreation of the project environment.
-    Clean your current environment in advance or create another folder and create environment there.
-    ::
-
-1. For the purposes of this tutorial, we don't need the Greeter related files generated by the ZKsync-CLI.
-  Proceed with removing `Greeter.sol` from our `/contracts` directory:
-
-    ```sh
-    rm -rf ./contracts/Greeter.sol
-    ```
-
-1. Similarly, remove the deploy scripts associated with the Greeter contract:
+2. For the purposes of this tutorial, we don't need the example smart contracts and deployment script files generated by `zksync-cli`.
+   Run the following commands to remove them:
 
     ```sh
-    rm -rf ./deploy/deploy-greeter.ts && rm -rf ./deploy/use-greeter.ts
+    rm -rf ./contracts/*
+    rm -rf ./deploy/*
     ```
 
 ### Create L2 Counter Contract
@@ -44,7 +34,7 @@ Now that we have an address for the L1 governance contract, we can build, deploy
     ```solidity [Counter.sol]
     // SPDX-License-Identifier: Unlicense
 
-    pragma solidity ^0.8.20;
+    pragma solidity ^0.8.17;
 
     contract Counter {
         uint256 public value = 0;
@@ -83,7 +73,7 @@ Now that we have an address for the L1 governance contract, we can build, deploy
 ### Deploy L2 Counter Contract
 
 1. Copy/paste the following code into `L2-counter/deploy/deploy.ts`, replacing `<GOVERNANCE-ADDRESS>` with the address
-   of the Governance contract we just deployed, and `<WALLET-PRIVATE-KEY>` with your private key:
+   of the Governance contract we just deployed:
 
     ```typescript [L2-counter/deploy/deploy.ts]
     import { utils, Wallet } from "zksync-ethers";
@@ -121,12 +111,7 @@ Now that we have an address for the L1 governance contract, we can build, deploy
     }
     ```
 
-    ::callout{icon="i-heroicons-light-bulb"}
-    The deployment script contains a deposit from Sepolia to %%zk_testnet_name%%, which can take a few minutes to finish.
-    If your wallet already has funds in L2, you can skip that part to save you some time.
-    ::
-
-1. Now deploy the contract from the `L2-counter/` folder root to ZKsync:
+2. Now deploy the contract from the `L2-counter/` folder root to ZKsync:
 
     ::code-group
 
@@ -204,216 +189,3 @@ Now both contracts are deployed, we can create a script to retrieve the value of
     ```txt
     The counter value is 0
     ```
-
-## Call L2 Contract from L1
-
-Now, let's call the `increment` method on Layer 2 from Layer 1.
-
-1. Copy the `abi` array from the compilation artifact located at:
-
-    `/L1-governance/artifacts/contracts/Governance.sol/Governance.json`.
-
-    You have to copy only abi content from the file after the keyword abi, an example below:
-
-    ```json
-    [
-      {
-        "inputs": [
-          {
-            "internalType": "address",
-            "name": "newGovernance",
-            "type": "address"
-          }
-        ],
-        "stateMutability": "nonpayable",
-        "type": "constructor"
-      },
-      {
-        "inputs": [],
-        "name": "governance",
-        "outputs": [
-          {
-            "internalType": "address",
-            "name": "",
-            "type": "address"
-          }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-      },
-      {
-        "inputs": [],
-        "name": "increment",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-      },
-      {
-        "inputs": [],
-        "name": "value",
-        "outputs": [
-          {
-            "internalType": "uint256",
-            "name": "",
-            "type": "uint256"
-          }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-      }
-    ]
-    ```
-
-1. Paste it into a new file: `/L2-counter/scripts/governance.json`.
-
-1. Create the `L2-counter/scripts/increment-counter.ts` file and paste in the following code, replacing the following
-   details:
-
-    - GOVERNANCE-ADDRESS: the address of the contract deployed in L1.
-    - COUNTER-ADDRESS: the address of the contract deployed in L2.
-    - WALLET-PRIVATE-KEY: the private key of your account.
-    - RPC-URL: the same url you used in the `sepolia.json` file.
-
-    ```ts [L2-counter/scripts/increment-counter.ts]
-    import { Contract, Wallet, Interface } from "ethers";
-    import { Provider, utils } from "zksync-ethers";
-    // load env file
-    import dotenv from "dotenv";
-    dotenv.config();
-
-    const GOVERNANCE_ABI = require("./governance.json");
-    const GOVERNANCE_ADDRESS = "<GOVERNANCE-ADDRESS>";
-    const COUNTER_ABI = require("./counter.json");
-    const COUNTER_ADDRESS = "<COUNTER-ADDRESS>";
-
-    const PRIVATE_KEY = process.env.WALLET_PRIVATE_KEY || "";
-    if (!PRIVATE_KEY) throw "⛔️ Private key not detected! Add it to the .env file!";
-    // Initialize the wallet.
-
-    async function main() {
-      // Enter your Ethereum L1 provider RPC URL.
-      const l1Provider = new Provider("<L1-RPC-URL>");
-      // Set up the Governor wallet to be the same as the one that deployed the governance contract.
-      const wallet = new Wallet(PRIVATE_KEY, l1Provider);
-      // Set a constant that accesses the Layer 1 contract.
-      const govcontract = new Contract(GOVERNANCE_ADDRESS, GOVERNANCE_ABI, wallet);
-
-      // Initialize the L2 provider.
-      const l2Provider = new Provider("https://sepolia.era.zksync.dev");
-      // Get the current address of the ZKsync L1 bridge.
-      const zkSyncAddress = await l2Provider.getMainContractAddress();
-      // Get the `Contract` object of the ZKsync bridge.
-      const zkSyncContract = new Contract(zkSyncAddress, utils.ZKSYNC_MAIN_ABI, wallet);
-
-      // Encoding the L1 transaction is done in the same way as it is done on Ethereum.
-      // Use an Interface which gives access to the contract functions.
-      const counterInterface = new Interface(COUNTER_ABI);
-      const data = counterInterface.encodeFunctionData("increment", []);
-
-      // The price of an L1 transaction depends on the gas price used.
-      // You should explicitly fetch the gas price before making the call.
-      const gasPrice = await l1Provider.getGasPrice();
-
-      // Define a constant for gas limit which estimates the limit for the L1 to L2 transaction.
-      const gasLimit = await l2Provider.estimateL1ToL2Execute({
-        contractAddress: COUNTER_ADDRESS,
-        calldata: data,
-        caller: utils.applyL1ToL2Alias(GOVERNANCE_ADDRESS),
-      });
-      // baseCost takes the price and limit and formats the total in wei.
-      // For more information on `REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_LIMIT` see the [fee model documentation](../developer-guides/transactions/fee-model.md).
-      const baseCost = await zkSyncContract.l2TransactionBaseCost(gasPrice, gasLimit, utils.REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_LIMIT);
-
-      // !! If you don't include the gasPrice and baseCost in the transaction, a re-estimation of fee may generate errors.
-      const tx = await govcontract.callZkSync(zkSyncAddress, COUNTER_ADDRESS, data, gasLimit, utils.REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_LIMIT, {
-        // Pass the necessary ETH `value` to cover the fee for the operation
-        value: baseCost,
-        gasPrice,
-      });
-
-      // Wait until the L1 tx is complete.
-      await tx.wait();
-
-      // Get the TransactionResponse object for the L2 transaction corresponding to the execution call.
-      const l2Response = await l2Provider.getL2TransactionFromPriorityOp(tx);
-
-      // Output the receipt of the L2 transaction corresponding to the call to the counter contract.
-      const l2Receipt = await l2Response.wait();
-      console.log(l2Receipt);
-    }
-
-    // We recommend always using this async/await pattern to properly handle errors.
-    main().catch((error) => {
-      console.error(error);
-      process.exitCode = 1;
-    });
-    ```
-
-    ::callout{icon="i-heroicons-light-bulb"}
-    Executing transactions from L1 requires the caller to pay a fee to the L2 operator.
-    The fee depends on the length of the calldata and the `gasLimit`.
-    This is similar to the `gasLimit` on Ethereum.
-    The fee also depends on the gas price that is used during the transaction call.
-    So to have a predictable fee for the call, the gas price should be fetched from the L1 provider.
-    ::
-
-1. Run the script with the following command:
-
-    ::code-group
-
-    ```sh [npm]
-    npx ts-node ./scripts/increment-counter.ts
-    ```
-
-    ```sh [yarn]
-    yarn ts-node ./scripts/increment-counter.ts
-    ```
-
-    ::
-
-    In the output, you should see the full transaction receipt in L2.
-    You can take the `transactionHash` and track it in the [ZKsync explorer](https://sepolia.explorer.zksync.io/).
-    It should look something like this:
-
-    ```json
-    {
-      to: '0x9b379893bfAD08c12C2167C3e3dBf591BeD9410a',
-      from: '0xE2EA97507a6cb610c81c4A9c157B8060E2ED7036',
-      contractAddress: null,
-      transactionIndex: 0,
-      root: '0xb9ca78c288163a322a797ee671db8e9ab430eb00e38c4a989f2246ea22493945',
-      gasUsed: BigNumber { _hex: '0x05c3df', _isBigNumber: true },
-      logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
-      blockHash: '0xb9ca78c288163a322a797ee671db8e9ab430eb00e38c4a989f2246ea22493945',
-      transactionHash: '0x1fb19cc0aca8fcccaf5fbafd9174550f3151d0d2aa15d99eb820e0394313e409',
-      logs: [
-        {
-          transactionIndex: 0,
-          blockNumber: 4119331,
-          transactionHash: '0x1fb19cc0aca8fcccaf5fbafd9174550f3151d0d2aa15d99eb820e0394313e409',
-          address: '0x000000000000000000000000000000000000800A',
-          topics: [Array],
-          ...
-
-    ```
-
-1. Verify that the transaction was successful by running the `display-value` script again.
-
-    ```sh
-    npx ts-node ./scripts/display-value.ts
-    ```
-
-    You should see an incremented value in the output:
-
-    ```txt
-    The counter value is 1
-    ```
-
-## Learn More
-
-- To learn more about L1->L2 interaction on ZKsync, check out the
-  [documentation](https://docs.zksync.io/build/developer-reference/l1-l2-interoperability).
-- To learn more about the `zksync-ethers` SDK, check out its
-  [documentation](https://docs.zksync.io/sdk/ethers/v6/getting-started).
-- To learn more about the ZKsync hardhat plugins, check out their
-  [documentation](https://docs.zksync.io/build/tooling/hardhat/getting-started).
diff --git a/content/tutorials/cross-chain-governance/30.cross-chain-transactions.md b/content/tutorials/cross-chain-governance/30.cross-chain-transactions.md
index 71cb85c5..ee6ec9d3 100644
--- a/content/tutorials/cross-chain-governance/30.cross-chain-transactions.md
+++ b/content/tutorials/cross-chain-governance/30.cross-chain-transactions.md
@@ -70,7 +70,7 @@ Now, let's call the `increment` method on Layer 2 from Layer 1.
     - GOVERNANCE-ADDRESS: the address of the contract deployed in L1.
     - COUNTER-ADDRESS: the address of the contract deployed in L2.
     - WALLET-PRIVATE-KEY: the private key of your account.
-    - RPC-URL: the same url you used in the `sepolia.json` file.
+    - RPC-URL: the same url you used in the `.env` file of the `L1-governance` folder.
 
     ```ts [L2-counter/scripts/increment-counter.ts]
     import { Contract, Wallet, Interface } from "ethers";
@@ -151,6 +151,7 @@ Now, let's call the `increment` method on Layer 2 from Layer 1.
     Executing transactions from L1 requires the caller to pay a fee to the L2 operator.
     The fee depends on the length of the calldata and the `gasLimit`.
     This is similar to the `gasLimit` on Ethereum.
+
     You can read more about the [ZKsync fee model here](https://docs.zksync.io/build/developer-reference/fee-model).
     The fee also depends on the gas price that is used during the transaction call.
     So to have a predictable fee for the call, the gas price should be fetched from the L1 provider.
@@ -171,7 +172,7 @@ Now, let's call the `increment` method on Layer 2 from Layer 1.
     ::
 
     In the output, you should see the full transaction receipt in L2.
-    You can take the `transactionHash` and track it in the [%%zk_testnet_name%% Block Explorer](%%zk_testnet_block_explorer_url%%).
+    You can take the `transactionHash` and track it in the [ZKsync explorer](https://sepolia.explorer.zksync.io/).
     It should look something like this:
 
     ```json