In Part 8, you explored how Ethereum reaches consensus using a Proof of Stake model, and how the interaction of Validators, slots, epochs and finality secure the Ethereum network.

But here’s the big question:

If Ethereum is secure and decentralised, why are there times when the network feels slow and expensive?

The answer to this question can be found in the concept of scalability and that’s where Layer 2 solutions come in.

By the end of this guide, you’ll understand:

• Why Ethereum Needs Layer 2 Scaling?

• What L2 Actually Means ?

• How Rollups Work the Differences Between Optimistic and ZK Rollups?

• How Ethereum and Layer 2s Work Together As One System ?

• Why Ethereum Needs Scaling?
  

Why Ethereum Needs Scaling

The Ethereum Network has a focus on the following:

• Security

• Decentralization

However, this focus on security and decentralisation means that:

• The number of transactions processed on the Ethereum network each second is limited.
  

• As traffic increases, the amount of gas paid per transaction will also increase.
  

This is referred to as the Blockchain Trilemma, which means that a network on a single layer cannot be at its most secure, decentralised, and scalable all at the same time.

Due to this issue, the Ethereum Ecosystem worked to create a better solution to scaling Ethereum without destroying the foundation of Ethereum.

What Is Layer 2?

Layer 2 (L2) is a separate system on top of the Ethereum Network which:

• Executes transactions off-chain

• Uses Ethereum Layer 1 as the source of truth for the commitment to security and the settlement of final balances

In Part 7, you explored how Ethereum keeps and modifies data through accounts, transactions, and state.Now, let’s uncover how the entire network agrees on those updates — without a central authority.

By the end of this guide, you’ll know:

• What the Consensus Layer is and how it differs from the Execution Layer

• How Proof of Stake replaced Proof of Work

• The roles of validators, slots, and epochs

• What happens during block proposals, attestations, and finalization

• How fork choice and finality keep Ethereum secure

Ethereum’s Two Layers

Ethereum operates through two tightly linked layers:

• Execution Layer (EL): The EVM, transactions, and state changes

• Consensus Layer (CL): Coordination and agreement on which state is valid

Together, these form the post-Merge architecture of modern Ethereum (2022).

Proof of Stake — The Heart of Modern Ethereum

• Before 2022, Ethereum used Proof of Work (PoW).

• In PoW, miners solved complex puzzles using powerful computers.

• The first miner to solve the puzzle added a new block and earned rewards.

• This method consumed a lot of electricity and energy.

• After the Merge, Ethereum switched to Proof of Stake (PoS).

• In PoS, there are no miners — only validators.

• Validators must stake 32 ETH to take part in securing the network.

• They are chosen randomly to create and confirm blocks.

• If they act dishonestly, they can lose part or all of their staked ETH.

• In short:

  • PoW = Energy + Machines

  • PoS = Money + Honesty

• PoS makes Ethereum faster, cheaper, and more energy-efficient.

Validators, Slots & Epochs

Ethereum divides time into fixed intervals:

• Slot = 12 seconds

• Epoch = 32 slots ≈ 6.4 minutes

Each slot designates one validator to propose a block.The remaining validators attest (vote) on the block’s validity.

The Life Cycle of a Block

1. Propose — A validator creates a new block.

2. Broadcast — The block spreads across the network.

3. Attest — Validators vote on its validity.

4. Include — Attestations appear in subsequent blocks.

5. Finalize — After two epochs, the block becomes immutable.

“Once finalized, a block is set in stone — rewriting it would require rewriting history.”

Fork Choice Rule

Ethereum’s fork-choice algorithm is called LMD GHOST(Latest Message Driven Greediest Heaviest Observed SubTree).

“If two versions of the chain exist, validators stick with the one containing the most attestations — the heaviest chain.”

Finality and Checkpoints

Each epoch has a checkpoint block.When two consecutive checkpoints are justified and finalized, finality is achieved.

✅ Once finalized, a block cannot be reverted unless one-third of all validators are slashed — an extremely costly event.

Rewards, Penalties & Slashing

The system maintains honesty through incentives:

• Rewards: For proposing and attesting correctly

• Penalties: For downtime or missed attestations

• Slashing: For double-signing or contradicting votes

“Imagine staking like being a referee — you win if you play square, but forfeit your deposit if you cheat.”

Putting It All Together

Execution Layer (EVM) ↔ Consensus Layer (Validators) → Finalized State.

Summary

You now know:

• How Proof of Stake drives Ethereum’s consensus

• What validators, slots, and epochs do

• How attestations and finality keep the chain secure

• Why PoS is energy-efficient and economically sound

In the next part (Part 9), we’ll explore Layer 2 scaling — how rollups and sidechains boost Ethereum’s speed without sacrificing security. ⚡

Welcome back to Web3 Developer Docs!

In Part 6, you learned about the Ethereum Virtual Machine (EVM) — the "world computer" that runs each smart contract deterministically.

Now, we'll go one step further and observe what the EVM actually runs on: accounts, transactions, and state.

By the end of this guide, you'll know:

• How Ethereum stores and keeps track of data

• The two kinds of accounts: user and contract

• How transactions cause state changes

• How the EVM keeps it all in sync across the network

Let's peel back the data model that makes Ethereum tick. ⚙️

Ethereum as a State Machine

Ethereum isn't merely a transaction ledger — it's a state machine.

A block is a global state of the Ethereum universe, and a new transaction converts that state into a new state.

Mathematically:

State(n+1) = StateTransition(State(n), Transaction)

That is:

• The blockchain's "memory" advances step by step.

• Each node in the network executes the same transactions → arrives at the same state.

Account Types

There are two types of accounts on Ethereum:

Type Description Controlled By:

• Externally Owned Account (EOA)

• Regular user accountPrivate key

  The two account types have the same internal structure.

Account Structure

Every Ethereum account holds:

• nonce: Number of transactions sent (EOA) or contracts deployed (Contract)

• balance: Balance of ETH (in wei)

• storageRoot: Hash of the contract's storage data

• codeHash: Hash of the contract’s bytecode (empty for EOAs)

This data forms part of the global state trie (a cryptographic tree we’ll discuss later).

What is a Transaction?

A transaction is a signed message from an EOA that tells the EVM to do something:

• Transfer ETH

• Deploy a contract

• Execute a smart contract function

Each transaction changes Ethereum’s state.

Transaction Fields

A standard Ethereum transaction includes:

Field Description

• nonce - Sequential number to prevent replay

• gasPrice - ETH paid per unit of gas

• gasLimit - Maximum gas the sender will pay to spend

• to - Recipient address (or empty for contract creation)

• value - Value of ETH sent (in wei)

• data - Encoded function call or bytecode

• v, r, s - Digital signature pieces

Example (Simplified)

{
  "nonce": 1,
  "gasPrice": "20000000000",
  "gasLimit": "21000",
  "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
  "value": "1000000000000000000",
  "data": "0x",
  "v": "0x25",
  "r": "0x1c5.",
  "s": "0x4a7."
}

On broadcasting, validators run this transaction through the EVM and store the resultant new state.

Lifecycle of a Transaction

1. Creation: The user signs a transaction locally with their private key.

2. Broadcast: The transaction is broadcasted to the mempool of the network.

3. Validation: Validators verify signature, nonce, and gas.

4. Execution: The EVM executes the transaction — updating balances, storage, or deploying contracts.

5. Inclusion: The transaction is included in a block and becomes part of Ethereum's permanent state.

Gas and Costs of Execution

Each EVM operation (opcode) burns gas.

• Gas Limit prevents infinite loops or spam.

• Gas Price encourages validators to include your transaction.

When execution drains its gas, the EVM reverts the state — but spent gas is still incurred.

💡 Tip: You can calculate gas usage with libraries like Ethers.js:

const gasEstimate = await contract.estimateGas.transfer(recipient, amount);

The Global State Trie

Ethereum stores its global state in a Merkle Patricia Trie (MPT) — a cryptographic data structure that allows the blockchain to be verifiable.

• Every node within the trie corresponds to an account.

• The root hash of this trie is contained in every block header (stateRoot).

• Any minor alteration in an account updates the root, assuring integrity.

This implies any Ethereum node has the ability to check the state of the entire blockchain based solely on the root hash.

Example: Transaction Modifying State

Consider an example where a contract modifies its internal variable.

Solidity

// Counter.sol
pragma solidity ^0.8.0;

contract Counter {
    uint256 public count;

    function increment() public {
        count = count + 1;
    }
}

Ethers.js Interaction

const contract = new ethers.Contract(address, abi, signer);
const tx = await contract.increment();
await tx.wait();

Result:

• EVM calls increment()

• Updates count in contract storage

• Creates a new global state root

Determinism and Consensus

Ethereum's architecture provides deterministic execution — with the same state and transactions, all nodes calculate the same output.

This achieves:

• Global consensus

• Trustless verification

• Immutable state transitions

No central authority determines the "truth" — the network as a whole agrees on it.

Summary

You now know:

• How Ethereum encodes data in terms of accounts and state

• How transactions are instructions to change that state

• How gas provides fairness and security

• How the Merkle Trie makes global consensus verifiable

In the next part, we’ll dive into Ethereum’s Consensus Layer — where validators, staking, and blocks come together to maintain this trustless global state. ⚙️

As someone already familiar with Web3, I’ve interacted with several blockchains before Ethereum .But this week’s challenge was something new: exploring Monad, a next-generation Layer-1 chain built for speed and scalability.

Here’s how I got my hands dirty testing it out on the Monad Testnet

Step 1: Setting Up My Wallet

I already use MetaMask as my primary wallet, so setup was easy.All I had to do was switch my existing wallet to the Monad Testnet using the provided configuration.

It was quick, simple, and smooth — exactly what you’d expect from a high-performance blockchain. No complicated steps, no lag — just a seamless transition into a new ecosystem.

Step 2: Collecting Faucet Tokens & Making My First Monad Transaction

After switching to the Monad Testnet, the next step was to get some test tokens to start experimenting.

Instead of using the usual faucet, I followed the Monad101 faucet process.I opened the faucet link, entered my email ID, and received a one-time password (OTP) for verification.Once I verified my email, I entered my MetaMask wallet address, clicked Claim, and successfully received 10 MON tokens in my wallet.

Once the tokens arrived, I decided to try a transaction.I entered a receiver wallet address, set the amount, and clicked **“Confirm.”**The transaction was processed instantly — and when I checked it on the Monad Explorer, all the details were there: the sender, receiver, transaction hash, gas fee, and confirmation count.

Step 3: Exploring My Transaction on Monad Explorer

After clicking “Confirm” in MetaMask, my transaction was instantly processed and verified on the Monad network.

I opened the Monad Explorer to view the complete transaction details — it clearly displayed everything I needed to understand what happened on-chain:

• Transaction Hash

• Block

• Confirmations

• Status

• Timestamp

• From

• To

• Value

• Transaction Fee

• Gas Limit

• Gas Used

The explorer interface made it super easy to analyze the transaction flow.It showed how my 5 MON were transferred, confirmed within seconds, and recorded permanently on-chain.

I also checked my account view on Monad Explorer — where my remaining balance (4.99789 MON) was displayed along with the current token value.

Seeing the transaction details live on the blockchain felt like watching transparency in action — everything was traceable, verifiable, and fast ⚡

What I Learned About Monad

• Monad focuses on parallel execution, allowing multiple transactions to run at once.

• Its testnet already feels lightning fast and highly efficient.

• The developer tools (Monorail + Explorer) make experimentation smooth.

• Transparency remains a core principle — anyone can verify any transaction instantly.

• It’s clear Monad is building toward scalability without sacrificing decentralization.

Final Thoughts

Exploring Monad reminded me how quickly the Web3 ecosystem evolves.Each new blockchain brings its own flavor of innovation — and Monad’s emphasis on speed, scalability, and dev-friendliness definitely makes it one to watch.

This first interaction on the testnet gave me a hands-on sense of how efficient next-gen Layer-1s can really be.Excited to see how Monad shapes the future of blockchain performance!

Each Web3 developer comes to this realization eventually — that all the activity going on on Ethereum, from token sends to NFT mints, is driven by a single invisible engine: the Ethereum Virtual Machine (EVM).

If the Ethereum blockchain is the body, the EVM is the brain — running every smart contract, enforcing every rule, and keeping global consensus.

By the end of this section, you'll know:

• What the EVM is and why it's the "world computer"

• How it runs smart contracts safely

• Why EVM compatibility drives the whole multichain universe

Let’s uncover the magic of Ethereum's core ⚙️

What Is the Ethereum Virtual Machine (EVM)?

The EVM (Ethereum Virtual Machine) is the runtime environment upon which all Ethereum smart contracts reside and run.

Conceptualize it as a shared computer that is present in hundreds of thousands of Ethereum nodes — each transaction, each function call, and each dApp activity runs within the EVM.

Each node hosts a replica of the EVM, so regardless of where or whom it is run by, the outcome is the same and can be verified throughout the network.

In a nutshell:

The EVM guarantees trustless execution — code executes precisely as it was written, without being tampered with or controlled centrally.

How the EVM Runs Smart Contracts

When you deploy a smart contract on the Ethereum network, what you're really uploading is compiled bytecode — a low-level representation of your Solidity code that the EVM speaks.

Here's the process step by step:

1. Write the code → In Solidity or Vyper

2. Compile it → Translates into EVM bytecode

3. Deploy → The bytecode is stored on the blockchain

4. Execute → Each call to a function initiates EVM execution

The EVM employs an internal stack-based structure — akin to a small computer that executes instructions referred to as opcodes (such as ADD, MUL, CALL).

Each operation incurs gas, so no one can clog the network with infinite loops or intensive maths.

Gas: The Fuel of the EVM

Each instruction within the EVM incurs gas — a modest payment in ETH.

Gas does two things:

• Security: Stops infinite loops or spamming attacks

• Efficiency: Penalizes bloated code and impartial network usage

When you're submitting a transaction, you set:

• Gas Limit → Maximum units of gas you're willing to expend

• Gas Price → Amount of ETH you pay per unit of gas

If your transaction depletes all its gas, it gets rejected — but you still get charged for the computation consumed so far.

So, gas isn't merely a charge — it's the EVM's rhythm.

Why EVM Compatibility Is Important

The EVM eventually became the gold standard for executing smart contracts.That's why new blockchains such as Polygon, Avalanche, BNB Chain, and Base all established EVM-compatible platforms.

What that means:

• You can deploy the same Solidity code on several chains

• Wallets such as MetaMask work perfectly everywhere

• Developers reuse tools such as Hardhat, Remix, and Truffle

That is, EVM compatibility = immediate ecosystem adoption.

EVM Opcodes and Determinism

Fundamentally, the EVM operates using opcodes — plain instructions that perform actions such as adding numbers, storing values, or transferring ETH.

Due to the determinism of the EVM, the same input always gives the same output regardless of where it's run.

That's how Ethereum can be trustless — no single authority is determining what happens.

Code is law.

Why the EVM Is the "World Computer"

As opposed to a single device, the EVM exists concurrently at **thousands of nodes.**Every node authenticates and runs the same code, keeping the blockchain in perfect harmony.

It's akin to having a worldwide computer running the same application — securely, openly, and without interruption.

This distributed model of computation is the reason Ethereum is so revolutionary.

Conclusion

Every Web3 developer wants to understand what truly powers Ethereum’s smart contract magic — and it all starts here, inside the EVM.

In this part, you’ve learned:

• What the EVM is and why it’s the “world computer”

• How it executes smart contracts deterministically

• Why gas fuels and secures the entire process

• How EVM compatibility unites the multichain ecosystem

You now understand the beating heart of Ethereum — the machine that turns code into trustless action.

Welcome to the next step of your Ethereum experience — from understanding how it works to making it work for you. ⚙️🚀

Every Web3 developer eventually reaches this point - where you realize everything on Ethereum runs on tokens.

From stablecoins to NFTs, governance tokens to game assets - they all follow a shared set of rules called ERC standards.

Now, we’re ready to go deeper into the foundation of Ethereum’s token ecosystem - ERC tokens.

By the end of this part, you’ll know:

• What ERC means and why it exists

• The difference between ERC-20, ERC-721, and ERC-1155

• How these standards power almost every token in Web3

Let’s dive in 👇

What Does “ERC” Mean?

ERC stands for Ethereum Request for Comment.

It’s like a proposal or blueprint that defines how a specific kind of smart contract should behave. Think of it as a rulebook that ensures every wallet, exchange, and dApp can understand and interact with tokens the same way.

When developers agree on an ERC standard - such as ERC-20 or ERC-721 - it becomes part of Ethereum’s shared language for digital assets.

Without these standards, every token would behave differently - breaking interoperability across wallets and dApps.

ERC-20 -The Foundation of Fungible Tokens

The ERC-20 standard defines fungible tokens — meaning each token is exactly the same as another.

Just like every rupee or ETH coin is identical in value, ERC-20 tokens are interchangeable.

They are used for:

• Cryptocurrencies (DAI, USDT, UNI, etc.)

• DeFi tokens (governance, staking rewards)

• Utility tokens (access, payments, or rewards)

Core Functions:

• balanceOf(address) → Get a wallet’s balance

• transfer(address, amount) → Send tokens to another wallet

• approve() + transferFrom() → Allow another address (like a contract) to spend tokens

These functions make ERC-20 tokens the building blocks of DeFi and Web3 applications.

ERC-721 - The Birth of NFTs

The ERC-721 standard introduced non-fungible tokens - assets that are unique.Each ERC-721 token has a one-of-a-kind tokenId and metadata, often linked to art, collectibles, or identity.

Used for:

• Digital art and collectibles

• Game items and skins

• Proof of ownership and authenticity

Unlike ERC-20 tokens, no two ERC-721 tokens are alike. Owning one represents something truly yours on the blockchain.

ERC-1155 — The Hybrid Standard

The ERC-1155 standard is like the Swiss Army knife of tokens - it allows multiple types of assets (both fungible and non-fungible) to exist in a single contract.

Used for:

• Gaming ecosystems

• Multi-asset collections

• Batch transfers and efficient storage

With ERC-1155, a single smart contract can manage game coins, items, and collectibles - all together.

Why ERC Standards Matter

ERC standards are the reason Ethereum works as a unified ecosystem.

• Interoperability: Every wallet and dApp knows how to read and interact with tokens.

• Security: Developers reuse tested standards instead of writing risky custom logic.

• Composability: Tokens can easily plug into DeFi, games, or marketplaces.

In short - ERCs are the common language that keeps Web3 connected and functional.

Conclusion

Every Web3 developer wants to understand what truly powers the Ethereum ecosystem — and it all starts here, with ERC tokens.

In this part, you’ve learned:

• What ERC means and why Ethereum uses standards

• The key differences between ERC-20, ERC-721, and ERC-1155

• How tokens follow shared rules that make wallets and dApps interoperable

• Why ERCs are the backbone of digital assets and interoperability in Web3

You now understand the universal language of Ethereum - the foundation behind every coin, NFT, and tokenized asset.

👉In the next part, we’ll take this knowledge into action - you’ll write and deploy your own ERC-20 token on the Ethereum testnet, view it inside MetaMask, and experience your first real token deployment.

Welcome to the next level of your Web3 journey - where you go from understanding tokens to creating your own.🚀

Welcome back to the Web3 Developer Docs! ✨

In Part 3, you built your first frontend dApp using HTML, TailwindCSS, and Ethers.js to connect MetaMask and interact with a deployed smart contract. 🚀

In this part, we’ll take a closer look under the hood. You’ll understand every single line of code we wrote:

🔎 What the HTML structure does

🔎 How Ethers.js works in the background

🔎 How wallet connection, transaction sending, and contract calls are actually happening

By the end of this guide, you’ll not only know how to build, but also why each part works.

Breaking Down index.html

Our HTML file is the structure of the dApp. Let’s review the key parts:

1️⃣ Page Layout with TailwindCSS

<body class="bg-gray-100 flex items-center justify-center min-h-screen">
  <div class="bg-white shadow-lg rounded-2xl p-8 w-full max-w-md text-center">
    <h1 class="text-2xl font-bold mb-6">🔒 Simple Storage</h1>

• bg-gray-100 flex items-center justify-center min-h-screen: centers the app on screen.

• shadow-lg rounded-2xl p-8: creates a card-like UI for the dApp.

• This layout is where all UI elements (buttons, input, stored number) live.

2️⃣ Stored Number Display

<div class="text-5xl font-mono text-gray-900 mb-2" id="storedNumber">--</div>
<p class="text-gray-500 text-sm mb-6">Stored Number</p>

• id="storedNumber" → we’ll later use JavaScript to update this dynamically with the blockchain value.

• Initially shows -- until a value is fetched.

3️⃣ Input + Buttons

<input type="number" id="inputNumber" placeholder="Enter a number" ... />
<button onclick="setNumber()">Store Number</button>
<button onclick="getNumber()">Get Stored Number</button>
<button id="walletButton" onclick="toggleWallet()">Connect Wallet</button>

• inputNumber → user types a number.

• Store Number → calls contract.setNumber().

• Get Stored Number → calls contract.getNumber().

• Connect Wallet → links MetaMask to our dApp.

4️⃣ Loading Ethers.js

<script src="https://cdn.ethers.io/lib/ethers-5.7.2.umd.min.js"></script>
<script src="script.js?v=2"></script>

• Loads Ethers.js library from a CDN.

• Loads our custom script.js (all blockchain logic).

• Without this, the buttons wouldn’t talk to Ethereum.

Breaking Down script.js

Now let’s understand the JavaScript logic:

1️⃣ Contract Details

const contractAddress = "YOUR_CONTRACT_ADDRESS"; 
const contractABI = [ ... ];

• contractAddress: the unique deployed smart contract address from Remix.

• contractABI: describes what functions exist (setNumber, getNumber) and how to call them.

🔑 Without ABI + Address, the dApp wouldn’t know how to talk to the blockchain.

2️⃣ Wallet Connection

async function connectWallet() {
  if (window.ethereum) {
    provider = new ethers.providers.Web3Provider(window.ethereum);
    await provider.send("eth_requestAccounts", []);
    signer = provider.getSigner();
    contract = new ethers.Contract(contractAddress, contractABI, signer);
    alert("Wallet connected ✅");
  } else {
    alert("Please install MetaMask!");
  }
}

• window.ethereum: injected by MetaMask into your browser.

• provider: allows reading blockchain data.

• signer: allows sending transactions (needs your wallet’s signature).

• contract: connects ABI + address → gives us access to functions.

3️⃣ Writing to Blockchain (setNumber)

async function setNumber() {
  const num = document.getElementById('inputNumber').value;
  const tx = await contract.setNumber(num);
  await tx.wait(); 
  getNumber();
}

• Takes user input (num).

• Sends a transaction to setNumber(num).

• await tx.wait(): waits until transaction is confirmed on-chain.

• Calls getNumber() again → refreshes UI.

  This costs gas fees because it changes blockchain state.

4️⃣ Reading from Blockchain (getNumber)

async function getNumber() {
  const value = await contract.getNumber();
  document.getElementById('storedNumber').textContent = value.toString();
}

• Calls getNumber() from the contract.

• Updates UI with the retrieved value.

  Reading is free (no gas), because it doesn’t change the blockchain.

5️⃣ Error Handling

Every function uses try...catch:

try {
  // blockchain action
} catch (error) {
  console.error(error);
  alert("Error: " + error.message);
}

• Prevents app from crashing if MetaMask is not installed, user rejects transaction, or network issues occur.

Conclusion

In this part, you’ve learned:

✅How index.html builds the UI for your dApp

✅How script.js uses Ethers.js to connect wallet, read, and write data

✅Difference between read (free) and write (paid) calls

✅Why ABI, provider, and signer are crucial for blockchain interaction

You now fully understand how your dApp works under the hood ,not just running the code, but knowing exactly what’s happening at each step. This knowledge forms the backbone of becoming a confident Web3 developer. 🚀

Welcome to the world of Ethereum Web3,your journey as a blockchain developer has just begun! 🚀

Welcome back to the Web3 Developer Docs!

In the previous guide, you wrote and deployed your first Ethereum smart contract on a testnet using Remix and MetaMask. 🚀

Now, we’ll take the next step: interacting with your contract using JavaScript libraries (Web3.js / Ethers.js), handling events, and moving closer to building real-world dApps.

By the end of this guide, you’ll be able to:

• Connect your wallet to a dApp using Ethers.js

• Read from and write data to your smart contract

• Build a simple frontend that interacts with Ethereum

• Take your first step toward real-world dApp development

Setting Up Ethers.js

1️⃣ Open VS Code → Create a new project folder (example: ethers-demo).

2️⃣ Initialize npm

npm init -y  //package.json file will appear after you run this command.

3️⃣ Install Ethers.js

npm install ethers //node_modulus and package-lock.json file will appear after you run this command.

4️⃣ Create an index.html file in your project folder. Add basic buttons:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Simple Storage dApp</title>
  <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100 flex items-center justify-center min-h-screen">

  <div class="bg-white shadow-lg rounded-2xl p-8 w-full max-w-md text-center">
    <h1 class="text-2xl font-bold mb-6">🔒 Simple Storage</h1>

    <!-- Display Stored Number -->
    <div class="text-5xl font-mono text-gray-900 mb-2" id="storedNumber">--</div>
    <p class="text-gray-500 text-sm mb-6">Stored Number</p>

    <!-- Input + Set -->
    <input 
      type="number" 
      id="inputNumber" 
      placeholder="Enter a number" 
      class="border rounded-lg px-4 py-2 mb-4 w-full focus:ring-2 focus:ring-blue-500 outline-none"
    />
    <button 
      onclick="setNumber()" 
      class="bg-blue-600 text-white px-4 py-2 rounded-lg w-full hover:bg-blue-700 transition">
      Store Number
    </button>

    <!-- Get Number -->
    <button 
      onclick="getNumber()" 
      class="mt-4 bg-green-600 text-white px-4 py-2 rounded-lg w-full hover:bg-green-700 transition">
      Get Stored Number
    </button>

    <!-- Connect/Disconnect Wallet -->
    <button 
      id="walletButton"
      onclick="toggleWallet()" 
      class="mt-6 bg-gray-800 text-white px-4 py-2 rounded-lg w-full hover:bg-gray-900 transition">
      Connect Wallet
    </button>
  </div>

  <!-- Load ethers.js before our script -->
  <script src="https://cdn.ethers.io/lib/ethers-5.7.2.umd.min.js"></script>
  <script>
    // Debug: Check if ethers is loaded
    console.log("Ethers loaded:", typeof ethers !== 'undefined');
    if (typeof ethers === 'undefined') {
      console.error("Ethers.js failed to load from first CDN, trying alternative...");
      // Try alternative CDN
      const script = document.createElement('script');
      script.src = 'https://unpkg.com/ethers@5.7.2/dist/ethers.umd.min.js';
      script.onload = function() {
        console.log("Ethers loaded from alternative CDN:", typeof ethers !== 'undefined');
      };
      script.onerror = function() {
        console.error("Both CDNs failed to load ethers.js");
        alert("Error: Unable to load Ethers.js library. Please check your internet connection.");
      };
      document.head.appendChild(script);
    } else {
      console.log("Ethers.js loaded successfully!");
    }
  </script>
  <script src="script.js?v=2"></script>
</body>
</html>

5️⃣ Create a script.js file → in the same folder, add your Ethers.js code (for connecting MetaMask, setting a number, and getting a number).

// script.js

// Debug: Check if ethers is available
console.log("Script.js loaded");
console.log("Ethers available:", typeof ethers !== 'undefined');

if (typeof ethers === 'undefined') {
  console.error("Ethers is not defined! Make sure ethers.js is loaded before this script.");
}
// Paste your contract details from Remix
const contractAddress = "YOUR_CONTRACT_ADDRESS"; // Replace with your deployed contract address
const contractABI = [
  {
    "inputs": [{ "internalType": "uint256", "name": "_num", "type": "uint256" }],
    "name": "setNumber",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "getNumber",
    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
    "stateMutability": "view",
    "type": "function"
  }
];

let provider;
let signer;
let contract;

// 1️⃣ Connect MetaMask wallet
async function connectWallet() {
  try {
    if (window.ethereum) {
      // Use ethers v5 syntax
      provider = new ethers.providers.Web3Provider(window.ethereum);
      await provider.send("eth_requestAccounts", []); // request wallet connection
      signer = provider.getSigner();
      contract = new ethers.Contract(contractAddress, contractABI, signer);
      alert("Wallet connected ✅");
      console.log("Wallet connected successfully");
    } else {
      alert("Please install MetaMask!");
    }
  } catch (error) {
    console.error("Error connecting wallet:", error);
    alert("Error connecting wallet: " + error.message);
  }
}

// 2️⃣ Call setNumber function
async function setNumber() {
  try {
    if (!contract) return alert("Connect your wallet first!");
    
    const inputElement = document.getElementById('inputNumber');
    const num = inputElement.value;
    
    if (!num) {
      alert("Please enter a number!");
      return;
    }
    
    console.log("Setting number:", num);
    const tx = await contract.setNumber(num);
    alert("Transaction sent! Waiting for confirmation...");
    await tx.wait(); // wait for confirmation
    alert("Transaction confirmed ✅ Number stored!");
    
    // Clear input and update display
    inputElement.value = '';
    getNumber();
  } catch (error) {
    console.error("Error setting number:", error);
    alert("Error setting number: " + error.message);
  }
}

// 3️⃣ Call getNumber function
async function getNumber() {
  try {
    if (!contract) return alert("Connect your wallet first!");
    
    console.log("Getting stored number...");
    const value = await contract.getNumber();
    const numberStr = value.toString();
    
    // Update the display
    const displayElement = document.getElementById('storedNumber');
    if (displayElement) {
      displayElement.textContent = numberStr;
    }
    
    alert("Stored number: " + numberStr);
    console.log("Stored number:", numberStr);
  } catch (error) {
    console.error("Error getting number:", error);
    alert("Error getting number: " + error.message);
  }
}

6️⃣ Get your Contract Address + ABI from Remix after deployment, and paste them in script.js.

7️⃣ Open index.html in your browser (with MetaMask installed).

• By Clicking Go Live you can see your website.

8️⃣ Click “Connect Wallet” → approve connection in MetaMask.

9️⃣ Try “Set Number” → approve transaction in MetaMask.

🔟 Click “Get Number” → it shows the number stored on-chain.

Wrapping Up

In this part of the Web3 Developer Docs, you’ve learned how to:

✅ Create a simple frontend with HTML + TailwindCSS

✅ Use Ethers.js to connect your MetaMask wallet

✅ Interact with your smart contract by storing and retrieving values

This was your first step in building a frontend that can talk to the Ethereum blockchain. You now have a working dApp where users can connect their wallet, write data, and read data directly from a deployed contract.

👉 In the next part, we’ll go one level deeper ,breaking down the code you just wrote and explaining what each piece does, so you fully understand how the dApp works behind the scenes.

Welcome to the world of Ethereum Web3,your journey as a blockchain developer has just begun! 🚀

Welcome back to the Web3 Developer Docs!

In the previous guide, you set up the foundation learned the prerequisites, enabled a testnet, and created your first Ethereum wallet with MetaMask. 🚀

Now, we’ll take the next big step: actually understanding how Ethereum works under the hood and writing your very first smart contract.

By the end of this guide, you’ll know how to:

• Understand Ethereum fundamentals: what the network is, how it works under the hood, and what it’s used for.

• Write your first Solidity smart contract.

• Deploy it safely on an Ethereum testnet using Remix and MetaMask.

Ethereum Fundamentals

Before writing code, let’s cover some core Ethereum concepts:

• What is the Ethereum network? → A decentralized blockchain for sending transactions, deploying smart contracts, and building DApps.

• How does Ethereum work? → Transactions and smart contracts are processed by nodes/validators, secured with cryptography, and powered by ETH gas fees.

• What is Ethereum used for? → Running DApps, DeFi, NFTs, DAOs, smart contracts, and peer-to-peer value transfer with ETH.

• How to start using Ethereum? → Create a wallet (e.g., MetaMask), connect to the mainnet/testnet, and get ETH for transactions.

👉 Think of Ethereum as a global computer, and gas as the fuel that keeps it running.

Writing Your First Smart Contract (Solidity 101)

We’ll use Remix IDE (browser-based, no setup required) to write a Simple Storage contract.

https://remix.ethereum.org/#lang=en

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public storedNumber;

    // Store a number
    function setNumber(uint256 _num) public {
        storedNumber = _num;
    }

    // Retrieve the stored number
    function getNumber() public view returns (uint256) {
        return storedNumber;
    }
}

Explanation

• storedNumber → A variable saved on-chain.

• setNumber() → Updates the variable.

• getNumber() → Reads the variable.

Deploying to an Ethereum Testnet

Deploying smart contracts on mainnet costs real ETH, so developers use testnets Sepolia with free faucet ETH.

✅ Steps to Deploy:

1️⃣Open Remix IDE.

2️⃣Paste your smart contract code.

3️⃣Compile the contract using the Solidity compiler.

4️⃣Open Deploy & Run Transactions → select Injected Provider (MetaMask).

5️⃣Click Deploy and approve the transaction in MetaMask.

🎉 Your contract is now live on the testnet! You can call:

• setNumber(42) → Store a number.

• getNumber() → Retrieve it back.

In the Deployed Contracts section of Remix, expand Storage to interact:

Wrapping Up

You’ve now taken the next step in your Ethereum Web3 journey:

• Learned the fundamentals: the Ethereum network, how it works, what it’s used for, and how to start using it.

• Written your first Solidity smart contract.

• Deployed it successfully to an Ethereum testnet.

👉 In the next docs, we’ll dive into:

• Interacting with your contract using Web3.js / Ethers.js.

• Understanding events and logs.

• Exploring real-world dApp building.

Welcome to the world of Ethereum Web3,your journey as a blockchain developer has just begun! 🚀

Welcome to the Web3 Developer Docs!

This guide will help you get started with Ethereum and Web3 development.

By the end, you’ll know how to:

• Understand the basics of Web3 & Ethereum

• Set up the necessary tools for development

• Create and configure your first wallet

Web3 is about decentralization instead of relying on centralized servers, we use blockchains (like Ethereum) where data and applications are owned and controlled by users.

Prerequisites

Before you dive in, make sure you’re familiar with the following:

• Basic Programming Knowledge → JavaScript is most common in Web3.

• Web Fundamentals → HTML, CSS, APIs.

• Node.js & npm/yarn → required for running development tools.

• Git & GitHub → version control for your projects.

  Blockchain Basics:

Tools You’ll Need:

• Google Chrome or Brave browser

• Metamask Wallet (browser extension)

• Remix IDE (for writing smart contracts)

• A testnet faucet (to get free ETH for practice, e.g. Sepolia Faucet)

Your Ethereum wallet is your entry point to Web3. We’ll use MetaMask.

Step 1: Install MetaMask

• Go to the Chrome Web Store.

• Search for MetaMask and install the official browser extension.

Step 2: Create a New Wallet

1. Click Get Started → Create a Wallet.

2. Set a strong password.

3. Backup your Secret Recovery Phrase (write it down, never share it).

4. Confirm your recovery phrase in the app.

Step 3: Open MetaMask Settings

• Click your account icon → Go to Settings → Advanced.

Step 4: Show Test Networks

• Toggle Show test networks → ON.

Step 5: Switch to Test Network

• Open MetaMask → Click Networks dropdown.

• Enable Sepolio Test Network.

• Copy your wallet address.

Step 6: Get Test ETH

• Visit https://cloud.google.com/application/web3/faucet/ethereum/sepolia to get faucet .

• Paste your wallet address → Request test ETH.

• Wait for confirmation → You’ll see 0.5ETH in MetaMask.

Wrapping Up

You’ve now set up the basics needed to start your Ethereum Web3 journey:

• You learned the prerequisites (tools and knowledge needed).

• You installed and created your first Ethereum wallet (MetaMask).

• You’re ready to explore test networks and practice with free ETH.

👉 In the next docs, we’ll dive into:

• Understanding Ethereum fundamentals (the Ethereum network, how it works, what it’s used for, and how to start using it).

• Writing your first smart contract in Solidity.

• Deploying it to an Ethereum testnet.

Welcome to the world of Ethereum Web3,your journey as a blockchain developer has just begun! 🚀