RoadShare
Turning Your Car’s Telemetry into Valuable DePIN Data
Modern cars are rolling data machines – yet most of that data never leaves the vehicle. In fact, over 96% of the data generated by connected cars goes unused, trapped in proprietary OEM clouds. This represents a massive untapped resource: insurers, cities, and EV networks crave high-resolution driving data to optimize services. The DePIN (“Decentralized Physical Infrastructure Network”) model flips this around by turning cars into blockchain data nodes. In a DePIN, participants are rewarded for contributing real-world data or services. The RoadShare is a prototype mobile app built with the vision of simulating a car’s telemetry stream, visualizing it, and “rewarding” the driver with micropayments. (As context, the connected-car market is already enormous – on the order of ~$116 billion in 2023 – and data monetization is projected to explode over the next decade.)
Building the App on React Native (with Expo)
We built RoadShare as a cross-platform app using React Native on top of Expo. React Native lets us write a single JavaScript/TypeScript codebase for iOS and Android, while Expo provides handy tools and libraries for quick development. The app interface displays live telemetry charts and an earnings counter, and it even includes a map for GPS data. (You can explore the source code on GitHub.) By leveraging React Native, we could tap into many UI and visualization libraries (for example, native charting components) to plot speed, RPM, fuel level, engine temp, GPS traces, and any diagnostic codes. In one implementation detail, we used react-native-chart-kit to render line charts for each numeric stream. The user interface is straightforward: it shows gauges or charts for each metric, updated over time, along with buttons or toggles to pause the stream or switch views. (For example, a code snippet might look like:
No special citations are needed for these implementation details beyond React Native’s own docs but suffice it to say the UI threads the telemetry into a clean dashboard.
Here’s a quick demo video
Streaming Synthetic Telemetry Data
Behind the scenes, we simulate a 24-hour stream of car sensor data using synthetic logs from DeCharge. These include typical On-Board Diagnostics (OBD-II) fields like speed, RPM, fuel level, engine temperature, GPS coordinates, and Diagnostic Trouble Codes (DTCs). (DTCs are the fault codes that a car’s computer emits when it detects an issue.) The synthetic log files mimic what an actual connected car might produce over a day of driving. The React Native app reads these logs like a live stream: every few seconds it fetches the next batch of data points. The app then visualizes each metric in real time – for instance, updating a speedometer gauge or plotting a scrolling line chart of engine temperature.
For demonstration, our app cycles through these synthetic drives so you can watch values change. (For example, if speed exceeds 60 km/h, the chart spikes; if the engine overheats, the temperature gauge jumps.) We took inspiration from other projects in this space – for example, one hackathon write-up notes that a React Native client can “simulate trips” and decide what fields to share. In our case, the entire dataset is public (since it’s synthetic), but we mimic the idea of opting in by having the app continuously stream and display all fields.
Earnings Simulation Model
One of the core features is a micropayment reward simulation: the app “pays out” for each data point according to a simple rule set. This models how a DePIN might pay users for valuable data. In our demo, the base rate is $0.001 per data point. Then we add bonuses for higher-value conditions:
Speed Bonus: If the reported speed is > 60 km/h, add +$0.0005 for that point (higher-speed data is often more valuable for real-world driving patterns).
DTC Bonus: If the data point includes any Diagnostic Trouble Codes, add +$0.002 (indicating potentially useful fault/event data).
Engine Temp Bonus: If engine temperature is very high or very low (an “extreme” reading outside normal range), add +$0.001.
Market Fluctuation: To simulate market variability, we also randomly add or subtract up to $0.0005 from each point’s total.
This model can be summarized in code or text, but it’s easiest to show as a bullet list in the app’s documentation or even in-app tooltip. Essentially:
Base rate: $0.001
+$0.0005 if speed > 60 km/h
+$0.002 if any DTCs are present
+$0.001 if engine temp is out-of-bounds
±$0.0005 random fluctuation
As the synthetic data streams in, the app applies these rules per data point and accumulates a running “balance” on screen. For example, at time t the app might display: “Data points: 3,000 | Earnings: $3.45” and update it in real time as more data flows. This gamifies the experience and illustrates the DePIN concept: your car (as a node) is literally earning money by sharing telemetry data.
Para Authentication
We also integrated Para for user authentication. Para is a cross-chain identity platform that handles login with wallets, social logins, biometrics, etc. It’s designed for Web3 apps and “bridges the gap between traditional authentication and blockchain security”. In practice, we embedded Para’s React Native SDK so that when a user opens the app, they see a Para login modal. They can log in via email/ social or connect a Solana wallet (Para even supports cross-chain flows). Under the hood, Para’s framework uses multi-party computation and secure enclaves to manage keys, but from our side it just gives us a unique user ID. Once logged in, the user’s session is tied to the data they generate – in a real DePIN this could link to on-chain rewards or profiles. For the demo we didn’t do actual on-chain payments, but you can imagine extending this: Para-authenticated users could sync their earnings to a wallet for $DLP tokens, for example. The important point is that Para makes it easy to add Web3 login without writing complex auth code.
Architecture Overview
The system architecture is quite simple, designed to be a straightforward data flow
Synthetic Car Logs: Pre-generated CSV or JSON files containing 24h of telemetry, served locally or via mock API.
React Native App: The mobile client (built with Expo) reads the logs like a live stream and processes each data point.
Visualization UI & Earnings Module: Inside the app, the data is plotted (speedometer, charts, etc.) and run through the earnings rules described above. The UI updates in real time.
Para Auth: Users log in via Para at startup; their identity is associated with the session and any “earned” balance.
This hand-drawn flow chart illustrates the idea: the synthetic data flows into our app, which both visualizes the logs (charts, maps, gauges) and runs the simple economic model to simulate rewards. Para sits alongside as the gatekeeper for users. Because this is a prototype, all data and calculations are done client-side. However, one could easily extend this: for instance, the app could submit aggregated data summaries to a smart contract or lock the simulated earnings into a DeCharge vault. But even as-is, the Car-as-a-Node Explorer shows how car telemetry can be treated like any other sensor in a DePIN – the car becomes a node.
What’s Next
Currently, the RoadShare is a proof-of-concept MVP powered by synthetic data and local logic. But our long-term vision goes far beyond simulation. In the future, we plan to integrate the app with real vehicles using OBD-II Bluetooth dongles or native in-car telemetry systems. This will enable the app to stream live driving data directly from your car in real time. With Para’s embedded wallet, users will be able to sign transactions on Solana seamlessly and share their data on-chain — earning real crypto rewards as they drive. Each car becomes a live DePIN node, contributing valuable telemetry (like speed, fuel, engine status, location) to a decentralized data marketplace. As more vehicles connect, the ecosystem grows into a global DePIN network — one where users truly own their data and are rewarded for contributing it.
Try It & Explore the Code
If you’re interested in decentralized car data or building Web3 mobile apps, give RoadShare a try. You can find the full source code here. The repo includes setup instructions (it’s an Expo app, so running expo start will launch it) and synthetic log samples. Feel free to fork it, add your own datasets, tweak the earnings model, or connect it to a live car via Bluetooth OBD-II!
In summary, this project is a proof of concept that showcases how we might build a DePIN for car data. By streaming telemetry, visualizing it, and modeling token rewards, we turn a daily drive into a data node. It’s a small step toward a future where drivers are compensated for the data their vehicles produce – just by taking the highway.