Research Prototype - This is a research system exploring decentralized, blockchain-anchored UAV traffic management. It is not a commercial product.
Drones will revolutionize delivery in the next decade. But the infrastructure to track them, especially in low-altitude city corridors is still missing. DRONA fills this gap with a blockchain-authenticated, node-based traffic layer built from the ground up.
This project addresses questions that remain open in the UTM (Unmanned Traffic Management) research:
- What happens when GPS is jammed, spoofed, or unavailable in dense urban airspace?
- How do you create tamper-proof audit trails for near-miss incidents at scale?
- Local node placement.
- Smart contracts to log drone passage and compliance.
- Decentralized, real-time authentication.
- Designed for lightweight drone logistics over rooftops.
- Community-hosted nodes with potential incentive models.
| Requirement | Version | Notes |
|---|---|---|
| Node.js + npm | v18+ | nodejs.org |
| Python | 3.11+ | python.org |
| Git | any | git-scm.com |
| Mosquitto | 2.x | mosquitto.org/download - install as Windows service |
Mosquitto must be running as a Windows service on port 1883 before starting the system.
# 1. Clone
git clone https://github.com/yashasvi045/drona.git
cd drona
# 2. Smart contract dependencies
npm install
# 3. Python virtual environment + backend/simulation packages
python -m venv .venv
.venv\Scripts\pip install -r backend\requirements.txt
.venv\Scripts\pip install paho-mqtt web3
# 4. Frontend dependencies
cd frontend
npm install
cd ..
# 5. Compile contracts (generates artifacts/ - required before running)
npx hardhat compile.\start.ps1This opens five terminal windows in the correct order:
Hardhat node → contract deploy → backend → simulation → frontend.
The dashboard opens automatically at http://localhost:5173 when ready.
# Terminal 1 - EVM node
npx hardhat node
# Terminal 2 - Deploy contract (after node is up)
npx hardhat run scripts/deploy.js --network localhost
# Terminal 3 - Backend API
.venv\Scripts\python.exe -m uvicorn backend.main:app --port 8001
# Terminal 4 - Drone simulation
.venv\Scripts\python.exe simulation\simulator.py
# Terminal 5 - Frontend
cd frontend && npx vite --port 5173| Service | URL |
|---|---|
| Dashboard | http://localhost:5173 |
| API + docs | http://localhost:8001/docs |
| Health check | http://localhost:8001/health |
| EVM node | http://127.0.0.1:8545 |
| MQTT broker | localhost:1883 |
.venv\Scripts\pip install requests websocket-client # first time only
.venv\Scripts\python.exe test_integration.py
# Expected: 14/14 checks passingQuick stop helper (if configured in your local shell):
.\StopIf you started with ./start.ps1:
- Close the terminal windows it opened (Hardhat, backend, simulation, frontend).
If you started manually, stop each terminal with Ctrl + C.
To stop everything quickly from one PowerShell window:
# Stop listeners used by this stack (frontend, backend, local EVM)
foreach ($p in 5173, 8001, 8545) {
Get-NetTCPConnection -LocalPort $p -State Listen -ErrorAction SilentlyContinue |
Select-Object -ExpandProperty OwningProcess -Unique |
ForEach-Object { Stop-Process -Id $_ -Force -ErrorAction SilentlyContinue }
}Optional: stop Mosquitto too (requires Administrator PowerShell):
Stop-Service -Name Mosquitto -ForceVerify everything is stopped:
foreach ($p in 5173, 8001, 8545, 1883) {
$c = Get-NetTCPConnection -LocalPort $p -State Listen -ErrorAction SilentlyContinue
if ($c) { "Port $p still listening" } else { "Port $p closed" }
}DRONA/
├── contracts/ Solidity smart contracts (DroneRegistry.sol)
├── scripts/ Hardhat deploy scripts
├── test/ Hardhat contract unit tests (16 tests)
├── simulation/ Python drone simulation (Kolkata, 3 drones)
├── backend/ FastAPI server - REST + WebSocket + MQTT ingestion
├── frontend/ React + Vite dashboard (DRONA UI)
├── test_integration.py End-to-end system test (14 checks)
├── start.ps1 One-command startup script (Windows)
└── hardhat.config.js Hardhat config (local network, chainId 1337)
Frontend
- React + Vite - dashboard UI
- Leaflet.js / Mapbox GL JS - real-time drone map
- WebSockets - live position push from backend
Backend
- FastAPI (Python) - async node server and REST APIs
- MQTT - drone telemetry ingestion (IoT standard)
- Redis - live position caching and pub/sub
Blockchain
- Solidity + Hardhat + OpenZeppelin - smart contracts for drone registration, passage logging, compliance
- Web3.py - Python ↔ blockchain bridge
- Polygon / Base (L2) testnet - low gas fee deployment
Data
- PostgreSQL + PostGIS - persistent flight logs with geospatial queries
Infra
- Docker Compose - portable packaging for community-hosted nodes
Blockchain is the compliance/audit layer (async, ~2–15s block confirmation). Real-time tracking runs over MQTT → Redis → WebSocket only, keeping the latency-critical path off-chain.
Why the architecture works:
- Mesh nodes as independent verifiers - each node cross-validates passage without trusting a central server, a practical application of Byzantine fault-tolerant distributed systems.
- On-chain passage logs - immutable, timestamped records of every drone transit through a node. Directly applicable to insurance liability and incident investigation use cases.
- Separation of concerns - real-time control runs entirely off-chain (MQTT → WebSocket), while audit/compliance is written to the chain asynchronously.
- MQTT over cellular - telemetry continues even under GPS degradation, since node proximity is determined independently of satellite positioning.
Known research limitations (intentional trade-offs):
- Blockchain adds per-transaction cost and ~2–15 s confirmation latency - unsuitable for hard real-time control, by design used only as the audit layer.
- In-memory position store is not persistent across restarts - a deliberate simplification for prototype phase.
- Current simulation uses synthetic Kolkata routes; production would require live GNSS feeds.
Copyright © 2026 Yashasvi. All Rights Reserved.