Proof-of-Coverage

Proof-of-Coverage uses radio frequency (RF) challenges to cryptographically prove a Hotspot's physical location. The core mechanism involves:

• Beaconing: Hotspots broadcast a small data packet (a beacon) that nearby peers must witness.
• Witnessing: Neighboring Hotspots receive and sign the beacon, creating cryptographic proof of RF reception.
• Challenge Construction: The network randomly selects a Challengee to transmit a beacon and Witnesses to receive it, creating an unforgeable proof of physical presence and coverage.

The protocol operates on a deterministic schedule that defines when and where challenges occur, creating a verifiable ledger of network coverage over time.

• Epochs & Consensus Groups: Time is divided into epochs. For each epoch, a randomly selected Consensus Group of nodes is responsible for creating blocks and issuing challenges.
• Deterministic Scheduling: The challenge target, witnesses, and timing are derived from the blockchain state, making the process predictable and auditable.
• Coverage Map: The aggregate of all successful challenge receipts forms a continuously updated, decentralized map of proven wireless coverage.

Proof-of-Coverage is specifically designed to prevent Sybil attacks (creating fake nodes) and location spoofing (faking a node's position). Key defenses include:

• RF Physics: Spoofing a radio signal's receipt from a specific location is extremely difficult without physical hardware present.
• Challenge Distance & RSSI: The protocol analyzes the Received Signal Strength Indicator (RSSI) and the claimed distance between challenger and witness to detect anomalies.
• Penalties: Nodes that provide invalid proofs or are consistently unreachable have their mining rewards reduced (denylist status), disincentivizing malicious behavior.

Unlike compute-intensive Proof-of-Work, Proof-of-Coverage is designed for low-power, low-cost hardware (like Raspberry Pi-based Hotspots).

• Efficient Challenges: The RF data packets are tiny, and the cryptographic verification of witness signatures is computationally cheap.
• Off-Chain Execution: The RF challenge and response happen off-chain. Only the resulting proof (a small cryptographic receipt) is submitted to the blockchain.
• Scalability: This design allows thousands of nodes to participate in consensus without congesting the underlying blockchain with massive data transfers.

Proof-of-Coverage differs fundamentally from other major consensus mechanisms:

• vs. Proof-of-Work (PoW): Replaces energy-intensive hashing with lightweight RF verification. Secures a physical resource (location/coverage) instead of computational power.
• vs. Proof-of-Stake (PoS): Does not require capital lock-up (staking). Participation and rewards are based on providing a useful, verifiable service (wireless coverage).
• vs. Proof-of-Authority (PoA): Permissionless and decentralized. Any participant can join the network by deploying a Hotspot, without requiring a pre-approved identity.

A PoC challenge is a multi-step cryptographic process that validates a hotspot's location and operational integrity.

• 1. Beacon Creation: A Challenger hotspot creates a beacon (a data packet) and broadcasts it via radio.
• 2. Witnessing: Neighboring Witness hotspots within range receive the beacon and submit cryptographic receipts to the blockchain.
• 3. Proof Aggregation: The Target hotspot's location and signal strength are verified by correlating the witness receipts, creating a valid Proof-of-Coverage.

PoC's core function is to prevent location spoofing, where a node falsely claims to be in a valuable, underserved area. The mechanism enforces this through:

• Hex Grid System: The world is divided into hexagons (Res 4-12), and rewards are optimized for one hotspot per hex.
• RF Proof: Physical radio transmission is required; a spoofed node cannot produce valid witness receipts from legitimate neighbors.
• Penalties: Invalid proofs or spoofing attempts result in slashed rewards or removal from the consensus group.

Beyond location verification, PoC-secured networks enable real-world data transfer. IoT devices (sensors, trackers) use the LoRaWAN coverage provided by validated hotspots.

• Device Uplink: An IoT device sends data to a nearby hotspot.
• Network Routing: The hotspot packages the data into a Data Credit transaction on the blockchain.
• Oracle Integration: Data Oracles (like Pythia) relay this off-chain sensor data to external applications and APIs, completing the utility loop.

The aggregate result of PoC challenges creates a live, verifiable coverage map of the entire network. This is critical for:

• Network Auditing: Operators and the community can audit coverage claims via blockchain explorers.
• Reward Optimization: Hotspot owners can identify gaps in coverage to optimize placement and earnings.
• Carrier Analytics: Mobile operators can assess the quality and density of decentralized network infrastructure before integration.

A spoofing attack occurs when a malicious node attempts to falsely prove it is providing wireless coverage from a specific location. This undermines the network's integrity and can be executed by:

• GPS Spoofing: Broadcasting false GPS coordinates to appear in a target location.
• Signal Relay: Relaying valid RF signals from a legitimate Hotspot to a dishonest one.
• Virtualization: Running the mining software on a virtual machine without the required radio hardware.

A Sybil attack involves a single entity controlling multiple, seemingly independent network nodes (Hotspots). In PoC, this allows an attacker to:

• Self-Challenge: Challenge their own colluding nodes, guaranteeing successful Proof-of-Coverage receipts.
• Manipulate Consensus: Gain disproportionate influence over network consensus and rewards.
• Exploit Density Rules: Place many nodes in a single hexagon to unfairly maximize rewards, violating the network's scaling model.

The core security primitive is a cryptographic challenge-response protocol. Validator nodes (or beacons) issue encrypted challenges to target Hotspots, which must be witnessed by others.

• Challenge Construction: A validator creates a packet with a target Hotspot's address and a random nonce.
• RF Transmission: The target Hotspot must transmit the packet over its radio.
• Witness Verification: Neighboring Hotspots receive the transmission and submit cryptographic proofs (witness receipts) to the blockchain, creating an immutable audit trail.

The protocol enforces honesty through a transparent penalty system. Automated checks invalidate PoC receipts and slash rewards for suspicious activity. Key penalties target:

• Invalid Witnesses: Receipts from witnesses too far away (impossible RF travel time).
• RSSI/SNR Anomalies: Signal strength or noise ratios inconsistent with claimed distance.
• Density Violations: Rewards are scaled down for Hotspots too close to others, disincentivizing Sybil clusters.
• Spoofing Detection: Consistent failure to be witnessed or abnormal challenge success rates trigger investigation and potential blacklisting.

The system relies on trusted oracles and off-chain data for critical decisions, creating potential centralization risks.

• Location Assertion: Hotspots must assert their location (via GPS) to an oracle, which can be spoofed.
• Data Feed Reliance: Network metrics like transmit scale are calculated off-chain and published via oracles. Compromised oracles could manipulate rewards.
• Validator Selection: The set of Validators issuing challenges is determined by the core protocol; their honest participation is a security assumption.

Security depends on the properties of radio frequency (RF) physics, which can be exploited.

• Jamming: An attacker can broadcast noise on the ISM band (e.g., 868 MHz, 915 MHz) to disrupt legitimate PoC transmissions and witness events.
• Directional Antenna Abuse: Using high-gain directional antennas can make a Hotspot appear closer to witnesses than it physically is, artificially increasing reward scales.
• Topology Manipulation: Strategic placement of a few malicious nodes can disrupt the witness graph for a large area, denying service to honest nodes.