touchgrass

touchgrass: Run, Explore, and Mine the Real World

touchgrass is a gamified running app that turns outdoor activity into an on-chain data mining experience.

When users go out for a run, they stream their GPS coordinates through Yellow Network’s state channels. This live, off-chain stream forms the backbone of a session — allowing real-time location updates, multiplayer awareness, and low-latency gameplay.

While running, users can “mine” datacoins by completing real-world data quests: spotting potholes, EV chargers, water fountains, or any valuable urban dataset. Each quest represents a small “data job” — when a user submits a photo and proof, the app packages it into a ZK-TLS attestation (zero-knowledge time-location proof) and sends it to the backend for validation. A lightweight LLM validator checks the submission (e.g., “is this really a pothole?”) and confirms the claim’s accuracy.

If the data is valid, the event is emitted through Yellow’s state channel as a datacoin capture, and the runner is rewarded with a minted datacoin NFT — representing a verifiable, user-contributed data point anchored to the real world.

When the user presses STOP, the session closes:

• The final state (distance, route, and validated datacoin captures) is settled on-chain via Yellow’s channel settlement.
• The datacoins mined during the session become claimable on-chain assets, each tied to a verifiable proof of work (running + data capture).

On the frontend, a Mapbox-powered interface visualizes everything live:

• active runners around you (via Yellow’s real-time state feed)
• datacoin markers appearing as users mine real-world data
• a leaderboard that aggregates who has contributed the most verified data

Under the hood:

• Next.js web app for frontend
• Yellow Network state channels for real-time GPS streaming and off-chain state consensus
• LLM validator service for automatic data quality checks
• ZK-TLS proofs for privacy-preserving location attestation
• Datacoin smart contract for on-chain minting and reward settlement
• MongoDB for persistence (runs, users, datacoins, proofs)

Why this matters

touchgrass transforms outdoor movement into a decentralized sensing network. Instead of mining digital blocks, runners mine physical data — building an open, verified map of real-world insights: where potholes exist, where clean water points are, where EV chargers work. Every step becomes a datapoint, and every verified submission turns into a tokenized contribution to a collective data layer.

In short: touchgrass bridges movement, data provenance, and decentralized rewards — powered by Yellow’s state channels for real-time off-chain interaction and on-chain finality.

touchgrass is built as a Next.js web app that uses Yellow Network state channels to stream real-world movement data and Lighthouse’s Datacoin SDK to mint verifiable, rewardable consumer data assets.

When a runner hits START, their GPS coordinates begin streaming through a Yellow clearnet state channel to our backend peer. This off-chain state channel provides a low-latency, verifiable stream of location updates while keeping everything off-chain until the session ends. The backend aggregates those updates, anchors them in MongoDB, and broadcasts live map changes to nearby players in real time.

While running, users can complete data quests — such as mapping potholes, EV chargers, or water fountains. When a user submits a photo, the backend uses Reclaim Protocol’s zkTLS proofs to attest to location and time without revealing sensitive GPS data. We then run a lightweight LLM-based validator to verify the content of the submission (for example, confirming that the image truly contains a pothole).

If the data is valid, we mint a Datacoin using the Lighthouse SDK — encoding the data’s proof, metadata, and contributor wallet into a verifiable token on-chain. Each Datacoin represents a useful, privacy-preserving, user-contributed data point that can be queried or traded later as part of an open data economy.

When the runner presses STOP, the Yellow state channel finalizes the session:

• the off-chain state (distance, movement, mined datacoins) is settled on-chain,
• rewards are distributed to the user’s wallet,
• and the data contributions are finalized via Lighthouse’s Datacoin protocol.

The frontend uses Mapbox GL JS for live visualization — showing nearby runners, mined datacoins, and verified quest markers — while the backend (Node + MongoDB) maintains persistent state and proof data. We also added a JS-based lat/lon bucketing system to map territory and manage channel routing efficiently across the world.

Stack summary:

• Next.js for the web app UI
• Yellow Network for off-chain state channels and realtime GPS sync
• Lighthouse SDK for Datacoin minting
• Reclaim Protocol + zkTLS for privacy-preserving proof-of-location
• LLM Validator for content validation
• MongoDB for persistence
• Mapbox GL JS for the live interactive map

Notable hack: We cached Mapbox tile hashes locally to generate deterministic zkTLS proofs quickly, allowing near real-time Datacoin minting from field data without repeated external API calls.