Flight Chain | Devpost

Black boxes haven't changed since the 1960s. They sit in the tail of the plane, record data locally, and wait to be physically dug out of wreckage. The search for Air France 447's black box cost over $40 million and took 23 months. MH370's has never been found, $160 million spent, still open a decade later.

The system the world trusts to explain aviation disasters is a metal cylinder that has to survive the crash, stay intact underwater, and be physically located before anyone learns anything. We thought that was insane. So we asked: what if the black box was never in the plane to begin with?

What it does

FlightChain is a zero-trust aviation emergency system. The moment a crash is detected by an onboard Arduino measuring G-forces, the system:

Instantly pins the final flight telemetry to IPFS via Pinata, permanent, decentralized, tamper-proof
Fires an NFTokenModify transaction on the XRP Ledger to update the aircraft's Dynamic NFT from "Nominal" to "Crash", the plane is officially marked downed on the global ledger in seconds
Moves a 100,000 RLUSD escrow to release-pending, rescue funds unlock automatically, no insurance paperwork, no approval chain
An ElevenLabs AI voice agent broadcasts the mayday, reads the IPFS hash aloud as cryptographic proof, and answers investigator questions in real time

How we built it

Arduino Nano 33 BLE Sense, onboard IMU detects catastrophic G-force anomalies (> 3.5g) at the edge and fires a CRASH_DETECTED signal over USB
Pinata, Python gateway bundles telemetry into JSON and pins it to IPFS, returning a cryptographic CID (Content Identifier) that is mathematically unique to that exact data
XRP Ledger (XLS-46d), we use the new Dynamic NFT amendment to represent the physical aircraft as a living on-chain object. NFTokenModify swaps the URI from the nominal CID to the crash CID atomically
XRPL TokenEscrow + RLUSD, programmable rescue liquidity locked until crash is cryptographically proven on-chain
ElevenLabs Conversational AI, v3 turn model voice agent acts as the autonomous incident commander
Custom MCP Server (Python), Model Context Protocol bridge that lets the ElevenLabs agent read live blockchain and Pinata data mid-conversation

Challenges we ran into

The XLS-46d amendment is newer than most xrpl-py documentation. The library has the TransactionType.NFTOKEN_MODIFY enum value but ships no Transaction subclass for it, we built the entire NFTokenModify typed model from scratch as a frozen dataclass with field validation and hex URI encoding.

We also hit a silent killer early on: minting the NFT without the tfMutable flag set. The first on-chain mint looked successful, but NFTokenModify came back with tecNO_PERMISSION every time. Took a while to realize the NFT itself had to be minted as mutable from the start, you cannot patch that after the fact. Re-minted with NFT_FLAGS = 24 (tfTransferable | tfMutable) and it worked immediately.

Getting hardware, IPFS, blockchain, and AI to fire in the correct sequence under live demo conditions, with real network latency on each leg, was the hardest integration problem we faced.

Accomplishments that we're proud of

A real NFTokenModify transaction confirmed on XRPL testnet, live, with a Pinata CID in the URI field, not mocked, not stubbed, actually on-chain
Building a typed XLS-46d model that doesn't exist in the official library
The full pipeline from edge hardware trigger to on-chain state change works end to end
An MCP server that gives an AI voice agent live read access to blockchain state mid-conversation, something that feels genuinely new

What we learned

Pinata's CID is deterministic for identical data but unique for timestamped payloads, which is exactly what you want for flight telemetry. Every pin is non-reproducible and time-bound. That's not a limitation, that's the feature.

MCP as a bridge between live AI agents and blockchain state is massively underexplored. ElevenLabs reading a live IPFS hash mid-conversation as cryptographic proof to a simulated ATC felt like the future of evidence handling, and it's all running on open standards.

What's next for FlightChain

If every commercial flight continuously pins its telemetry to IPFS after each leg, altitude curves, engine performance, turbulence signatures, fuel burn rates, you accumulate a massive, verifiable, tamper-proof corpus of real-world aviation data. That's not just safety insurance. That's training data.

Every anomaly, every smooth flight, every near-miss becomes a labeled, timestamped, cryptographically verified data point aviation AI models can actually trust, because the provenance is on-chain and immutable. You cannot quietly scrub a near-miss from IPFS the way you can quietly patch a server log.

Current aviation datasets are locked behind airline NDAs and proprietary systems. FlightChain's architecture makes flight data public, sovereign, and auditable by default.