Hydra-IoT Core: A native C++ SDK for Cardano DePIN

[Proposal setup] Proposal title

Please provide your proposal title

Hydra-IoT Core: A native C++ SDK for Cardano DePIN

[Proposal Summary] Budget Information

Enter the amount of funding you are requesting in ADA

159650

[Proposal Summary] Time

Please specify how many months you expect your project to last

12

[Proposal Summary] Translation Information

Please indicate if your proposal has been auto-translated

No

Original Language

en

[Proposal Summary] Problem Statement

What is the problem you want to solve?

IoT needs blockchain, but L1 is too slow/costly for high-frequency data. Cardano lacks a C++ SDK for IoT, especially one built for L2 (Hydra) scaling, blocking real-world adoption.

[Proposal Summary] Supporting Documentation

Supporting links

• https://docs.google.com/document/d/1kv5Z8FIRZevmnN_z_nLo0aqwrhdz0bZJFlY5r9DXnro/edit?usp=sharing

[Proposal Summary] Project Dependencies

Does your project have any dependencies on other organizations, technical or otherwise?

No

Describe any dependencies or write 'No dependencies'

No dependencies

[Proposal Summary] Project Open Source

Will your project's outputs be fully open source?

Yes

Please provide details on the intellectual property (IP) status of your project outputs, including whether they will be released as open source or retained under another licence.

We will use the MIT License to ensure maximum adoption for both open-source developers and commercial enterprises. The entire project (including C++ source code, documentation, and examples) will be publicly available on a dedicated GitHub repository from the start of the project.

[Theme Selection] Theme

Please choose the most relevant theme and tag related to the outcomes of your proposal

IoT

[Campaign Category] Category Questions

Describe what makes your idea innovative compared to what has been previously launched in the market (whether by you or others).

The first native C++ Hydra client: Currently, Cardano lacks a C++ SDK for the Hydra Layer 2 protocol. This blocks 90% of embedded devices (which run on C++) from using Cardano. We are building the first solution to bridge this gap.

Unique "stateless" architecture: We introduce a "gateway-centric" design. The low-power IoT device handles simple cryptographic signing locally, while the heavy Hydra state machine logic is offloaded to a gateway. This innovation makes L2 scaling technically feasible on battery-powered chips for the first time.

Describe what your prototype or MVP will demonstrate, and where it can be accessed.

Production-grade v1.0 on mainnet: We commit to delivering Hydra-IoT Core v1.0 as a production-ready library on Cardano mainnet, going beyond typical testnet-only pilots. The "sensor-to-settlement" demo: By the project close-out, we will demonstrate a complete lifecycle:

Identity: Minting a persistent device ID (NFT) on the mainnet ledger.

L2 streaming: Opening a Hydra head with real ADA, streaming verifiable sensor data off-chain.

Settlement: Closing the head and settling the final state back to L1.

Access & testing:

Repository: The complete source code will be public on GitHub under an MIT License.

Community testing: We will provide a Dockerized environment (QEMU) allowing community developers to simulate an IoT network and verify the Hydra connection on their local machines without needing physical hardware.

Describe realistic measures of success, ideally with on-chain metrics.

• Quantitative KPIs
  • Developer interest: Achieve 50+ GitHub Stars/Forks and 50+ Unique Clones, indicating active interest and code usage from the community.
  • Adoption (primary goal): Secure 3 pilot startups to integrate the SDK v1.0 for their initial mainnet deployments.
  • On-chain - device registration: ~30-50 transactions specifically for minting device ID NFTs on mainnet.
  • On-chain - settlement: ~150+ settlement transactions resulting from Hydra head open/close cycles for data aggregation or payment.
  • Education: Achieve 150+ unique views on the technical workshop video ("Connecting IoT to Hydra") within the first month of release.
• Qualitative KPIs
  • Technical reliability: Demonstrate a >99% transaction success rate in the MVP's end-to-end stress tests (verifiable via CI/CD logs).
  • Documentation quality: Achieve "self-serve" capability, validated by feedback from the 3 pilot partners confirming they could integrate the SDK successfully using only the provided documentation without direct support.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

The situation: The IoT-blockchain disconnect

The Internet of Things (IoT) is projected to include over 40 billion connected devices by 2030, generating zettabytes of data. This data from smart agriculture sensors, medical devices, and global supply chains is currently siloed in centralized, proprietary servers. This creates massive security risks, single points of failure, and a complete lack of verifiable trust.

Cardano, with its secure, decentralized, and EUTXO-based architecture, is the ideal platform to solve this trust problem. However, two critical barriers are preventing its adoption for any serious, large-scale IoT application:

1. The developer gap: C++ is the dominant language for high-performance and embedded systems. There is currently no robust, well-documented C++ SDK to connect these devices to Cardano, forcing developers to build risky, time-consuming, and incompatible solutions from scratch.
2. The scaling wall (the core problem): A single IoT device can generate thousands of data points per day. A single factory or farm could generate millions. Attempting to post this high-frequency data directly to layer 1 is technically and economically unfeasible. The transaction fees and block confirmation latency would make any real-world IoT project dead on arrival.

Our solution directly solves both of these problems.

Our solution: A Hydra-native Cardano IoT SDK

We will build and deliver a comprehensive, open-source Cardano IoT C++ SDK.

This is not just a simple transaction-building library. It is a sophisticated toolkit designed with a "Hydra-first" architecture. It empowers developers to build applications that use Cardano's layer 1 for unparalleled trust and security, while leveraging the Hydra protocol for the high-throughput, low-cost data streaming that IoT demands.

The "how": A dual-layer architecture

Our SDK will provide developers with distinct tools to manage a "dual-layer" application model, which is the only viable path for scalable IoT on the blockchain.

1. Layer 1 (the "trust anchor") The L1 mainchain is used for high-value, low-frequency events where security and immutability are paramount. Our SDK will provide modules for:
   1. Device identity & provisioning: Registering a device’s unique public key on-chain as a "digital twin."
   2. Smart contract logic: Interacting with Plutus/Aiken smart contracts that define business rules.
   3. Final settlement: Opening and closing Hydra heads to settle the final, aggregated state of L2 data onto the L1 ledger.
2. Layer 2 (the "data highway") The L2 Hydra protocol is used for high-frequency, low-cost data transmission. A group of participants open a "head" to create a private, off-chain mini-ledger. Through the gateway, cryptographically signed data is processed inside the head almost instantly and at near-zero cost.
   1. High-frequency data: A sensor can submit a new temperature reading every second as an off-chain transaction.
   2. Real-time state: All participants in the head see the updated state immediately, enabling real-time actions.
   3. L1 security: The final state is still secured by L1 once the head is closed.

Our SDK's primary innovation is to make this complex L1/L2 interaction simple for a C++ developer.

Core SDK modules & features

The project will be delivered in phases, with the initial version establishing the core foundation.

• Device manager (L1): Manages the on-chain lifecycle of devices. Handles registration, identity verification, and status updates.
• Security layer (L1/L2): Manages the cryptographic keys for both L1 mainchain transactions and L2 off-chain message signing. Ensures secure key storage on-device.
• L1 transaction manager: A robust builder for L1 transactions. Manages UTXOs, fee calculation, metadata attachment, and signing for all L1 operations (including head initialization).
• L1 Cardano client: A "pluggable" client interface for communicating with L1 nodes or APIs to submit L1 transactions and query chain state.
• Hydra client interface (L2): A lightweight C++ communication module designed for IoT devices to:
  • Securely connect and stream signed data to a Hydra gateway (edge node).
  • Construct and sign data payloads using standard cryptography (Ed25519), allowing the gateway to package them into valid Hydra transactions.
  • Submit these L2 transactions to other head participants.
  • Monitor the off-chain state.
  • Participate in head closing and L1 settlement.
• Smart contract integrator (L1): A simplified API for building the Redeemers and Datums needed to interact with common Plutus/Aiken smart contracts.
• Data provenance & utilities: Tools for packaging sensor data with critical metadata (device ID, timestamp, signature) in standard formats (CBOR), plus helpers for logging and error management.
• Energy manager: Provides hooks and operating modes to optimize for battery-powered devices.

Why this solution is vital for Cardano

This SDK is a foundational piece of infrastructure. By solving the C++ developer gap and the L2 scaling problem simultaneously, we:

• Bridge the hardware gap: Currently, embedded devices cannot talk natively to Cardano. This SDK provides the missing C++ driver layer, enabling direct hardware-to-blockchain communication without relying on centralized intermediaries.
• Attract a new developer class: We open the door to the massive global community of C++ and embedded systems engineers, giving them a clear path to build on Cardano.
• Enable new business models: This SDK will allow enterprises to build solutions that were previously impossible, such as auditable supply chains, pay-per-use autonomous machines, and decentralized environmental monitoring networks.
• Drive L1 adoption: Far from ignoring L1, our L2 solution will drive more meaningful L1 traffic by enabling millions of new use cases that all require L1 transactions for identity, security, and final settlement.

[Your Project and Solution] Impact

Please define the positive impact your project will have on the wider Cardano community

This project’s impact is profound because it moves Cardano from a platform theoretically capable of IoT to one that is practically and scalably capable of it.

The challenge has never been just the lack of a C++ SDK; it has been the lack of an SDK that solves the L2 scaling crisis for high-frequency IoT data. Our Hydra C++ client SDK is the key that unlocks this market.

Value to the Cardano community

• For developers: It makes the impossible, possible. We provide a powerful, well-documented C++ toolkit that abstracts the complexity of layer 2. Developers no longer need to choose between "fast and insecure" (centralized) or "secure and slow" (L1-only). We give them a third path: secure L1 trust anchors combined with high-speed L2 data streams. This will attract a new wave of C++ and embedded systems engineers who were previously blocked by L1’s economic and speed limitations.
• For the Cardano ecosystem: Feasible scaling & real-world utility. Our SDK enables feasible network utility. Instead of millions of L1 transactions clogging the network, our solution funnels this high-volume data through layer 2 (Hydra). This drives L1 adoption strategically for opening/closing heads, registering device identities, and settling smart contract payments without sacrificing L1 performance. It turns billions of potential IoT data points from a network-killer into a network-enhancer.
• For enterprises & startups: Unlocking trillion-dollar markets. This SDK is the foundational infrastructure for new, trust-based business models. It enables: - Verifiable supply chains: Proving every step of a cold-storage shipment with 100% data integrity. - "Pay-as-you-go" machines: Autonomous devices that transact based on real-time data feeds. - Decentralized oracles: Creating trusted, high-frequency data feeds directly from the source. - Smart asset management: Real-time tracking and automation for industrial and agricultural IoT.
• For Cardano's competitive position. This positions Cardano as the only major blockchain with a clear, developer-ready, C++-native solution for scalable IoT. While other chains struggle with L1 data bottlenecks or complex, non-native L2s, Cardano will have a purpose-built toolkit ready for real-world deployment.

How we will share outputs

We are committed to total transparency and ecosystem empowerment:

1. Open-source repository (GitHub): The complete SDK, all code, and examples will be publicly available on GitHub under an MIT License from day one.
2. Comprehensive documentation: We will publish a high-quality documentation website with API references, "getting started" guides, and most importantly in-depth tutorials on building L2 Hydra-powered IoT applications.
3. Community education: We will host live-coding workshops and webinars to demonstrate the SDK's power. We will post these recordings on YouTube for permanent access.
4. Regular updates: We will share progress, celebrate community projects, and provide technical insights via X (Twitter), Cardano Forums, and project-specific channels.
5. Formal reporting: All Proof of Achievement (PoA) reports and the final project close-out report and video will be submitted and shared with the community.

[Your Project and Solution] Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

We are a group of developers with practical experience in industrial IoT, embedded systems, and blockchain architecture. We started building on Cardano in early 2024 and have won the Cardano Vietnam Hackathon in both 2024 and 2025.

Our team combines two main skill sets. Some of us have spent years in firmware development, optimizing C++ for hardware devices. Others come from a Web3 background, focusing on layer 2 scaling and data handling. This mix allows us to build infrastructure that works efficiently on both physical devices and the blockchain.

We focus on solving real technical constraints like memory limits and network latency rather than just following market trends. Our goal is simple: to provide reliable tools that embedded engineers and DePIN architects can actually use. Hydra-IoT Core is a working platform built to address these specific needs.

[Milestones] Project Milestones

Milestone Title

Foundation & systems architecture

Milestone Outputs

• System architecture & memory design: Comprehensive technical diagrams (UML) defining the "client-gateway" data flow and static memory management strategy for constrained devices.
• IoT threat modeling: A security analysis report using the STRIDE methodology to identify physical and network attack vectors specific to DePIN hardware.
• API definition & C++ headers: Complete set of C++ header files (.h) defining the SDK's public interfaces, strictly typed and compliant with C++17 standards.
• Dev environment & CI/CD setup: Dockerized cross-compilation environment (ARM/x86) and GitHub Actions workflow.

Acceptance Criteria

• Design document must define memory ownership (stack vs. heap) and concurrency models.
• Threat report must list specific physical and network risks for DePIN hardware.
• Header files must be syntactically correct C++17/20 and compile without errors.
• GitHub Actions logs must show a successful build environment initialization.

Evidence of Completion

• Link to the "architecture & design" document in the GitHub repository.
• Link to the "threat model analysis" report.
• Link to the specific folder containing the .hpp header files.
• Link to the Dockerfile and successful GitHub Actions run logs.

Delivery Month

1

Cost

15830

Progress

10 %

Milestone Title

Core development & embedded security

Milestone Outputs

• Device identity & provisioning: C++ module for decentralized device identity (DID) creation and secure provisioning via BLE/NFC.
• Embedded crypto & secure element HAL: Optimized Ed25519/Sodium wrappers for ARM Cortex-M, including a hardware abstraction layer (HAL) for secure elements.
• Data signing & provenance engine: Logic to cryptographically sign sensor data payloads at the source using Merkle tree batching.
• Unit tests & QEMU emulation: Unit test suite configured to run on QEMU emulators within the CI pipeline.
• Internal API documentation: Doxygen-generated reference documentation.

Acceptance Criteria

• The C++ module must successfully generate a DID and keypair when triggered by a BLE/NFC event (or mock interface).
• The HAL must compile successfully for ARM Cortex-M targets and demonstrate separation between software logic and hardware security module calls.
• The signing engine must successfully batch data into a Merkle tree and produce a root hash signed by the device's private key.
• CI/CD pipeline (GitHub Actions) must successfully boot the QEMU emulator and pass all unit tests with >85% code coverage.
• Doxygen must run without errors and generate a navigable HTML documentation site covering all internal APIs.

Evidence of Completion

• Link to video demonstration showing the device provisioning flow and DID generation via the C++ module.
• Link to the GitHub folder containing the ARM-optimized crypto wrappers and HAL header files.
• Link to the signing_engine.cpp source code and a log file showing a valid Merkle tree signature generation.
• Link to the GitHub Actions run logs showing successful execution of tests inside the QEMU emulator.
• Link to the live Doxygen documentation website containing the API references.

Delivery Month

4

Cost

43900

Progress

30 %

Milestone Title

Layer 1 integration & resource optimization

Milestone Outputs

• Smart contract integrator & zero-copy CBOR serialization: Custom C++ implementation of CBOR encoding/decoding for Plutus data (Datum/Redeemer) and scripts that writes directly to network buffers to minimize RAM usage.
• UTXO management & Tx building: Deterministic coin selection algorithm (FIFO) and logic to construct valid Cardano L1 transactions.
• Energy & network manager: Intelligent network scheduler using CoAP/UDP protocols and "wake-on-radio" logic.
• Cardano lite client (C++): Lightweight client interface to query blockchain state via Blockfrost/Ogmios.
• Integration testing: End-to-end tests verifying L1 transaction submission on testnet.

Acceptance Criteria

• Benchmark logs must demonstrate that CBOR serialization stays within the defined RAM budget for constrained devices.
• The Tx builder must construct a transaction that passes validation rules (fee, inputs, outputs) without errors.
• Network manager code must compile and implement the specified sleep/wake logic.
• Lite client must successfully authenticate and retrieve UTXO data from the provider API.
• A valid transaction must be submitted to the Cardano preprod/preview testnet.

Evidence of Completion

• Link to the CBOR engine source code and memory usage benchmark report.
• Link to the tx_builder module source code.
• Link to the network_manager source code.
• Link to the lite_client source code.
• Link to video demonstration of L1 transaction submission and a link to the transaction hash (Tx ID) on a testnet explorer.

Delivery Month

7

Cost

40680

Progress

70 %

Milestone Title

Layer 2 (Hydra) integration & scalability

Milestone Outputs

• Hydra head protocol client (C++): Robust WebSocket client handling the Hydra head state machine (Init, Open, Closed) and message exchange.
• State sync & flash persistence: Mechanism to atomically write channel state (snapshots) to non-volatile flash memory.
• Error handling & watchtower logic: Logic that checks head status upon reconnection and alerts if a contestation period is active.
• Private beta coordination: Coordination of a closed beta test with selected developers.

Acceptance Criteria

• The C++ client must successfully open a WebSocket connection to a Hydra node and complete a handshake.
• The device must retain the correct head state (snapshot) after a simulated power loss and reboot.
• The watchtower module must correctly identify "Open" or "Closed" head status upon network reconnection.
• A beta test report must be generated containing feedback from at least 3 external developer participants.

Evidence of Completion

• Link to the Hydra client WebSocket source code.
• Video demonstration of the "power-loss recovery" scenario where the device reboots and resumes the state.
• Link to the watchtower/error handling source code.
• Link to the "beta testing summary report" (PDF/MD).

Delivery Month

10

Cost

32790

Progress

90 %

Milestone Title

Release engineering, documentation & close-out

Milestone Outputs

• Open source packaging: Code cleanup, licensing, and creation of package manager scripts (CMake, PlatformIO).
• Developer portal: Deployment of a documentation site (Docusaurus) with tutorials.
• Technical integration support & workshop: 1 month of dedicated engineering support for beta integrators and a recorded technical workshop.
• Final report & impact video: Submission of the mandatory project close-out report and video.

Acceptance Criteria

• The SDK must include a CMakeLists.txt or library.json allowing it to be installed as a dependency in a standard C++ project.
• The documentation portal must be publicly accessible and include a "Hydra IoT" specific tutorial.
• A workshop video demonstrating the SDK must be uploaded to a public video platform.
• The final report and close-out video must be submitted to and approved by the Catalyst team.

Evidence of Completion

• Link to the GitHub release v1.0 and package script files.
• Link to the live developer documentation website.
• Link to the "Connecting IoT to Hydra" workshop video.
• Link to the submitted project close-out report and video.

Delivery Month

12

Cost

26450

Progress

100 %

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

The budget is allocated based on engineering effort (estimated at ~88 ADA/hour for embedded/blockchain engineers) and essential project overheads.

• Foundation & architecture (15,830 ADA): Allocated for senior system architect time (~195 hours) to design a memory-safe architecture and conduct STRIDE threat modeling.
  • Tasks:
    • System architecture & memory design: (5200 ₳)
    • IoT threat modeling (STRIDE): (5280 ₳)
    • API definition & C++ headers: (3600 ₳)
    • Dev environment & CI/CD setup: (1750 ₳)
• Core development & security (43,900 ADA): ~510 hours of development. This is the most resource-intensive phase involving low-level C++ coding for cryptography (Ed25519 optimization) and hardware abstraction layers to ensure key security.
  • Tasks:
    • Device identity & provisioning: (13200 ₳)
    • Embedded crypto & secure element HAL: (13200 ₳)
    • Data signing & provenance engine: (11000 ₳)
    • Unit tests & QEMU emulation: (4400 ₳)
    • Internal API documentation: (2100 ₳)
• Layer 1 integration & resource optimization (40,680 ADA): ~610 hours for developing the "zero-copy" CBOR engine and transaction builder. This ensures the SDK runs efficiently on RAM-constrained chips.
  • Tasks:
    • Smart contract integrator & zero-copy CBOR serialization: (14080 ₳)
    • UTXO management & Tx building: (8800 ₳)
    • Energy & network manager: (6800 ₳)
    • Cardano lite client (C++): (6800 ₳)
    • Integration testing (testnet): (4200 ₳)
• Layer 2 (Hydra) integration & scalability (32,790 ADA): ~395 hours focused on the Hydra WebSocket client and flash persistence logic. This enables the high-throughput data streaming.
  • Tasks:
    • Hydra head protocol client (C++): (11440 ₳)
    • State sync & flash persistence: (8800 ₳)
    • Error handling & watchtower logic: (8000 ₳)
    • Private beta coordination: (4550 ₳)
• Release engineering, documentation & close-out (26,450 ADA): ~360 hours Covers documentation, packaging, and community support.
  • Tasks:
    • Open source packaging (CMake/PIO): (10000 ₳)
    • Developer portal (docusaurus): (8050 ₳)
    • Technical integration support & workshop: (6650 ₳)
    • Final report & impact video: (1750 ₳)

Detail budget: https://docs.google.com/spreadsheets/d/1JaQ9eTGV_KpoDWv8W6KS49r-_0V5bgoArNNUbrNq-W4/edit?usp=sharing

[Final Pitch] Value for Money

How does the cost of the project represent value for the Cardano ecosystem?

This proposal delivers high ROI (return on investment) by solving a specific technical bottleneck: the lack of a native C++ client for Hydra.

1. Infrastructure efficiency: Currently, any C++ IoT project on Cardano must build its own Hydra connector from scratch. By funding this SDK once, the community removes this cost for all future projects. If this SDK saves just 5 future teams from spending 2 months each on R&D, the project has already paid for itself.
2. Practical scalability: We are not promising theoretical adoption. We are building the necessary "plumbing" to make IoT feasible. Without this L2 SDK, IoT on Cardano remains cost-prohibitive due to L1 fees. This investment opens the door for DePIN developers to migrate to Cardano realistically.
3. Lean budgeting: The requested budget supports a small, specialized team of engineers for 12 months. The costs are derived strictly from local market rates for embedded C++ development, with funds allocated directly to code production and documentation rather than marketing or administrative overhead.

[Self-Assessment] Self-Assessment Checklist

I confirm that evidence of prior research, whitepaper, design, or proof-of-concept is provided.

Yes

I confirm that the proposal includes ecosystem research and uses the findings to either (a) justify its uniqueness over existing solutions or (b) demonstrate the value of its novel approach.

Yes

I confirm that the proposal demonstrates technical capability via verifiable in-house talent or a confirmed development partner (GitHub, LinkedIn, portfolio, etc.)

Yes

I confirm that the proposer and all team members are in good standing with prior Catalyst projects.

Yes

I confirm that the proposal clearly defines the problem and the value of the on-chain utility.

Yes

I confirm that the primary goal of the proposal is a working prototype deployed on at least a Cardano testnet.

Yes

I confirm that the proposal outlines a credible and clear technical plan and architecture.

Yes

I confirm that the budget and timeline (≤ 12 months) are realistic for the proposed work.

Yes

I confirm that the proposal includes a community engagement and feedback plan to amplify prototype adoption with the Cardano ecosystem.

Yes

I confirm that the budget is for future development only; excludes retroactive funding, incentives, giveaways, re-granting, or sub-treasuries.

Yes

[Required Acknowledgements] Consent & Confirmation

I Agree

Yes