diff --git a/components/content/NetworkAdder.vue b/components/content/NetworkAdder.vue
new file mode 100644
index 00000000..e592ae99
--- /dev/null
+++ b/components/content/NetworkAdder.vue
@@ -0,0 +1,68 @@
+
+
+
+
+
+ Add {{ chainName }}
+
+
+
+
diff --git a/content/10.zksync-101/1.zksync-overview.md b/content/10.zksync-101/1.zksync-overview.md
new file mode 100644
index 00000000..8184a6aa
--- /dev/null
+++ b/content/10.zksync-101/1.zksync-overview.md
@@ -0,0 +1,61 @@
+---
+title: zkSync overview
+description: A quick overview of what is zkSync
+---
+
+## What is zkSync?
+
+**zkSync Era** is a Layer 2 **[ZK rollup](https://docs.zksync.io/build/developer-reference/rollups.html#what-are-zk-rollups)**, a trustless protocol that uses cryptographic validity proofs to provide scalable and low-cost transactions on Ethereum. In zkSync Era, computation is performed off-chain and most data is stored off-chain as well. Transactions are bundled into batches before generating a validity proof. As all validity proofs are proven on the Ethereum mainchain, users enjoy the same security level as in Ethereum.
+
+DIAGRAM L1-L2
+
+zkSync Era is made to look and feel like Ethereum, but with a higher throughput and lower fees. Just like on Ethereum, smart contracts are written in Solidity/Vyper and can be called using the same clients as the other EVM-compatible chains.
+
+You don't need to register a separate private key before using it; zkSync supports existing Ethereum wallets out of the box.
+
+## Main features
+
+
+:check-icon Mainnet-like security with zero reliance on 3rd parties.
+
+:check-icon Permissionless EVM-compatible smart contracts.
+
+:check-icon Preserving key EVM features, such as smart contract composability.
+
+:check-icon Standard Web3 API.
+
+:check-icon State updates via transaction outputs (also known as state diffs) which provides significant cost savings over transaction inputs.
+
+:check-icon Native account abstraction with improvements over EIP4337 (implemented in Ethereum and other rollups).
+
+You can find [more information about zkSync Era in l2beat](https://l2beat.com/scaling/projects/zksync-era#stage).
+
+## Developer experience
+
+zkSync Era was built to provide a similar developer experience as Ethereum.
+
+:check-icon Smart contracts can be written in Solidity or Vyper.
+
+:check-icon Most contracts work out of the box so migrating projects is seamless.
+
+:check-icon Smart contracts are compiled with custom compilers: **[zksolc and zkvyper](https://docs.zksync.io/zk-stack/components/compiler/toolchain/overview.html)**.
+
+:check-icon Use existing frameworks like **[Hardhat](https://docs.zksync.io/build/tooling/hardhat/getting-started.html),** libraries like Ethers, Viem, or web3.js, and tools like theGraph, Thirdweb, or Chainlink.
+
+:check-icon Web3 API compatibility enables support of most developer tools.
+
+:check-icon Different **[tools for testing and debugging locally](https://docs.zksync.io/build/test-and-debug/getting-started.html)**.
+
+## User experience
+
+Interacting with applications built on zkSync Era is seamless, cheap and fast.
+
+- Transactions have instant confirmations and fast finality on L1.
+- Transaction fees are extremely low (see [average transaction costs here](https://www.growthepie.xyz/fundamentals/transaction-costs)).
+- Transaction fees can be conveniently paid with ERC20 tokens (e.g. USDC) thanks to **[native account abstraction and paymasters](https://docs.zksync.io/build/developer-reference/account-abstraction.html)**.
+- Support for existing Ethereum-based wallets like Metamask, TrustWallet, Zerion or Rabby.
+
+## Get started
+
+- Follow [this guide to Add the zkSync network to your wallet](./2.connect-zksync.md).
+- Deploy your first smart contract to zkSync Era in the **[quickstart](3.quickstart.md)**.
diff --git a/content/10.zksync-101/2.connect-zksync.md b/content/10.zksync-101/2.connect-zksync.md
new file mode 100644
index 00000000..63986230
--- /dev/null
+++ b/content/10.zksync-101/2.connect-zksync.md
@@ -0,0 +1,45 @@
+---
+title: Connect to zkSync
+description: Step-by-step guide to connect your wallet to zkSync.
+---
+
+## Add zkSync Era to your wallet
+
+You can add zkSync Era to your wallet using the buttons below:
+
+
+
+
+
+
+### Manual settings
+
+To manually add zkSync Era as a custom network in your wallet, follow these steps:
+
+1. Find the “Add Network” option in your wallet (in Metamask, you can find this in the networks dropdown).
+2. Click “Add Network"
+3. Fill in the following details for the zkSync Era network you want to add:
+
+**Mainnet network details**
+
+- Network Name: `zkSync Era Mainnet`
+- RPC URL: `https://mainnet.era.zksync.io`
+- Chain ID: `324`
+- Currency Symbol: `ETH`
+- Block Explorer URL: `https://explorer.zksync.io/`
+- WebSocket URL: `wss://mainnet.era.zksync.io/ws`
+
+**Sepolia testnet network details:**
+
+- Network Name: `zkSync Era Sepolia Testnet`
+- RPC URL: `https://sepolia.era.zksync.dev`
+- Chain ID: `300`
+- Currency Symbol: `ETH`
+- Block Explorer URL: `https://sepolia.explorer.zksync.io/`
+- WebSocket URL: `wss://sepolia.era.zksync.dev/ws`
+
+Click on "Save" to add the zkSync Era network to your wallet.
+
+## **How to get started?**
+
+Begin by deploying your first smart contract to zkSync Era in the **[quickstart](3.quickstart.md)**.
diff --git a/content/10.zksync-101/3.quickstart.md b/content/10.zksync-101/3.quickstart.md
new file mode 100644
index 00000000..0def5310
--- /dev/null
+++ b/content/10.zksync-101/3.quickstart.md
@@ -0,0 +1,112 @@
+---
+title: Quickstart
+description: Deploy a smart contract to zkSync in under 5 minutes
+---
+
+This tutorial shows you how to deploy and interact with a smart contract on zkSync Era in less than 5 minutes. It will help you get familiar with the zkSync smart contract development and deployment process using different tools.
+
+This is what we're going to do:
+
+:check-icon Fund your wallet with zkSync Sepolia ETH.
+
+:check-icon Build a smart contract to exchange secret messages with Zeek.
+
+:check-icon Deploy the smart contract to the zkSync Era Sepolia testnet using Remix or Atlas.
+
+Before you start, make sure that [you’ve configured the zkSync Sepolia tesnet in your browser wallet by following the instructions here](./2.connect-zksync.md).
+
+## Step 1: Fund your wallet
+
+zkSync Testnet ETH is used to deploy and interact with smart contracts on the zkSync Sepolia testnet. You can get it directly into zkSync Sepolia testnet using the **[following faucet provided by LearnWeb3](https://learnweb3.io/faucets/zksync_sepolia/)** (GitHub authentication required) or any of the [other available faucets](#).
+
+You can also bridge SepoliaETH to the zkSync Sepolia testnet using the **[zkSync bridge](https://portal.zksync.io/bridge/?network=sepolia)**.
+
+You can check the balance of your account in the **[zkSync Sepolia explorer](https://sepolia.explorer.zksync.io/)**.
+
+## Review the smart contract code
+
+The smart contract will store messages from users in a hashed format and emit events with replies from Zeek. The entire code is as follows:
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract ZeekSecretMessages {
+ bytes32[] private messages;
+
+ // Event to acknowledge a new message
+ event MessageReceived(string);
+
+ constructor() {
+ // Zeek initializes the contract with a welcome message
+ emit MessageReceived("Zeek welcomes you to zkSync!");
+ }
+
+ // Function to send a "secret" message to Zeek
+ function sendMessage(string memory _message) public {
+ bytes32 hashedMessage = keccak256(abi.encodePacked(_message));
+ messages.push(hashedMessage);
+
+ // Acknowledge the message receipt with Zeek's reply
+ emit MessageReceived("ZK is the endgame - Message received!");
+ }
+
+ // Function to count the total messages sent to Zeek
+ function getTotalMessages() public view returns (uint) {
+ return messages.length;
+ }
+}
+```
+
+The Solidity smart contract contains two functions:
+
+- `sendMessage` stores the messages sent by users in the `messages` state variable.
+- `getTotalMessages` returns the number of messages stored in the smart contract.
+
+::callout{icon="i-heroicons-light-bulb"}
+zkSync Era is EVM compatible. You can write smart contracts with Solidity or Vyper and use existing popular libraries like OpenZeppelin.
+::
+
+## Step 2: deploy the contract
+
+To deploy the contract we can use either Atlas or Remix:
+
+::content-switcher
+---
+items: [{
+ label: 'Atlas',
+ partial: '_quickstart/_atlas_deploy_contract'
+}, {
+ label: 'Remix',
+ partial: '_quickstart/_remix_deploy_contract'
+}]
+---
+::
+
+## Step 3: check the contract in explorer
+
+Copy the smart contract address from Atlas/Remix and search it the zkSync Sepolia testnet explorer. You’ll see the contract has a transaction from the message we just sent.
+
+
+
+Click in the transaction hash to check all its details, like timestamp, the account that send it, transaction fee etc. The status will be “Processed” on zkSync and “Sending” on Ethereum. To learn more about the transaction lifecycle on zkSync, check out this section of the docs.
+
+In the “Contract” tab you’ll see the contract source code as Atlas and Remix automatically verified the contract for us. When a smart contract is verified in a block explorer, it means that the source code of the contract has been published and matched to the compiled version on the blockchain enhancing transparency, as users can review the contract’s source code to understand its functions and intentions.
+
+Finally in the “Events” tab, you’ll see the replies from Zeek as these are emitted as events in our smart contract.
+
+
+
+ZK is the endgame!
+
+## Takeaways
+
+- **EVM-compatibility**: zkSync Era is EVM-compatible and you can write smart contracts in Solidity or Vyper as in Ethereum.
+- **Custom compilers**: smart contracts deployed to zkSync Era must be compiled with the customs compilers: `zksolc` for Solidity and `zkvyper` for Vyper.
+- **Browser-based IDEs**: Existing tools like Atlas and Remix use zkSync custom compilers under the hood.
+
+## Next steps
+
+- Join the zkSync developer community in Discord where you can ask any questions about this tutorial in the #dev-101 channel
+- Continue learning by deploying an ERC20 token to zkSync Era.
+- Join our GitHub Discussions community to help other devs building on zkSync or share your project.
diff --git a/content/10.zksync-101/4.erc20-token.md b/content/10.zksync-101/4.erc20-token.md
new file mode 100644
index 00000000..d0159ea0
--- /dev/null
+++ b/content/10.zksync-101/4.erc20-token.md
@@ -0,0 +1,43 @@
+---
+title: ERC20 token tutorial
+description: In this tutorial we'll deploy and ERC20 token to zkSync
+---
+
+This tutorial shows you how to deploy and interact with an ERC20 token on zkSync Era.
+
+This is what we’re going to do:
+
+:check-icon Build an ERC20 token smart contract with additional custom logic
+
+:check-icon Deploy the smart contract to the zkSync Era Sepolia testnet using Remix or Atlas.
+
+## Prerequisites
+
+Before you start, make sure that you’ve configured the zkSync Sepolia tesnet in your browser wallet by following the instructions here.
+
+In addition, fund your wallet with testnet ETH on zkSync Sepolia testnet.
+
+To complete this tutorial we’ll use either Atlas or Remix. Select your preferred tool:
+
+::content-switcher
+---
+items: [{
+ label: 'Atlas',
+ partial: '_erc20_tutorial/_atlas_erc20_tutorial'
+}, {
+ label: 'Remix',
+ partial: '_erc20_tutorial/_remix_erc20_tutorial'
+}]
+---
+::
+
+## Takeaways
+
+- **zkSync is EVM compatible** and supports existing smart contract libraries like OpenZeppelin
+- **Use popular libraries like** `ethers` , `viem`, or `web3.js` to interact with smart contracts deployed on zkSync.
+
+## Next steps
+
+- Join the zkSync developer community in Discord where you can ask any questions about this tutorial in the #dev-101 channel
+- Continue learning by deploying an ERC20 token to zkSync Era.
+- Join our GitHub Discussions community to help other devs building on zkSync or share your project.
diff --git a/content/10.zksync-101/_erc20_tutorial/_atlas_erc20_tutorial.md b/content/10.zksync-101/_erc20_tutorial/_atlas_erc20_tutorial.md
new file mode 100644
index 00000000..50f2bb9c
--- /dev/null
+++ b/content/10.zksync-101/_erc20_tutorial/_atlas_erc20_tutorial.md
@@ -0,0 +1,114 @@
+---
+title: ERC20 token with Atlas
+---
+## Custom ERC20 token code
+
+ERC20 tokens are a standard for fungible tokens, which can be traded and represent a fixed value. You’ve used ERC20 tokens if you’ve transacted with USDC, DAI, USDT, LINK or UNI.
+
+The ERC20 token we’re going to deploy will allow users to mint and burn tokens. The entire smart contract code is as follows:
+
+```solidity
+// SPDX-License-Identifier: Unlicensed
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+
+contract TestToken is ERC20, Ownable, ERC20Burnable {
+ constructor(string memory name, string memory symbol) ERC20(name, symbol) {
+ _mint(msg.sender, 100 * 10 ** decimals());
+ }
+
+ function mint(address to, uint256 amount) public onlyOwner {
+ _mint(to, amount);
+ }
+}
+```
+
+::callout{icon="i-heroicons-light-bulb"}
+zkSync is EVM compatible, so you can use existing popular libraries like OpenZeppelin.
+::
+
+The most important features are:
+
+- `Ownable` : this extension sets the deployer account as owner of the smart contract. It also introduces the `onlyOwner` modifier that restricts the execution of certain functions to the owner of the contract.
+- `ERC20Burnable`: this extension adds the `burn` and `burnFrom` functions to the smart contract. These functions destroy tokens from a given account.
+- `constructor`: called on deployment, the constructor will assign the given name and symbol to the token and mint 100 units of it to the account that deployed the contract.
+- `mint` : this function creates new token units to a given account. It uses the `onlyOwner` modifier so it can only be called from the owner account.
+
+## Deploy the smart contract
+
+Atlas is a browser-based IDE with an integrated AI assistant that allows you to write, test and deploy smart contracts directly from your browser. Click the button below to open the project in Atlas.
+
+Open in Atlas
+
+You can see the contract in the Atlas code editor. On the right side, make sure the selected network is “zkSync Sepolia tesnet“ and click on “Deploy” to trigger the smart contract compilation and deployment.
+
+::callout{icon="i-heroicons-light-bulb"}
+Behind the scenes, Atlas is using the zkSync Era custom solidity compiler (named `zksolc` ) to generate ZKEVM compatible bytecode. [Learn more about zkSync custom compilers]().
+::
+
+Once compiled sign the transaction with your wallet and wait until its processed. You’ll see the contract in the “Deployed contracts” section.
+
+## Interact with the ERC20 contract
+
+In the `scripts` folder you can find the `interact.ts` script containing the following code:
+
+```tsx
+import { AtlasEnvironment } from "atlas-ide";
+import TokenArtifact from "../artifacts/MyToken";
+import * as ethers from "ethers";
+
+// Address of the ERC20 token contract
+const TOKEN_CONTRACT_ADDRESS = ""
+// Wallet that will receive tokens
+const RECEIVER_WALLET = "";
+// Amount of tokens to mint in ETH format, e.g. 1.23
+const TOKEN_AMOUNT = "";
+
+export async function main (atlas: AtlasEnvironment) {
+ const provider = new ethers.providers.Web3Provider(atlas.provider);
+ const wallet = provider.getSigner();
+
+ // initialise token contract with address, abi and signer
+ const tokenContract= new ethers.Contract(TOKEN_CONTRACT_ADDRESS, TokenArtifact.MyToken.abi, wallet);
+
+ console.log("Minting tokens...");
+ const tx = await tokenContract.mint(RECEIVER_WALLET, ethers.utils.parseEther(TOKEN_AMOUNT));
+ await tx.wait();
+
+
+ console.log("Success!");
+ console.log(`The account ${RECEIVER_WALLET} now has ${await tokenContract.balanceOf(RECEIVER_WALLET)} tokens`)
+
+}
+```
+
+This scripts uses `ethers` to interact with the contract we’ve just deployed.
+
+::callout{icon="i-heroicons-light-bulb"}
+Existing libraries like `ethers` , `viem` and `web3.js` can be used to interact with smart contracts deployed on zkSync.
+::
+
+Fill the following variables:
+
+- `TOKEN_CONTRACT_ADDRESS`: the contract address of the ERC20 token we just deployed.
+- `RECEIVER_WALLET`: address of a different account that will receive new tokens.
+- `TOKEN_AMOUNT`: the amount of tokens we’ll send to the account.
+
+With the `interact.ts` file open in the Atlas editor, click on the “Deploy” button to run the script and see the output in the terminal.
+
+
+
+To confirm the account has received the tokens, visit the zkSync Sepolia explorer and search the receiver wallet address. You’ll see the new token balance in the assets table:
+
+
diff --git a/content/10.zksync-101/_erc20_tutorial/_remix_erc20_tutorial.md b/content/10.zksync-101/_erc20_tutorial/_remix_erc20_tutorial.md
new file mode 100644
index 00000000..4c5e4313
--- /dev/null
+++ b/content/10.zksync-101/_erc20_tutorial/_remix_erc20_tutorial.md
@@ -0,0 +1,139 @@
+---
+title: ERC20 with Remix
+---
+## Custom ERC20 token code
+
+ERC20 tokens are a standard for fungible tokens, which can be traded and represent a fixed value. You’ve used ERC20 tokens if you’ve transacted with USDC, DAI, USDT, LINK or UNI.
+
+The ERC20 token we’re going to deploy will allow users to mint and burn tokens. The entire smart contract code is as follows:
+
+```solidity
+// SPDX-License-Identifier: Unlicensed
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+
+contract TestToken is ERC20, Ownable, ERC20Burnable {
+ constructor(string memory name, string memory symbol)
+ ERC20(name, symbol) Ownable(msg.sender) {
+ _mint(msg.sender, 100 * 10 ** decimals());
+ }
+
+ function mint(address to, uint256 amount) public onlyOwner {
+ _mint(to, amount);
+ }
+}
+```
+
+::callout{icon="i-heroicons-light-bulb"}
+zkSync is EVM compatible, so you can use existing popular libraries like OpenZeppelin.
+::
+
+The most important features are:
+
+- `Ownable` : this extension sets the deployer account as owner of the smart contract. It also introduces the `onlyOwner` modifier that restricts the execution of certain functions to the owner of the contract.
+- `ERC20Burnable`: this extension adds the `burn` and `burnFrom` functions to the smart contract. These functions destroy tokens from a given account.
+- `constructor`: called on deployment, the constructor will assign the given name and symbol to the token and mint 100 units of it to the account that deployed the contract.
+- `mint` : this function creates new token units to a given account. It uses the `onlyOwner` modifier so it can only be called from the owner account.
+
+## Deploy the smart contract
+
+The Remix IDE is an open-source web and desktop application that supports Ethereum smart contract development and deployment, offering tools for writing, testing, debugging, and deploying smart contracts written in Solidity to EVM compatible protocols.
+
+Click the button below to open the project in Remix.
+
+Open in Remix
+
+:display-partial{partial = "Enable the zkSync plugin in Remix"}
+
+You can see the contract in the Remix code editor.
+
+To compile the contract, click on Compile TestToken.sol. If you get a popup message requesting permissions to access **`ACCESS TO "WRITEFILE" OF "FILE MANAGER"`,** click on Accept.
+
+::callout{icon="i-heroicons-light-bulb"}
+Behind the scenes, Remix is using the zkSync Era custom solidity compiler (named `zksolc` ) to generate ZKEVM compatible bytecode. [Learn more about zkSync custom compilers]().
+::
+
+We will use our wallet’s configured network to connect and deploy our smart contract so make sure your wallet is currently connected to the zkSync Sepolia testnet. In Remix, under the Environment Section, select “Wallet” and click on “Connect Wallet”.
+
+To deploy the contract, click on “Deploy” and sign the transaction on your wallet. Congratulations, your ERC20 token contract is now deployed on zkSync Sepolia testnet!
+
+## Interact with the ERC20 contract
+
+In the `scripts` folder you can find the `interact.ts` script containing the following code:
+
+```tsx
+import {ethers} from "ethers";
+
+// Address of the ERC20 token contract
+const TOKEN_CONTRACT_ADDRESS = "0x68a0B41320cD6489A661523bBd7093cE5c918039"
+// Wallet that will receive tokens
+const RECEIVER_WALLET = "0x46C61CCb7dA11C1285B32Ef7168503AD7c5BFfb2";
+// Amount of tokens to mint in ETH format, e.g. 1.23
+const TOKEN_AMOUNT = "123.55";
+
+(async () => {
+ try {
+
+// Note that the script needs the ABI which is generated from the compilation artifact.
+ // Make sure contract is compiled and artifacts are generated
+ const artifactsPath = `browser/contracts/artifacts/TestToken.json` // Change this for different path
+ console.log(artifactsPath)
+
+ const metadata = JSON.parse(await remix.call('fileManager', 'getFile', artifactsPath))
+ // 'web3Provider' is a remix global variable object
+// console.log(metadata)
+
+ const signer = (new ethers.providers.Web3Provider(web3Provider)).getSigner(0)
+
+ // initialise token contract with address, abi and signer
+ const tokenContract= new ethers.Contract(TOKEN_CONTRACT_ADDRESS, metadata.abi, signer);
+
+ console.log("Minting tokens...");
+ const tx = await tokenContract.mint(RECEIVER_WALLET, ethers.utils.parseEther(TOKEN_AMOUNT));
+ console.log(`Mint transaction is ${tx.hash}`)
+ await tx.wait();
+ console.log("Success!");
+
+ const balance = await tokenContract.balanceOf(RECEIVER_WALLET)
+ console.log(balance)
+
+
+ console.log(`The account ${RECEIVER_WALLET} now has ${balance} tokens`)
+
+ } catch (e) {
+ console.log(e.message)
+ }
+})()
+
+```
+
+This scripts uses `ethers` to interact with the contract we’ve just deployed.
+
+::callout{icon="i-heroicons-light-bulb"}
+Existing libraries like `ethers` , `viem` and `web3.js` can be used to interact with smart contracts deployed on zkSync.
+::
+
+Fill the following variables:
+
+- `TOKEN_CONTRACT_ADDRESS`: the contract address of the ERC20 token we just deployed.
+- `RECEIVER_WALLET`: address of a different account that will receive new tokens.
+- `TOKEN_AMOUNT`: the amount of tokens we’ll send to the account.
+
+With the `interact.ts` file open in the editor, click on the “▶️” button to run the script and see the output in the terminal.
+
+
+
+To confirm the account has received the tokens, visit the zkSync Sepolia explorer and search the receiver wallet address. You’ll see the new token balance in the assets table:
+
+
diff --git a/content/10.zksync-101/_quickstart/_atlas_deploy_contract.md b/content/10.zksync-101/_quickstart/_atlas_deploy_contract.md
new file mode 100644
index 00000000..5c098e4e
--- /dev/null
+++ b/content/10.zksync-101/_quickstart/_atlas_deploy_contract.md
@@ -0,0 +1,30 @@
+---
+title: Quickstart with Atlas
+---
+Atlas is a browser-based IDE with an integrated AI assistant that allows you to write, test and deploy smart contracts directly from your browser. Click the button below to open the project in Atlas.
+
+Open in Atlas
+
+You can see the contract in the Atlas code editor. On the right side, make sure the selected network is “zkSync Sepolia tesnet“ and click on “Deploy” to trigger the smart contract compilation and deployment.
+
+::callout{icon="i-heroicons-light-bulb"}
+Behind the scenes, Remix is using the zkSync Era custom solidity compiler (named `zksolc` ) to generate ZKEVM compatible bytecode. [Learn more about zkSync custom compilers]().
+::
+
+Once compiled sign the transaction with your wallet and wait until its processed. You’ll see the contract in the “Deployed contracts” section. Congratulations, you’ve deployed your first smart contract to zkSync Era testnet!
+
+
+
+Below the contract name you can find its deployment address. The “Live Contract State” section displays the smart contract balance and the value returned by the `getTotalMessages` function.
+
+
+
+The “Write Functions” section contains the form to interact with the `sendMessage` function. Write a message, click the “Run” button and confirm the transaction in your wallet. You’ll see that the `getTotalMessages` is updated to `1`. That means our contract is storing the messages as expected! But how can we see the replies from Zeek?
diff --git a/content/10.zksync-101/_quickstart/_remix_deploy_contract.md b/content/10.zksync-101/_quickstart/_remix_deploy_contract.md
new file mode 100644
index 00000000..ab8ca0b1
--- /dev/null
+++ b/content/10.zksync-101/_quickstart/_remix_deploy_contract.md
@@ -0,0 +1,37 @@
+---
+title: Quickstart with Remix
+---
+
+The Remix IDE is an open-source web and desktop application that supports Ethereum smart contract development and deployment, offering tools for writing, testing, debugging, and deploying smart contracts written in Solidity to EVM compatible protocols.
+
+Click the button below to open the project in Remix.
+
+Open in Remix
+
+You can see the contract in the Remix code editor.
+
+:display-partial{partial = "Enable the zkSync plugin in Remix"}
+
+To compile the contract, click on Compile ZeeksSecretMessages.sol. If you get a popup message requesting permissions to access **`ACCESS TO "WRITEFILE" OF "FILE MANAGER"`,** click on Accept.
+
+::callout{icon="i-heroicons-light-bulb"}
+Behind the scenes, Remix is using the zkSync Era custom solidity compiler (named `zksolc` ) to generate ZKEVM compatible bytecode. [Learn more about zkSync custom compilers]().
+::
+
+We will use our wallet’s configured network to connect and deploy our smart contract so make sure your wallet is currently connected to the zkSync Sepolia testnet. In Remix, under the Environment Section, select “Wallet” and click on “Connect Wallet”.
+
+To deploy the contract, click on “Deploy” and sign the transaction on your wallet. Congratulations, you’ve deployed your first contract to zkSync Era testnet!
+
+Below the contract name you can find the address where the contract is deployed. The “Interact” section displays the forms to interact with the `getTotalMessages` and `sendMessage` functions.
+
+
+
+Write a message in the form, click the “sendMessage” button and confirm the transaction in your wallet. Once processed, click the `getTotalMessages` and check the response in the terminal, which should be `1`. That means our contract is storing the messages as expected! But how can we see the replies from Zeek?
diff --git a/content/_partials/enable-remix-zksync-plugin.md b/content/_partials/enable-remix-zksync-plugin.md
new file mode 100644
index 00000000..08c57d15
--- /dev/null
+++ b/content/_partials/enable-remix-zksync-plugin.md
@@ -0,0 +1,8 @@
+---
+title: Enable the zkSync plugin in Remix
+---
+To deploy smart contracts to zkSync via Remix we need to enable the zkSync plugin. Click on the “Plugin Manager” button in the left bottom corner, search “zksync” and click on the Activate button.
+
+
+
+Once activated, you’ll see a new menu item with the zkSync logo, click on it to see the different options to compile and deploy the contract to zkSync.
diff --git a/public/images/metamask_logo.svg b/public/images/metamask_logo.svg
new file mode 100644
index 00000000..faee2007
--- /dev/null
+++ b/public/images/metamask_logo.svg
@@ -0,0 +1,62 @@
+
+
+
+ Add {{ chainName }}
+