A perfect beginner-friendly blockchain project for school/college

📌 Project Overview

Create a web application that allows users to prove they had a document at a specific point in time without revealing the document's contents. This is like a digital notary service on the blockchain.

🎯 Why This Project?

• Teaches core blockchain concepts: Hashing, transactions, immutability
• No smart contracts needed: Can work with simple blockchain interactions
• Practical real-world use: Useful for copyright, patents, legal documents
• Visually demonstrable: Easy to show in presentations

🛠️ Tech Stack Suggestions

Component	Technology Options
Blockchain	Ethereum (testnet), Polygon, Binance Smart Chain testnet
Smart Contracts	None required (can use blockchain's native transactions)
Backend	Node.js, Python (Flask), or PHP
Frontend	HTML/CSS, JavaScript, React (optional)
Storage	IPFS (optional for file storage)
Wallet Connection	MetaMask, Web3.js, or Ethers.js

📋 Step-by-Step Implementation Guide

Step 1: Understanding the Core Concept

When you timestamp a document:

1. User selects a file
2. App calculates the file's cryptographic hash (unique fingerprint)
3. Hash is sent to the blockchain in a transaction
4. Blockchain records the time permanently
5. Later, anyone can verify by comparing hashes

Step 2: Basic Architecture

User Uploads File → Calculate SHA-256 Hash → Send Hash to Blockchain (small transaction) → Get Transaction Receipt with Timestamp → Store Receipt Hash for Verification

Step 3: Code Structure

A. Hash Generator (Python Example)

import hashlib import datetime def calculate_file_hash(filename): """Calculate SHA-256 hash of a file""" sha256_hash = hashlib.sha256() with open(filename, "rb") as f: # Read file in chunks to handle large files for byte_block in iter(lambda: f.read(4096), b""): sha256_hash.update(byte_block) return sha256_hash.hexdigest() # Example usage file_hash = calculate_file_hash("my_document.pdf") print(f"Document Fingerprint: {file_hash}") print(f"Timestamp: {datetime.datetime.now()}")

B. Simple Blockchain Interaction (Using Web3.js)

// Connect to Ethereum testnet const Web3 = require('web3'); const web3 = new Web3('https://goerli.infura.io/v3/YOUR_PROJECT_ID'); async function timestampOnBlockchain(documentHash) { // Get user account (via MetaMask) const accounts = await web3.eth.requestAccounts(); const fromAddress = accounts[0]; // Create a simple transaction with the hash in data field const tx = { from: fromAddress, to: '0x0000000000000000000000000000000000000000', // Null address data: web3.utils.toHex(documentHash), gas: 21000 }; // Send transaction const receipt = await web3.eth.sendTransaction(tx); console.log('Transaction Hash:', receipt.transactionHash); console.log('Block Timestamp:', receipt.timestamp); return receipt; }

C. Verification Function

async function verifyDocument(originalFile, transactionHash) { // 1. Calculate hash of current file const currentHash = calculateFileHash(originalFile); // 2. Get the original hash from blockchain const tx = await web3.eth.getTransaction(transactionHash); const originalHash = web3.utils.hexToAscii(tx.input); // 3. Compare if (currentHash === originalHash) { return { verified: true, message: "Document is authentic!", timestamp: tx.timestamp }; } else { return { verified: false, message: "Document has been modified!" }; } }

Step 4: Simple Web Interface

HTML (index.html):

<!DOCTYPE html> <html> <head> <title>Blockchain Timestamp Service</title> <style> body { font-family: Arial; max-width: 600px; margin: 50px auto; } .box { border: 2px solid #333; padding: 20px; margin: 20px 0; border-radius: 10px; } button { background: #4CAF50; color: white; padding: 10px 20px; border: none; cursor: pointer; } #result { margin-top: 20px; padding: 10px; background: #f0f0f0; } </style> </head> <body> <h1>📜 Blockchain Timestamp Service</h1> <p>Prove you had a document at a specific time - without revealing it!</p> <div class="box"> <h2>1. Timestamp a Document</h2> <input type="file" id="fileInput"> <button onclick="timestampDocument()">Stamp on Blockchain</button> </div> <div class="box"> <h2>2. Verify a Document</h2> <input type="file" id="verifyFile"> <input type="text" id="txHash" placeholder="Enter transaction hash"> <button onclick="verifyDocument()">Verify Authenticity</button> </div> <div id="result"></div> <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/web3.min.js"></script> <script src="app.js"></script> </body> </html>

JavaScript (app.js):

let web3; if (window.ethereum) { web3 = new Web3(window.ethereum); } async function timestampDocument() { const file = document.getElementById('fileInput').files[0]; if (!file) { alert('Please select a file'); return; } // Read file and calculate hash const buffer = await file.arrayBuffer(); const hashBuffer = await crypto.subtle.digest('SHA-256', buffer); const hashArray = Array.from(new Uint8Array(hashBuffer)); const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join(''); document.getElementById('result').innerHTML = '⏳ Sending to blockchain...'; try { // Request account access await window.ethereum.request({ method: 'eth_requestAccounts' }); const accounts = await web3.eth.getAccounts(); // Send transaction const tx = await web3.eth.sendTransaction({ from: accounts[0], to: '0x0000000000000000000000000000000000000000', data: web3.utils.toHex(hashHex), gas: 21000 }); document.getElementById('result').innerHTML = ` ✅ Document stamped successfully!<br> Transaction Hash: ${tx.transactionHash}<br> Block: ${tx.blockNumber}<br> Timestamp: ${new Date().toLocaleString()} `; } catch (error) { document.getElementById('result').innerHTML = '❌ Error: ' + error.message; } } async function verifyDocument() { const file = document.getElementById('verifyFile').files[0]; const txHash = document.getElementById('txHash').value; if (!file || !txHash) { alert('Please select file and enter transaction hash'); return; } // Calculate current file hash const buffer = await file.arrayBuffer(); const hashBuffer = await crypto.subtle.digest('SHA-256', buffer); const hashArray = Array.from(new Uint8Array(hashBuffer)); const currentHash = hashArray.map(b => b.toString(16).padStart(2, '0')).join(''); // Get original hash from blockchain const tx = await web3.eth.getTransaction(txHash); const originalHash = web3.utils.hexToAscii(tx.input).replace(/\0/g, ''); if (currentHash === originalHash) { document.getElementById('result').innerHTML = ` ✅ VERIFIED: Document is authentic!<br> Original timestamp: ${new Date(tx.timestamp * 1000).toLocaleString()} `; } else { document.getElementById('result').innerHTML = ` ❌ FAILED: Document has been modified! `; } }

🎓 Learning Outcomes

By building this project, you'll learn:

1. Cryptographic Hashing: How SHA-256 creates unique fingerprints
2. Blockchain Transactions: How data is stored permanently
3. Web3 Integration: Connecting web apps to blockchain
4. Immutability: Why blockchain data can't be changed
5. Gas and Fees: Understanding transaction costs (even on testnets)

🔧 Simplification Options

• Use a testnet faucet to get free test ETH
• Skip MetaMask by using a centralized API (less secure but simpler)
• Use Python only and store hashes in a simple blockchain simulation
• Focus on theory and create a working prototype without real blockchain

📊 Presentation Tips

• Show before/after: Modify a file and demonstrate failed verification
• Explain the "hash" concept with a simple analogy (fingerprint)
• Show the blockchain explorer to prove the timestamp exists
• Discuss real-world applications: Copyright, patents, legal evidence

🚀 Possible Extensions

• Add IPFS storage for the actual files
• Create a receipt PDF with QR code
• Build a mobile app version
• Add email notifications
• Create a public verification page

⚠️ Common Pitfalls to Avoid

1. Don't store actual files on blockchain (too expensive)
2. Always use testnets first (real ETH costs money)
3. Handle large files properly (stream reading)
4. Clear error messages for users without MetaMask

💡 Real-World Example

Imagine you wrote a song and want to prove you wrote it first:

1. Upload your MP3 file
2. Get a timestamp proof on blockchain
3. Later if someone claims they wrote it, you can prove your file existed earlier

Next Steps:

• Set up MetaMask
• Get free test ETH from a faucet
• Start coding the hash calculator
• Test with small text files first

Would you like me to elaborate on any specific part or provide the complete code for a different tech stack (like Python-only version)?