Uncodemy Ghaziabad Campus Blockchain Course Details

// Solidity — ERC-20 token with a simple distributor pattern
// A standard project from the Ghaziabad campus curriculum.

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract RewardToken is ERC20, Ownable {
    constructor() ERC20("RewardToken", "RWD") Ownable(msg.sender) {
        _mint(msg.sender, 1_000_000 * 10 ** decimals());
    }

    /// Owner can distribute tokens to a batch of recipients.
    function distribute(address[] calldata recipients, uint256 amountEach)
        external
        onlyOwner
    {
        require(recipients.length > 0, "empty list");
        require(recipients.length <= 200, "too many recipients");

        for (uint256 i = 0; i < recipients.length; i++) {
            require(recipients[i] != address(0), "zero address");
            _transfer(msg.sender, recipients[i], amountEach);
        }
    }
}

// What this proves in an interview:
// - You use OpenZeppelin standards rather than reimplementing ERC-20
// - You add sensible constraints (recipient cap, zero-address checks)
// - You reason about gas — a 200-recipient loop is already near the limit
// - You understand access control (onlyOwner) as a first-class concern

// In the README, explain the recipient cap: it shows you
// understand block gas limits, not just Solidity syntax.

// Hardhat — deployment script that verifies on the explorer
// The kind of script that separates "deployed once" from "shipped properly".

const hre = require("hardhat");

async function main() {
  const [deployer] = await hre.ethers.getSigners();
  console.log("Deploying with:", deployer.address);
  console.log("Balance:", (await deployer.provider.getBalance(deployer.address)).toString());

  const RewardToken = await hre.ethers.getContractFactory("RewardToken");
  const token = await RewardToken.deploy();
  await token.waitForDeployment();

  const address = await token.getAddress();
  console.log("RewardToken deployed to:", address);

  // Verify on Etherscan so anyone can read the source
  if (hre.network.name !== "hardhat" && hre.network.name !== "localhost") {
    await hre.run("verify:verify", {
      address,
      constructorArguments: [],
    });
  }
}

main().catch((err) => {
  console.error(err);
  process.exitCode = 1;
});

// What this proves in an interview:
// - You know deployment is a scripted, repeatable process
// - You print the deployer address and balance (sanity checks)
// - You verify the contract on the explorer — not optional
// - You handle errors properly, not with silent failures

// Deployment scripts belong in the repo alongside the
// contracts, tagged with the commit that matches the live code.

// Frontend — connect a wallet and call a contract function
// This is the "complete product" part interviewers want to see.

import { BrowserProvider, Contract, parseEther } from "ethers";
import { useState } from "react";

const TOKEN_ADDRESS = "0xYourDeployedTokenAddress";
const TOKEN_ABI = [
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address to, uint256 amount) returns (bool)",
];

export default function WalletPanel() {
  const [account, setAccount] = useState(null);
  const [balance, setBalance] = useState("0");
  const [error, setError] = useState(null);

  async function connect() {
    try {
      if (!window.ethereum) throw new Error("No wallet found");
      const provider = new BrowserProvider(window.ethereum);
      const accounts = await provider.send("eth_requestAccounts", []);
      const signer = await provider.getSigner();

      const token = new Contract(TOKEN_ADDRESS, TOKEN_ABI, signer);
      const raw = await token.balanceOf(accounts[0]);

      setAccount(accounts[0]);
      setBalance(raw.toString());
    } catch (err) {
      setError(err.message);
    }
  }

  return (
    <div>
      <button onClick={connect}>Connect Wallet</button>
      {account && <p>Connected: {account}</p>}
      {account && <p>Balance: {balance}</p>}
      {error && <p>Error: {error}</p>}
    </div>
  );
}

// What this proves in an interview:
// - You understand wallet connection, provider, and signer
// - You handle errors gracefully — users will reject connection
// - You read contract state via ABI + address
// - You know ethers v6 API (BrowserProvider, not Web3Provider)

// A working frontend around your contract turns a
// "project" into a "product" — and that's what a hiring
// manager actually evaluates.