DriverProof

Prove you drove safely without revealing where you drove. DriveProof turns attested private telemetry into a ZK compliance receipt on Midnight.

Comment

Inspiration

Usage-based insurance has a privacy problem.

To answer one simple question did this driver satisfy the safety policy? traditional telematics programs can collect an entire behavioral record: routes, locations, exact speeds, braking events, timestamps, and trip history.

That creates a bad trade-off:

prove you drove safely, or keep your journey private.

DriveProof removes that trade-off.

Prove you drove safely without revealing where you drove.

The key insight is that privacy and integrity are two different problems:

Zero knowledge protects privacy.
Attestation protects integrity.

A ZK proof can prove hidden telemetry satisfies a policy but it cannot prove the driver didn't invent favorable telemetry. So DriveProof first binds the trip to an authorized attestor, then proves the policy over that signed private data.

What it does

DriveProof is a mobile-first PWA for privacy-preserving driving compliance on Midnight.

The Driver receives a signed 16-sample private trip from an authorized telemetry issuer. Each sample contains private grid position, speed, braking-event state, and time bucket.

Our insurer policy requires:

  • every speed ≤ 80 km/h
  • harsh-braking events ≤ 2
  • every sample inside an allowed operating area
  • a valid registered attestor signature
  • the trip to be bound to the private driver subject
  • the attestation to have never been used before

The Driver then generates a zero-knowledge proof with our Compact contract.

If everything passes, Midnight records the minimal compliance result.

The insurer can verify:

  • policy result
  • attestor
  • Midnight transaction
  • block
  • contract metadata

But never receives:

  • route
  • coordinates
  • exact speed history
  • braking history
  • raw telemetry

The driver keeps the journey. The insurer gets the proof.

How we built it

Compact + Midnight

Our Compact contract verifies the complete private statement:

  1. registered attestor
  2. signed trip commitment integrity
  3. subject binding
  4. all 16 speed samples ≤ 80
  5. harsh-braking count ≤ 2
  6. every private position inside the allowed area
  7. replay nullifier unused
  8. nullifier consumption after success

A successful proof produces a public compliance result without publishing the underlying telemetry.

Attestation

For the hackathon we built a Vehicle Attestor Simulator as the prototype trust root.

The attestor owns the trip fixture and signs a commitment to the complete 16-sample measurement. The browser cannot simply choose a better speed or coordinate after the fact changing any committed telemetry invalidates the signature.

In production, that trust root could be replaced by an OEM telematics module, secure vehicle computer, trusted OBD device, or other hardware-backed telemetry issuer.

We intentionally do not claim that our simulator proves physical sensor provenance. DriveProof proves everything after the attestation trust boundary.

Product

DriveProof has two intentionally separate surfaces:

Driver

  • sees the private trip
  • sees telemetry
  • creates the proof

Insurer

  • sees only the public compliance receipt
  • never receives the private trip object

The Driver is built as a phone-sized, mobile-first PWA. The current Preprod wallet flow uses the Lace browser extension.

Real Midnight Preprod

DriveProof is not just a UI prototype.

We validated the final system against real Midnight Preprod:

  • real contract deployment
  • real Lace wallet approval
  • real 16-sample ZK proof
  • real Preprod transaction
  • hosted Driver → proof → Insurer flow
  • public compliance receipt

We also tested the failure boundaries:

  • Replay → Attestation already used
  • 112 km/h sample → Speed exceeds policy limit
  • Outside allowed area → Sample outside policy geofence
  • Tampered telemetry → Invalid attestation signature

The final repository passes:

  • 67/67 root tests
  • 10/10 contract acceptance tests
  • 14/14 attestor tests
  • typecheck and production builds

Challenges we ran into

Privacy is more than hiding UI fields

Removing coordinates from a screen would not have been enough.

We had to design the entire disclosure boundary so the insurer receipt itself only contains explicitly allowed public fields. That led us to separate Driver and Insurer surfaces and keep private witness data out of the receipt model entirely.

ZK does not prove where data came from

This was the most important design lesson.

A perfect ZK proof over fake telemetry is still a proof over fake telemetry.

That is why DriveProof combines ZK with signed attestations:

Zero knowledge protects privacy. Attestation protects integrity.

Real proving infrastructure

The public Preprod proof endpoint worked for lightweight checks but rejected the large binary proof workload used by the real provider.

We eventually deployed the pinned Midnight proof server 8.1.0 separately and validated the complete hosted flow end-to-end.

What we learned

Privacy-preserving applications need two forms of correctness:

Statement correctness:
Does the hidden data satisfy the rules?

Source integrity:
Can we trust where that hidden data came from?

Zero knowledge solves the first.
Attestation helps solve the second.

We also learned that the best privacy design is often to ask:

What does the other party actually need to know?

The insurer does not need a "privacy-friendly version" of the route.

The insurer does not need the route at all.

Why this fits the Mobile Track

DriveProof is designed around a mobile-first private Driver experience.

The Driver can see the route, telemetry, speeds, and braking history.

The verifier only receives the ZK-backed policy result and necessary public metadata.

For the strongest privacy configuration, DriveProof can use the local Midnight proof server so proving remains in the user's environment before submission. Our public hosted deployment uses a remote prover for accessibility, while the same Compact privacy policy remains unchanged.

Business value & what's next

Usage-based insurance is the immediate use case.

Today the model is often:

"Send us your driving history and we'll decide."

DriveProof changes the primitive to:

"Prove this trip satisfied policy AUTO-SAFE-01."

The same architecture could extend to:

  • fleet compliance
  • commercial-driver certification
  • rental-car policies
  • safe-driver discounts
  • privacy-preserving telematics

The next step is replacing our simulated attestor with a real hardware-backed vehicle trust root.

Long term, DriveProof could become a privacy layer for telematics: insurers publish predicates, vehicles prove them, and detailed movement history never needs to become permanent business data.

The driver keeps the journey.
The insurer gets the proof.

Built With

Share this project:

Updates