Aura
An Android marketplace prototype on Solana where an in-person sale is enforced by escrow, co-presence checks, an NFC-signed handover, and an on-chain receipt.
Hackathon build2026BuilderMonolith Solana Mobile Hackathonwith Wasif Waseem and Huaicheng Su
TL;DR
- Marketplace sales break where the software stops: two people leave the app to meet, and nothing can verify the item, the money, or the handover.
- Aura splits trust three ways — the phone guides the exchange, Solana holds the money, and a secure NFC tag proves the physical object was there.
- Four steps: the seller records the item, the buyer locks funds in an Anchor escrow, both devices confirm co-presence, and the tap releases escrow and mints an on-chain receipt.
- The handover had to be provable. An NTAG 424 DNA tag signs a fresh message on every tap and the backend verifies it, so a screenshot or replay cannot stand in for the tap.
- Kotlin and Compose on Android, Anchor and Metaplex on Solana, Supabase Edge Functions for verification.
- A complete hackathon prototype from the Monolith Solana Mobile Hackathon, built with Wasif Waseem and Huaicheng Su. Not deployed, no users.
Where it started
The riskiest part of a marketplace sale happens after the app has done its job.
A buyer finds an item, messages the seller, and agrees on a price. Then both of them leave the marketplace and meet in person. At that point the software has almost no idea what happens next. The item may not match the listing. The buyer may arrive without the money. Either person can walk away with a different account of what happened.
Aura was an attempt to keep the transaction enforceable all the way through the physical handover.
The idea
Split trust across the phone, the blockchain, and the object itself.
The phone is good at guiding the people through the exchange, but it should not be trusted with the money. Solana can hold and release the money, but it cannot see whether a real object changed hands. A secure NFC tag can prove that someone touched the right object at the meetup, but it cannot settle a transaction on its own.
Aura combines those three pieces. None of them is enough by itself. Together they let the next step happen only after the previous one has been verified.
The transaction
From listing to receipt, in four connected steps.
01
The seller records the item
The listing is tied to a specific physical object. It is more than a photo and a price: it becomes the reference the item will be checked against later.
02
The buyer commits the money
Before anyone meets, the buyer moves the agreed amount into an Anchor escrow program. The seller knows the money exists; the buyer knows it cannot be released yet.
03
Both people and the item are checked
At the meetup the devices confirm that buyer and seller are together, then the item is checked against the record created when it was listed.
04
The handover unlocks settlement
An NTAG 424 DNA tag attached to the item signs a fresh message when it is tapped. Once the backend verifies that proof, escrow releases and an on-chain receipt records the exchange.
What was difficult
The handover had to become something software could prove.
Releasing escrow on a button press would have moved the trust problem rather than solved it. The important part of the prototype was the NFC proof. The tag generates a different signed message on each tap, and the verification happens on the backend so the secret never sits inside the Android app. A copied screenshot or a replayed message cannot stand in for the physical tap.
The other constraint was making sure no single layer could finish the sale alone. The app handles the experience. The chain controls the funds. The backend checks the evidence from the real world. Compromising one should not be enough to fake the whole exchange.
How it was built
Three layers, each responsible for one kind of truth.
The Android app
What buyer and seller touch
Kotlin and Compose
Listing, discovery, wallet connection, and the meetup flow
NFC and ML Kit
Read the secure tag and help check the physical item
The Solana programs
What neither person controls
Anchor escrow
Holds the money and enforces when it can move
Metaplex receipt
Records the completed exchange
Helius
Provides the RPC connection to Solana
The backend
What verifies the real world
Supabase
Listings, accounts, and exchange history
Edge Functions
Verify NFC proofs and coordinate settlement without putting secrets on the phone
Stack
Backend
Edge Functions verify NFC payloads and coordinate settlement so keys never reach the client.
Hardware & vision
Where it stands
A complete hackathon prototype, not a consumer product.
I built Aura with Wasif Waseem and Huaicheng Su for the Monolith Solana Mobile Hackathon. We chose to make the entire exchange work: listing, escrow, handover proof, settlement, and receipt, instead of polishing one part for the demo. It showed that the model was technically possible. It was not deployed, has no users, and is not presented here as more than the prototype it was.
