Best Blockchain Training Institute in Delhi 2026

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

/// @title Provenance
/// @notice Records the chain of custody for a physical product.
/// @dev Deployed on a permissioned testnet where only approved
///      manufacturers, shippers, and retailers can write.

contract Provenance {
    enum Stage { Manufactured, InTransit, Customs, Delivered, Recalled }

    struct Checkpoint {
        Stage stage;
        string location;
        address actor;
        uint256 timestamp;
        string documentHash;   // hash of an off-chain document
    }

    mapping(bytes32 => Checkpoint[]) private history;
    mapping(address => bool) public isAuthorized;
    address public admin;
    uint256 public checkpointCount;

    event CheckpointRecorded(
        bytes32 indexed productId,
        Stage stage,
        address indexed actor,
        uint256 timestamp
    );

    modifier onlyAuthorized() {
        require(isAuthorized[msg.sender], "Not an authorized party");
        _;
    }

    constructor() {
        admin = msg.sender;
        isAuthorized[msg.sender] = true;
    }

    function authorize(address party) external {
        require(msg.sender == admin, "Admin only");
        isAuthorized[party] = true;
    }

    function record(
        bytes32 productId,
        Stage stage,
        string calldata location,
        string calldata documentHash
    ) external onlyAuthorized {
        history[productId].push(Checkpoint({
            stage: stage,
            location: location,
            actor: msg.sender,
            timestamp: block.timestamp,
            documentHash: documentHash
        }));
        checkpointCount++;
        emit CheckpointRecorded(productId, stage, msg.sender, block.timestamp);
    }

    function getHistory(bytes32 productId)
        external
        view
        returns (Checkpoint[] memory)
    {
        return history[productId];
    }
}

// What enterprise interviewers look for:
// - Only authorized parties can write — this is the whole point
//   of a permissioned network.
// - Every checkpoint records WHO, WHERE, WHEN, and a hash of
//   the supporting document.
// - The on-chain record is a hash, not the document itself —
//   PII and business data stay off-chain.
// - Events are emitted for off-chain indexing and monitoring.
// - The contract is small and readable — not a monolith.
//
// Why companies do this:
// - A recalled batch can be traced to the exact stage and location.
// - Regulators get an immutable audit trail.
// - No single party can rewrite history.

// vulnerable_contract.sol — a contract with a reentrancy bug
// Every blockchain security course in Delhi should teach you
// how to spot this.

// VULNERABLE
contract VulnerableBank {
    mapping(address => uint256) public balances;

    function deposit() external payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw() external {
        uint256 balance = balances[msg.sender];
        require(balance > 0, "No balance");

        // BUG: sends ETH before updating state
        (bool success, ) = msg.sender.call{value: balance}("");
        require(success, "Transfer failed");

        balances[msg.sender] = 0;   // too late
    }
}

// ATTACK CONTRACT
contract Attacker {
    VulnerableBank public bank;

    constructor(address _bank) {
        bank = VulnerableBank(_bank);
    }

    function attack() external payable {
        bank.deposit{value: msg.value}();
        bank.withdraw();
    }

    // Called when the bank sends ETH — re-enters withdraw()
    receive() external payable {
        if (address(bank).balance >= msg.value) {
            bank.withdraw();
        }
    }
}

// FIXED — checks-effects-interactions pattern
contract SafeBank {
    mapping(address => uint256) public balances;

    function deposit() external payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw() external {
        uint256 balance = balances[msg.sender];
        require(balance > 0, "No balance");

        // Fix: update state BEFORE external call
        balances[msg.sender] = 0;

        (bool success, ) = msg.sender.call{value: balance}("");
        require(success, "Transfer failed");
    }
}

// What a top blockchain course teaches:
// - Why reentrancy is dangerous (The DAO hack, 2016)
// - How checks-effects-interactions prevents it
// - How to spot the same pattern in other contracts
// - How to use tools like Slither and MythX to find it
//
// What a weak course teaches:
// - "Write a contract that works" — no security training.
// - No audit practice, no testnet deployments.
// - No discussion of real exploits.
//
// Why this matters for Delhi jobs:
// - Fintech and DeFi companies in Delhi NCR will ask you about
//   reentrancy in the interview. If you cannot explain it, you
//   will not pass the security round.
# - A portfolio project that includes a security audit shows
#   you understand the real risks of the technology.

# deploy_to_testnet.py — deploying a smart contract to a real testnet
# Every blockchain training institute in Delhi should include this.

from web3 import Web3
import json

# Connect to a Sepolia testnet RPC (free via Alchemy/Infura)
w3 = Web3(Web3.HTTPProvider("https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY"))

# Load the compiled contract
with open("build/Provenance.json") as f:
    contract_data = json.load(f)

abi = contract_data["abi"]
bytecode = contract_data["bytecode"]

# Instantiate contract factory
Contract = w3.eth.contract(abi=abi, bytecode=bytecode)

# Build and send the deployment transaction
account = w3.eth.account.from_key("YOUR_PRIVATE_KEY")

tx = Contract.constructor().build_transaction({
    "from": account.address,
    "nonce": w3.eth.get_transaction_count(account.address),
    "gas": 3_000_000,
    "gasPrice": w3.eth.gas_price,
})

signed = account.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

print(f"Contract deployed at: {receipt.contractAddress}")

# Why this matters:
# - Companies do not hire people who can only write contracts
#   in a local test environment.
# - Deploying to a testnet proves you understand gas, nonces,
#   and the transaction lifecycle.
# - Every real interview includes "have you deployed to a
#   testnet? What did it cost?"
#
# What a great course includes:
# - A guided deployment to Sepolia or a similar testnet
# - Instructions on getting free testnet ETH from a faucet
# - Verification on Etherscan
# - A live contract address you can share on your resume
#
# What a weak course skips:
# - Local-only testing, no real network deployment
# - No discussion of gas costs, nonces, or failed transactions
# - No Etherscan verification — so the contract cannot be
#   inspected by an employer