// Solidity — a simple savings contract
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Savings {
    mapping(address => uint256) public balances;

    event Deposited(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);

    function deposit() external payable {
        require(msg.value > 0, "Send some ETH");
        balances[msg.sender] += msg.value;
        emit Deposited(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "Transfer failed");
        emit Withdrawn(msg.sender, amount);
    }

    function myBalance() external view returns (uint256) {
        return balances[msg.sender];
    }
}

// Ethers.js — read & write a smart contract
import { ethers } from "ethers";

const CONTRACT_ADDRESS = "0xYourContractAddress";
const ABI = [
  "function deposit() payable",
  "function myBalance() view returns (uint256)",
  "event Deposited(address indexed user, uint256 amount)",
];

async function connect() {
  await window.ethereum.request({ method: "eth_requestAccounts" });
  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  return new ethers.Contract(CONTRACT_ADDRESS, ABI, signer);
}

async function deposit(amountEth) {
  const contract = await connect();
  const tx = await contract.deposit({
    value: ethers.parseEther(amountEth),
  });
  await tx.wait();
  console.log("Deposited");
}

async function balance() {
  const contract = await connect();
  const b = await contract.myBalance();
  console.log(ethers.formatEther(b), "ETH");
}

// Hardhat test — deposit & withdraw flow
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Savings", function () {
  let savings, owner;

  beforeEach(async () => {
    [owner] = await ethers.getSigners();
    const Factory = await ethers.getContractFactory("Savings");
    savings = await Factory.deploy();
    await savings.waitForDeployment();
  });

  it("accepts deposits", async () => {
    await savings.deposit({ value: ethers.parseEther("1") });
    const bal = await savings.myBalance();
    expect(bal).to.equal(ethers.parseEther("1"));
  });

  it("rejects over-withdrawals", async () => {
    await savings.deposit({ value: ethers.parseEther("0.5") });
    await expect(
      savings.withdraw(ethers.parseEther("1"))
    ).to.be.revertedWith("Insufficient balance");
  });
});

Project 1 — On-chain dashboard
1. Pick a token or protocol (e.g., USDC, Uniswap)
2. Pull on-chain data with Ethers.js or The Graph
3. Build a small dashboard showing
   holders, transfers, and volume trends
4. Deploy on Vercel and share the link

Skills shown:
- Blockchain data reading
- API / SDK usage
- Data visualisation

Ideal for Analyst, PM, Community roles.

Project 2 — Smart contract + mini dApp
1. Write a Solidity contract
   (e.g., a simple voting or savings app)
2. Test it thoroughly with Hardhat
3. Build a tiny frontend with Ethers.js
4. Deploy to a testnet (Sepolia)
5. README with screenshots + demo video

Skills shown:
- Solidity fundamentals
- Security basics
- Full-stack web3

Ideal for Developer and QA roles.

Weekly study plan (12-15 hours):
Mon 1.5h — Theory (blockchain basics)
Tue 1.5h — Hands-on (wallets, transactions)
Wed 1.5h — Theory (Solidity)
Thu 1.5h — Coding practice
Fri 1h   — Weekly review + notes
Sat 4h   — Project work
Sun 2h   — Community + reading

Consistency beats intensity.
Join a Discord and share weekly progress.

Job search plan (Month 6):
Week 1: Polish resume + LinkedIn
Week 2: Build a one-page portfolio site
Week 3: Apply to 10 roles per week
Week 4: 2 mock interviews
Week 5: Engage in web3 Discords
Week 6: Follow up + iterate

Aim for 8–12 quality applications per week.
Track every application in a simple sheet.