bclab 1.0.0__tar.gz

bclab-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.5
+Name: bclab
+Version: 1.0.0
+Summary: Blockchain Technology lab (CS441): menu with steps and code for 8 experiments
+Requires-Python: >=3.8
+Requires-Dist: cryptography
+Description-Content-Type: text/markdown
+
+# bclab
+
+Blockchain Technology lab menu. Lists 8 experiments, shows steps and code, and can run or copy the files.
+
+    pipx install bclab
+    bclab

bclab-1.0.0/README.md

@@ -0,0 +1,6 @@
+# bclab
+
+Blockchain Technology lab menu. Lists 8 experiments, shows steps and code, and can run or copy the files.
+
+    pipx install bclab
+    bclab

bclab-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bclab"
+version = "1.0.0"
+description = "Blockchain Technology lab (CS441): menu with steps and code for 8 experiments"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = ["cryptography"]
+
+[project.scripts]
+bclab = "bclab.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/bclab"]

bclab-1.0.0/src/bclab/cli.py

@@ -0,0 +1,101 @@
+"""Blockchain lab menu: pick an experiment, see its steps and code, copy or run the files."""
+import os
+import shutil
+import subprocess
+import sys
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8")
+except Exception:
+    pass
+
+ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
+CODE_EXT = (".py", ".sol")
+
+
+def experiments():
+    return sorted(
+        (d for d in os.listdir(ROOT)
+         if d.lower().startswith("exp") and os.path.isdir(os.path.join(ROOT, d))),
+        key=lambda d: int("".join(c for c in d.split("_")[0] if c.isdigit()) or 0),
+    )
+
+
+def read(path):
+    with open(path, encoding="utf-8") as f:
+        return f.read()
+
+
+def show(folder):
+    base = os.path.join(ROOT, folder)
+    bar = "=" * 70
+    print(f"\n{bar}\n{folder}\n{bar}\n")
+    steps = os.path.join(base, "steps.md")
+    if os.path.exists(steps):
+        print(read(steps))
+    for name in sorted(os.listdir(base)):
+        if name.endswith(CODE_EXT):
+            print(f"\n{'-' * 70}\nFILE: {name}\n{'-' * 70}")
+            print(read(os.path.join(base, name)))
+
+
+def copy_files(folder):
+    base = os.path.join(ROOT, folder)
+    dest = input(f"Copy into which folder? [Enter = {os.getcwd()}]: ").strip().strip('"') or os.getcwd()
+    os.makedirs(dest, exist_ok=True)
+    for name in os.listdir(base):
+        shutil.copy2(os.path.join(base, name), os.path.join(dest, name))
+        print(f"  created {os.path.join(dest, name)}")
+
+
+def run_python(folder):
+    base = os.path.join(ROOT, folder)
+    pys = [n for n in sorted(os.listdir(base)) if n.endswith(".py")]
+    if not pys:
+        print("No Python file in this experiment (use Remix for Solidity).")
+        return
+    for n in pys:
+        print(f"\n>>> python {n}\n")
+        subprocess.run([sys.executable, n], cwd=base)
+
+
+def action_menu(folder):
+    while True:
+        print("\n[s] show again  [r] run Python file  [c] copy files to a folder  [b] back  [q] quit")
+        a = input("> ").strip().lower()
+        if a == "s":
+            show(folder)
+        elif a == "r":
+            run_python(folder)
+        elif a == "c":
+            copy_files(folder)
+        elif a == "b":
+            return True
+        elif a == "q":
+            return False
+
+
+def main():
+    while True:
+        exps = experiments()
+        print("\n" + "=" * 70 + "\n  BLOCKCHAIN TECHNOLOGY LAB (CS441) - EXPERIMENTS\n" + "=" * 70)
+        for i, e in enumerate(exps, 1):
+            print(f"  {i}. {e}")
+        print("  q. Quit")
+        choice = input("\nSelect experiment number: ").strip().lower()
+        if choice == "q":
+            return
+        if not choice.isdigit() or not 1 <= int(choice) <= len(exps):
+            print("Invalid choice.")
+            continue
+        folder = exps[int(choice) - 1]
+        show(folder)
+        if not action_menu(folder):
+            return
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (KeyboardInterrupt, EOFError):
+        print()

bclab-1.0.0/src/bclab/data/Exp1_Fundamentals/steps.md

@@ -0,0 +1,21 @@
+# Exp 1: Fundamentals of Blockchain Technology (theory)
+
+**Aim:** To study the fundamental concepts of blockchain, its history, evolution and key characteristics.
+
+## Points to explain
+1. **Definition:** A blockchain is a distributed, append-only ledger made of blocks. Each block stores data plus the hash of the previous block.
+2. **Decentralization:** No single central authority. Many nodes hold a copy of the ledger.
+3. **Transparency:** All participants can view the recorded transactions.
+4. **Immutability:** Changing an old block changes its hash and breaks every later block, so tampering is easy to detect.
+5. **History / evolution:**
+   - 2008: Bitcoin whitepaper (Satoshi Nakamoto)
+   - 2009: Bitcoin network launched (Blockchain 1.0, digital currency)
+   - 2015: Ethereum launched with smart contracts (Blockchain 2.0)
+   - Later: enterprise use in supply chain, finance, healthcare (Blockchain 3.0)
+6. **Types:** Public, private, consortium.
+7. **Applications:** Supply chain, finance, healthcare, digital identity, government records.
+
+## Viva questions
+- What makes a blockchain immutable?
+- Difference between public and private blockchains?
+- What is a node?

bclab-1.0.0/src/bclab/data/Exp2_DataStructures_Consensus/steps.md

@@ -0,0 +1,22 @@
+# Exp 2: Blockchain Data Structures and Consensus Mechanisms (theory)
+
+**Aim:** To study blocks, chains, Merkle trees and the PoW / PoS consensus mechanisms.
+
+## Points to explain
+1. **Block:** header (previous hash, timestamp, nonce, Merkle root) + body (transactions). In our Python code: index, timestamp, data, previous_hash, nonce, hash.
+2. **Chain:** each block stores the previous block's hash. The first block is the **Genesis block** with previous_hash = "0".
+3. **Merkle tree:** hash each transaction, pair the hashes and hash them again, repeat until one **Merkle root** remains. A change in any transaction changes the root. It allows quick verification of one transaction.
+4. **Proof of Work (PoW):** miners try nonces until the block hash meets a difficulty target (e.g. leading zeros). Secure, but uses a lot of energy. Used by Bitcoin.
+5. **Proof of Stake (PoS):** validators are chosen according to the coins they stake. Dishonest validators lose their stake (slashing). Energy efficient. Used by Ethereum now.
+
+## PoW vs PoS
+| | PoW | PoS |
+|---|---|---|
+| Selection | Computing power | Staked coins |
+| Energy | High | Low |
+| Example | Bitcoin | Ethereum |
+
+## Viva questions
+- What is the role of the nonce?
+- Why use a Merkle tree?
+- What is a 51% attack?

bclab-1.0.0/src/bclab/data/Exp3_SHA256/sha256_demo.py

@@ -0,0 +1,33 @@
+import hashlib
+
+def compute_sha256(data: str) -> str:
+    h = hashlib.sha256()
+    h.update(data.encode("utf-8"))
+    return h.hexdigest()
+
+def count_bit_difference(h1: str, h2: str) -> int:
+    b1 = bin(int(h1, 16))[2:].zfill(len(h1) * 4)
+    b2 = bin(int(h2, 16))[2:].zfill(len(h2) * 4)
+    return sum(x != y for x, y in zip(b1, b2))
+
+def avalanche(a: str, b: str):
+    h1, h2 = compute_sha256(a), compute_sha256(b)
+    print(f"Input 1 : {a!r}\nHash 1  : {h1}\n")
+    print(f"Input 2 : {b!r}\nHash 2  : {h2}\n")
+    d = count_bit_difference(h1, h2)
+    print(f"Differing bits: {d}/256  ({d/256*100:.2f}%)")
+    print("-" * 60)
+
+for t in ["Hello, World!", "RIT Sangli", "Password123", ""]:
+    print(f"Input: {t!r}\nHash : {compute_sha256(t)}\n")
+
+avalanche("Hello, World!", "Hello, World?")
+avalanche("password", "Password")
+avalanche("RIT Sangli", "RIT Sangli ")
+
+print("Type a string to hash (empty line to quit):")
+while True:
+    s = input("> ")
+    if not s:
+        break
+    print(compute_sha256(s))

bclab-1.0.0/src/bclab/data/Exp3_SHA256/steps.md

@@ -0,0 +1,26 @@
+# Exp 3: SHA-256 Hashing in Python
+
+**Aim:** To implement SHA-256 hashing in Python and observe how changes in input affect the hash (avalanche effect).
+
+**Requirements:** Python 3.8+ (uses only the standard library `hashlib`).
+
+## Steps
+1. Open a terminal in this folder.
+2. Import `hashlib`.
+3. Write `compute_sha256()` that encodes the string to UTF-8 and returns `hexdigest()`.
+4. Hash a few sample strings (including the empty string).
+5. Write `count_bit_difference()` that converts both hashes to binary and counts differing bits.
+6. Hash two nearly identical inputs (one character changed, case changed, trailing space) and compare. About 50% of the 256 bits should differ.
+7. Run the program.
+
+```
+python sha256_demo.py
+```
+
+**Code file:** `sha256_demo.py`
+
+## Key points for viva
+- SHA-256 always gives a 256-bit (64 hex character) output, whatever the input size.
+- It is deterministic, one-way and collision resistant.
+- Avalanche effect: a tiny input change changes about half the output bits.
+- Hashing is not encryption: it cannot be reversed.

bclab-1.0.0/src/bclab/data/Exp4_SimpleBlockchain/simple_blockchain.py

@@ -0,0 +1,57 @@
+import hashlib, json, time
+
+class Block:
+    def __init__(self, index, data, previous_hash, timestamp=None, nonce=0):
+        self.index = index
+        self.timestamp = timestamp or time.time()
+        self.data = data
+        self.previous_hash = previous_hash
+        self.nonce = nonce
+        self.hash = self.compute_hash()
+
+    def compute_hash(self):
+        s = json.dumps({"index": self.index, "timestamp": self.timestamp,
+                        "data": self.data, "previous_hash": self.previous_hash,
+                        "nonce": self.nonce}, sort_keys=True)
+        return hashlib.sha256(s.encode()).hexdigest()
+
+class Blockchain:
+    def __init__(self, difficulty=2):
+        self.difficulty = difficulty
+        self.chain = [Block(0, "Genesis Block", "0")]
+
+    def proof_of_work(self, block):
+        target = "0" * self.difficulty
+        while not block.hash.startswith(target):
+            block.nonce += 1
+            block.hash = block.compute_hash()
+        return block
+
+    def add_block(self, data):
+        prev = self.chain[-1]
+        blk = self.proof_of_work(Block(prev.index + 1, data, prev.hash))
+        self.chain.append(blk)
+
+    def is_chain_valid(self):
+        for i in range(1, len(self.chain)):
+            cur, prev = self.chain[i], self.chain[i - 1]
+            if cur.hash != cur.compute_hash():
+                print(f"Block {cur.index} tampered (hash mismatch).")
+                return False
+            if cur.previous_hash != prev.hash:
+                print(f"Block {cur.index} not linked correctly.")
+                return False
+            if not cur.hash.startswith("0" * self.difficulty):
+                print(f"Block {cur.index} fails Proof-of-Work.")
+                return False
+        return True
+
+c = Blockchain(difficulty=3)
+c.add_block("Alice pays Bob 10 coins")
+c.add_block("Bob pays Charlie 5 coins")
+c.add_block("Charlie pays Dave 2 coins")
+for b in c.chain:
+    print(f"Block #{b.index} | prev={b.previous_hash[:12]}... | hash={b.hash[:12]}... | nonce={b.nonce} | {b.data}")
+print("Chain valid before tampering?", c.is_chain_valid())
+c.chain[1].data = "Alice pays Bob 1000 coins"
+print("Chain valid after tampering? ", c.is_chain_valid())

bclab-1.0.0/src/bclab/data/Exp4_SimpleBlockchain/steps.md

@@ -0,0 +1,35 @@
+# Exp 4: Simple Blockchain using Cryptographic Hash Linking
+
+**Aim:** To build a simple blockchain in Python by linking blocks with SHA-256 hashes and verify chain integrity by detecting tampering.
+
+**Requirements:** Python 3.8+; standard libraries `hashlib`, `json`, `time`.
+
+## Algorithm / Steps
+1. Define a `Block` class with: index, timestamp, data, previous_hash, nonce, hash.
+2. Compute a block's hash as SHA-256 of its serialized fields (use `json.dumps(..., sort_keys=True)`).
+3. Create the **Genesis block** (index 0, previous_hash = "0").
+4. To add a block: take the previous block's hash as `previous_hash`, then run **Proof of Work**: increase `nonce` until the hash starts with the required number of zeros.
+5. Append the block to the chain.
+6. To verify the chain, for each block from index 1: (a) recompute the hash and compare with the stored hash, (b) check `previous_hash` equals the previous block's hash, (c) check the PoW difficulty is satisfied.
+7. If any check fails, report the chain as invalid; otherwise valid.
+8. Tamper with block 1's data and validate again.
+
+```
+python simple_blockchain.py
+```
+
+**Code file:** `simple_blockchain.py`
+
+## Expected output
+```
+Chain valid before tampering? True
+Block 1 tampered (hash mismatch).
+Chain valid after tampering?  False
+```
+
+## Viva questions
+1. Why does changing data in one block invalidate all subsequent blocks?
+2. What is the role of the Genesis block?
+3. How does Proof of Work make tampering expensive?
+4. If an attacker recomputes all downstream hashes, how does a real network defend? (distributed consensus, the honest majority holds the longest valid chain)
+5. Hashing vs encryption? (hashing is one-way, encryption is reversible with a key)

bclab-1.0.0/src/bclab/data/Exp5_KeyPair_DigitalSignature/sign_verify.py

@@ -0,0 +1,28 @@
+# pip install cryptography
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.exceptions import InvalidSignature
+
+private_key = ec.generate_private_key(ec.SECP256K1())
+public_key = private_key.public_key()
+
+print("Private key (PEM):")
+print(private_key.private_bytes(serialization.Encoding.PEM,
+      serialization.PrivateFormat.PKCS8, serialization.NoEncryption()).decode())
+print("Public key (PEM):")
+print(public_key.public_bytes(serialization.Encoding.PEM,
+      serialization.PublicFormat.SubjectPublicKeyInfo).decode())
+
+message = b"Alice pays Bob 10 coins"
+signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
+print("Signature:", signature.hex())
+
+def verify(msg):
+    try:
+        public_key.verify(signature, msg, ec.ECDSA(hashes.SHA256()))
+        return True
+    except InvalidSignature:
+        return False
+
+print("Original message valid? ", verify(message))
+print("Tampered message valid? ", verify(b"Alice pays Bob 1000 coins"))

bclab-1.0.0/src/bclab/data/Exp5_KeyPair_DigitalSignature/steps.md

@@ -0,0 +1,34 @@
+# Exp 5: Public/Private Key Generation and Digital Signature Simulation
+
+**Aim:** To generate a public/private key pair and simulate signing and verifying a message in Python.
+
+**Requirements:** Python 3.8+ and the `cryptography` package.
+
+```
+pip install cryptography
+```
+
+## Steps
+1. Generate a private key using ECDSA on the secp256k1 curve (the same curve Bitcoin and Ethereum use).
+2. Derive the public key from the private key.
+3. Print both keys in PEM format.
+4. Sign a message with the **private** key (hash with SHA-256, then sign).
+5. Verify the signature with the **public** key: it should print True.
+6. Change the message and verify again: it should print False (InvalidSignature).
+
+```
+python sign_verify.py
+```
+
+**Code file:** `sign_verify.py`
+
+## Expected output
+```
+Original message valid?  True
+Tampered message valid?  False
+```
+
+## Viva questions
+- Why is the private key kept secret and the public key shared?
+- What does a digital signature give us? (authentication, integrity, non-repudiation)
+- How is a wallet address derived from a public key?

bclab-1.0.0/src/bclab/data/Exp6_HelloWorld_Contract/HelloWorld.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract HelloWorld {
+    string private message = "Hello, World!";
+
+    function getMessage() public view returns (string memory) {
+        return message;
+    }
+
+    function setMessage(string memory _msg) public {
+        message = _msg;
+    }
+}

bclab-1.0.0/src/bclab/data/Exp6_HelloWorld_Contract/steps.md

@@ -0,0 +1,23 @@
+# Exp 6: "Hello World" Smart Contract in Solidity (Remix IDE)
+
+**Aim:** To write, compile and deploy a basic Hello World smart contract on Remix IDE.
+
+**Requirements:** A web browser and https://remix.ethereum.org
+
+## Steps
+1. Open https://remix.ethereum.org
+2. In the File Explorer, create a new file `HelloWorld.sol`.
+3. Paste the code from `HelloWorld.sol` in this folder.
+4. Open the **Solidity Compiler** tab, select compiler **0.8.19** (or a compatible 0.8.x) and click **Compile HelloWorld.sol**.
+5. Open the **Deploy & Run Transactions** tab and set Environment to **Remix VM**.
+6. Select the `HelloWorld` contract and click **Deploy**.
+7. Under *Deployed Contracts*, click `getMessage`. It returns "Hello, World!".
+8. Type a new text in `setMessage`, click **transact**, then call `getMessage` again to see the changed message.
+
+**Code file:** `HelloWorld.sol`
+
+## Viva questions
+- What is a smart contract?
+- What does `pragma solidity` do?
+- Difference between `view` functions and functions that change state? (view reads only and costs no gas when called directly)
+- What is the Remix VM?

bclab-1.0.0/src/bclab/data/Exp7_SimpleToken/SimpleToken.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract SimpleToken {
+    string public name = "SimpleToken";
+    string public symbol = "STK";
+    uint8 public decimals = 18;
+    uint256 public totalSupply;
+    address public owner;
+    mapping(address => uint256) public balanceOf;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(uint256 _initialSupply) {
+        owner = msg.sender;
+        totalSupply = _initialSupply * (10 ** uint256(decimals));
+        balanceOf[owner] = totalSupply;
+        emit Transfer(address(0), owner, totalSupply);
+    }
+
+    // Transfer tokens from caller to another address
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        require(_to != address(0), "Invalid address");
+        require(balanceOf[msg.sender] >= _value, "Insufficient balance");
+        balanceOf[msg.sender] -= _value;
+        balanceOf[_to] += _value;
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    // Helper to check balance of any account
+    function getBalance(address _account) public view returns (uint256) {
+        return balanceOf[_account];
+    }
+}

bclab-1.0.0/src/bclab/data/Exp7_SimpleToken/steps.md

@@ -0,0 +1,44 @@
+# Exp 7: Simple Token Transfer Smart Contract
+
+**Aim:** To implement a simple token transfer contract in Solidity, deploy it on Remix VM and verify balance changes between accounts.
+
+## Steps
+1. Open https://remix.ethereum.org
+2. Create `SimpleToken.sol` and paste the code from this folder.
+3. **Compile:** Solidity Compiler tab, version 0.8.19, click Compile.
+4. **Environment:** Deploy & Run tab, select **Remix VM (Cancun)**.
+5. **Constructor argument:** select `SimpleToken` and enter `1000` next to Deploy.
+6. Click **Deploy**. The contract appears under *Deployed Contracts*.
+
+### Check initial balances
+7. Copy Account 0's address (from the Account dropdown) and call `getBalance(<Account0>)`. Expected: `1000000000000000000000` (1000 tokens, 18 decimals).
+8. Call `getBalance(<Account1>)`. Expected: `0`.
+
+### Transfer
+9. Keep **Account 0** selected as the sender.
+10. In `transfer`, enter `_to` = Account 1's address and `_value` = `100000000000000000000` (100 tokens). Click **transact**.
+
+### Verify
+11. Call `getBalance` for both accounts again.
+
+| Account | Before | After |
+|---|---|---|
+| Account 0 (sender) | 1000 STK | 900 STK |
+| Account 1 (receiver) | 0 STK | 100 STK |
+
+12. Expand the transaction in the Remix console and check the `Transfer` event (from, to, value).
+
+### Negative test (include in the report)
+13. Try to transfer more than the sender's balance. Remix reverts with **"Insufficient balance"**.
+
+**Code file:** `SimpleToken.sol`
+
+## Notes
+- Amounts are in the smallest unit because of 18 decimals (100 tokens = 100 * 10^18).
+- `require()` blocks sending to the zero address and sending more than the balance.
+- `mapping(address => uint256)` stores balances.
+
+## Viva questions
+- What is the use of `msg.sender`?
+- What is an event and why emit `Transfer`?
+- Why are 18 decimals used?

bclab-1.0.0/src/bclab/data/Exp8_Sepolia_Deploy/HelloWorld.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract HelloWorld {
+    string private message = "Hello, World!";
+
+    function getMessage() public view returns (string memory) {
+        return message;
+    }
+
+    function setMessage(string memory _msg) public {
+        message = _msg;
+    }
+}

bclab-1.0.0/src/bclab/data/Exp8_Sepolia_Deploy/SimpleToken.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract SimpleToken {
+    string public name = "SimpleToken";
+    string public symbol = "STK";
+    uint8 public decimals = 18;
+    uint256 public totalSupply;
+    address public owner;
+    mapping(address => uint256) public balanceOf;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(uint256 _initialSupply) {
+        owner = msg.sender;
+        totalSupply = _initialSupply * (10 ** uint256(decimals));
+        balanceOf[owner] = totalSupply;
+        emit Transfer(address(0), owner, totalSupply);
+    }
+
+    // Transfer tokens from caller to another address
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        require(_to != address(0), "Invalid address");
+        require(balanceOf[msg.sender] >= _value, "Insufficient balance");
+        balanceOf[msg.sender] -= _value;
+        balanceOf[_to] += _value;
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    // Helper to check balance of any account
+    function getBalance(address _account) public view returns (uint256) {
+        return balanceOf[_account];
+    }
+}

bclab-1.0.0/src/bclab/data/Exp8_Sepolia_Deploy/steps.md

@@ -0,0 +1,28 @@
+# Exp 8: Deploy a Smart Contract on the Ethereum Sepolia Testnet (MetaMask + Etherscan)
+
+**Aim:** To deploy a smart contract on the Sepolia testnet using MetaMask and verify the transaction on Etherscan.
+
+**Requirements:** Chrome/Edge/Firefox, the MetaMask extension, Remix IDE, free Sepolia test ETH.
+
+## Steps
+1. Install the **MetaMask** extension (https://metamask.io) and create (or import) a wallet. Save the recovery phrase safely and never share it.
+2. In MetaMask open the network dropdown, enable **Show test networks** and select **Sepolia**.
+3. Get free Sepolia test ETH from a faucet (e.g. Google Cloud Web3 faucet or Alchemy Sepolia faucet) by pasting your wallet address. Wait until the balance shows in MetaMask.
+4. Open https://remix.ethereum.org and use the contract from this folder (`HelloWorld.sol`, or `SimpleToken.sol`).
+5. **Compile** it with 0.8.19.
+6. In Deploy & Run Transactions set Environment to **Injected Provider - MetaMask**. Check that the network shows *Sepolia (11155111)* and your account is selected.
+7. Click **Deploy** (for SimpleToken enter the initial supply first, e.g. 1000).
+8. A MetaMask popup appears. Review the gas fee and click **Confirm**.
+9. Wait for confirmation. In the Remix console copy the **transaction hash** and, under Deployed Contracts, the **contract address**.
+10. Open https://sepolia.etherscan.io and paste the transaction hash.
+11. Verify and note: Status = **Success**, Block number, From (your wallet), To (Contract Creation), Gas used, Transaction fee, Timestamp.
+12. Search the contract address on Etherscan to see the deployed contract.
+13. Optional: call a function (e.g. `setMessage` or `transfer`) from Remix and verify that transaction on Etherscan as well.
+
+**Code file:** `HelloWorld.sol` (and `SimpleToken.sol` as an alternative)
+
+## Viva questions
+- What is a testnet and why use it?
+- What is gas?
+- What is the difference between Remix VM and Injected Provider?
+- What does Etherscan show for a transaction?