Hydra Hexcore – Tool for Deployment Multi-Hydra Party

[Proposal setup] Proposal title

Please provide your proposal title

Hydra Hexcore – Tool for Deployment Multi-Hydra Party

[Proposal Summary] Budget Information

Enter the amount of funding you are requesting in ADA

95000

[Proposal Summary] Time

Please specify how many months you expect your project to last

6

[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?

Hydra Hexcore solves infrastructure deployment challenges for Hydra by providing automation beyond Docker image & Hydra TUI, avoiding manual setup and custom tooling that slow devs down.

[Proposal Summary] Supporting Documentation

Supporting links

• https://github.com/Vtechcom/hydra-hexcore-design-docs?tab=readme-ov-file
,
• https://youtu.be/wCrZO6rIiWo?si=W3u-2MXiYSGELCjE
,
• https://forum.cardano.org/t/introducing-hydra-hexcore-an-automated-deployment-management-tool-for-multi-hydra-party/144578
,
• https://drive.google.com/file/d/1kFH2Qqpt-YKwzOQr-n74CnfkH0IFdwTB/view?usp=sharing

[Proposal Summary] Project Dependencies

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

Yes

Describe any dependencies or write 'No dependencies'

The stability and documentation of the Hydra protocol are provided by the Cardano development team (IOG). Any major changes to the protocol may affect Hydra Hexcore deployment. Development tools: Related libraries and frameworks (e.g., Docker, Cardano APIs) need to be maintained and updated.

[Proposal Summary] Project Open Source

Will your project's outputs be fully open source?

Yes

License and Additional Information

MIT License

[Theme Selection] Theme

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

Developer Tools

[Campaign Category] Category Questions

Mention your open source license and describe your open source license rationale.

We will release Hydra Hexcore under the MIT License. The rationale behind choosing the MIT License is its simplicity and permissiveness, which aligns with our goal to encourage community contribution, experimentation, and adoption. By using this license, we allow developers and organizations to freely use, modify, distribute, and integrate the project into their own infrastructure — while maintaining attribution to the original authors. This ensures maximum flexibility and helps foster a vibrant open source ecosystem around Hydra and Cardano Layer 2 tooling

How do you make sure your source code is accessible to the public from project start, and people are informed?

The source code will be hosted publicly on GitHub from the beginning of the project. We will create a dedicated repository under our GitHub organization and ensure all components (backend, frontend, CLI, proxy modules) are pushed and version-controlled transparently. The repository will include clear instructions for contributors, and we will share the repository link in all relevant communications — including our Catalyst proposal, community channels (Discord, X). All commits, issues, and milestones will be openly visible to ensure full transparency and traceability

How will you provide high quality documentation?

We will maintain comprehensive and user-friendly documentation throughout the project lifecycle. This includes:

• A structured README with setup instructions, architecture overview, and key links.
• UI screenshots and usage tutorials for Hydra Hexcore’s interface.
• Continuous updates to the documentation as features evolve.

We will also publish the documentation online using tools like GitBook, making it accessible to both developers and non-technical users. Our goal is to make onboarding, contribution, and integration with Hydra as easy and clear as possible.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

1. Introduction

Hydra Hexcore is a dedicated system for managing and operating multiple Hydra Heads on a single server, aiming to simplify the setup, monitoring, and control of nodes within the Hydra network (a Layer 2 scalability solution for Cardano). This project acts as a coordination hub that facilitates the efficient, secure, and user-friendly creation of Hydra Heads.

2. Objectives

• Create a centralized platform to flexibly manage multiple Hydra Heads on the same server.
• Provide an intuitive user interface and convenient command-line tools for system interaction.
• Ensure security, resource reusability, and scalability.

3. Key Features

3.1. Cardano Account Management

Generate and manage skey/vkey key pairs for Cardano accounts.

Accounts are used to bind into node containers during Hydra Head initialization.

Validate account balances and eligibility before usage.

3.2. Hydra Head Initialization

Set up a Hydra Party based on the designated number of nodes (n-node party).

Automatically select suitable accounts for launching nodes.

Check necessary technical conditions:

• Cardano node must be available (validated via node.socket).
• Required ports must be unoccupied.
• Accounts must have sufficient ADA balance to commit transactions (minimum ADA can be configured).

Expected outcomes after initialization:

• A unique Head ID.
• Endpoint URLs for each node container, for example:

http://localhost:20010

http://localhost:20011

...

3.3. Hydra Head Lifecycle Management

Close Hydra Head: Stop and remove containers associated with a specific head.

Clear Temporary Data: Delete temporary or stored data for each head.

Monitor Runtime Status:

• Startup time.
• Docker container status (running, exited).
• Real-time logs of each node container.

4. System Architecture

4.1. Core Service

Developed with NestJS, serving as the backend core of the system.

Interacts with Docker using the dockerode library.

Connects to databases:

• MySQL: Stores information on heads, accounts, logs, etc.
• Redis: Caches runtime status, user sessions, etc.
• Optional: Some resource-checking and computational tasks may be written in Rust and embedded into NestJS via native bindings (e.g., NAPI) or WASM.

4.2. Hexcore UI

Built with Nuxt 3 (Vue 3).

Provides an intuitive interface for:

• Managing Hydra Heads and nodes.
• Managing Cardano accounts.
• Logging in/out and user role management.

A design mockup of the UI is already available.

4.3. Gateway Layer

Uses NGINX as the main reverse proxy:

• Routes requests to corresponding Hydra node endpoints.
• Secures access and restricts public exposure when necessary.

4.4. Optional Components

Hexcore-cli:

• A command-line tool for quickly initializing Hydra Heads, checking status, etc.
• Useful for admins or deployment automation scripts.

Hexcore-proxy:

• A secure proxy layer to protect Hydra endpoints from unauthorized access.
• Can be integrated with rate-limiting, API key, or JWT authentication.

[Your Project and Solution] Impact

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

Currently, deploying Hydra Heads is still technically complex and not user-friendly, which creates a barrier for smaller teams or independent developers. Hydra Hexcore removes that barrier and enables wider experimentation and adoption of Layer 2 solutions on Cardano.

By simplifying infrastructure and automating key operations, Hydra Hexcore allows developers to focus on writing smart contract logic and building real-world use cases (e.g., games, DeFi apps, microtransaction platforms) — without worrying about how to manage Hydra under the hood.

Long-Term Impact:

• Accelerated Hydra adoption in the Cardano ecosystem.
• Creation of a developer-friendly standard for testing and deploying L2 dApps.
• Opens up possibilities for Hydra Head-as-a-Service integrations in the future.

[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 Vtechcom, a software company based in Vietnam with over 10 years of experience in building and deploying enterprise software solutions such as ERP, CRM, DMS, and more. https://vtechcom.org/

Our project team consists of developers, software engineers, UI/UX experts, and QA testers who have been professionally trained at top universities and have hands-on experience in complex software projects.

Proven Capabilities

We have directly deployed and operated alpha-stage products utilizing the latest Hydra technology, version v0.22, provided by the IOG development team, in order to practically validate Hydra’s performance and stability prior to its official release, including:

• Hydra Wallet: A lightweight wallet with both web and Telegram interfaces, directly connected to Hydra Head. https://hydrawallet.app/
• Hydra FastPay: A fast-payment application using ADA/tokens via Hydra. https://hydrawallet.app/marketplace/hydra-fastpay-en
• Rock Paper Scissors Game: A multi-step game built on Hydra, integrating commit–reveal logic and reward distribution. https://hydrawallet.app/marketplace/rock-paper-scissors
• We have also developed an explorer tool for Hydra applications https://explorer.hydrawallet.app/

These products not only demonstrate our development capabilities but also prove our ability to implement real-world Layer 2 dApps using Hydra.

Technical Contributions to Hydra

In addition to building products, we have also made direct contributions to the Hydra development team at IOG through:

• Submitting bug reports
• Proposing feature requests
• Testing and verifying technical issues in real environments

Evidence:

Our GitHub account aniadev has created and discussed various technical issues with the Hydra team, including:

• Validation issues with Aiken built-in functions and validity_range https://github.com/cardano-scaling/hydra/issues/2162
• Intermittent DepositExpired errors before deadline https://github.com/cardano-scaling/hydra/issues/2144
• Feature request: Allow partial ADA commit from UTxO https://github.com/cardano-scaling/hydra/issues/2140
• Hydra Head Not Confirming Snapshot UTxO After TxValid When Interacting with Contract Using inlineDatum https://github.com/cardano-scaling/hydra/issues/2113
• ... and many other technical reports https://github.com/cardano-scaling/hydra/issues?q=author%3Aaniadev

This proves that we are not just users of Hydra, but also active collaborators with the Hydra development team, contributing to the improvement and refinement of the protocol.

Project Feasibility

The project is divided into clear modules. Each component (Core, UI, Gateway, CLI...) can be developed, tested, and deployed independently.

Core team includes:

• 1 Project Manager (10+ years of experience)
• 4 core developers (frontend, backend, blockchain, with 2–10+ years of experience)
• 1 UI/UX designer (3+ years of experience in dApp design)
• 1 QA specialist (8+ years of experience in software testing)

If necessary, we will allocate additional internal resources to ensure that the project remains on schedule and meets quality expectations.

Execution & Refund Commitment

We commit to:

• Completing the project on the planned timeline.
• Ensuring technical quality, stability, and scalability.
• Delivering a transparent, maintainable, and open-source product with long-term support.

If we fail to deliver the committed product, we will refund the full amount of ADA received from the Catalyst treasury.

[Milestones] Project Milestones

Milestone Title

Complete Core System (Backend) & Cardano Account Management

Milestone Outputs

Backend Development with NestJS

• Implement backend services to manage Hydra Heads, Cardano accounts, and container states.

• Provide RESTful APIs for UI and CLI integration.

Docker Integration for Hydra Node Management

• Integrate Dockerode library to start, stop, and monitor Hydra node containers directly from the backend.

• Support automatic cleanup and recovery for failed nodes.

State Management with MySQL and Redis

• Store persistent data in MySQL (accounts, Hydra Head info, logs).

• Use Redis for caching frequently accessed data and improving response times.

Cardano Account API

• Create APIs to generate new Cardano accounts (vkey/skey), check balances, and assign accounts to nodes.

• Ensure compatibility with both Preprod and Mainnet environments.

Acceptance Criteria

1. Backend allows creating and managing Cardano accounts through the UI, with correct backend processing and data persistence.
2. Backend verifies node readiness (node.socket, port availability, and minimum balance).
3. Hydra Heads can be successfully initialized with dynamically created container endpoints.
4. All APIs pass automated integration tests using Postman or Swagger, with stable performance under test conditions.

Evidence of Completion

1. Public GitHub repository containing backend source code, structured modules, and an installation guide.
2. Video demonstration showing Hydra Head creation and Cardano account binding process.
3. Example .env configuration file with environment-specific variables for local/testnet deployment.
4. Automated test data and recorded test results demonstrating stable API functionality.

Delivery Month

1

Cost

30000

Progress

30 %

Milestone Title

Develop the User Interface (Hexcore UI)

Milestone Outputs

UI Development with Nuxt 3 (Vue 3)

• Build a responsive web UI connected to backend APIs via REST.

• Implement reusable UI components for Hydra management.

Hydra Head and Account Management Interface

• Interface to manage Cardano accounts, initialize Hydra Heads, and monitor container states.

• Real-time status updates via API polling or WebSocket.

Role-Based Login System

• Implement authentication with three roles: Admin, Developer, Viewer.

• Role-based restrictions for critical operations.

Responsive Design with Mockups

• Design and implement a fully responsive layout compatible with desktop, tablet, and mobile.

• UI design based on pre-approved wireframes or mockups.

Acceptance Criteria

1. UI interacts successfully with all backend APIs from Milestone #1.
2. Displays list of running Hydra Heads and container states (running, stopped, etc.) in real-time.
3. Login/logout functionality works reliably with correct role-based permissions.

Evidence of Completion

1. Public GitHub repository for the frontend, deployed to Vercel or a private test server.
2. Demo video showcasing full UI flow (create Head, view logs, manage accounts).
3. Finalized interface design provided as .figma file or screenshots.
4. Staging demo link if available for live testing.

Delivery Month

2

Cost

300000

Progress

60 %

Milestone Title

Gateway Layer Integration & CLI Tool Development

Milestone Outputs

NGINX Reverse Proxy Configuration

• Set up NGINX to route traffic to each Hydra node based on hostname or path, with load balancing and SSL/TLS support.

• Allow dynamic configuration when the number of nodes changes.

Basic Security Layer for Hydra Endpoints

• Implement IP whitelisting to allow access only from specific IP addresses.

• Optionally enable API key or JWT authentication to enhance security for Hydra API calls.

• Log all access requests for analysis and intrusion detection.

CLI Tool Development – hexcore-cli

• Enable Hydra Head management directly from the command line: create new Heads, stop Heads, list statuses, and view logs.

• Support custom parameters when initializing a Head (e.g., number of participants, timeout configuration).

• Provide batch script capabilities to manage multiple Heads simultaneously.

Advanced Logging System

• Integrate real-time log streaming directly in the CLI, with filters by node or Head.

• Allow exporting logs to JSON or text files for offline analysis.

Acceptance Criteria

Full CLI Functionality

• hexcore-cli can perform all actions available in the UI: create new Head, stop Head, view status, and retrieve logs.

• CLI commands must return immediate feedback and provide clear error messages for invalid operations.

Gateway Security for Hydra Endpoints

• NGINX reverse proxy operates reliably and blocks all unauthorized requests.

• IP whitelist works correctly, allowing only configured addresses.

• API key/JWT (if enabled) must validate successfully before granting access.

Load Handling and Scalability

• Able to run stress tests to create and manage multiple Heads concurrently via CLI (e.g., 10–20 Heads) without significant performance degradation.

• System maintains complete logs without data loss under high load.

Documentation and Usage Guide

• README.md includes setup, configuration, and CLI usage instructions.

• Provides a sample nginx.conf configuration for real-world deployment.

Evidence of Completion

Public CLI Source Code

• Developed in Node.js or Python and published on GitHub.

• Modular and extendable code structure.

Documentation

• README.md detailing system requirements, installation, configuration, and CLI usage.

• Includes gateway integration instructions for Hydra nodes.

Sample Configuration File

• Example nginx.conf file with reverse proxy, IP whitelist, and API key/JWT protection.

Demonstration Video

• Shows CLI usage for creating Heads, stopping Heads, and viewing logs.

• Demonstrates the gateway blocking unauthorized requests and allowing valid ones.

Delivery Month

1

Cost

30000

Progress

90 %

Milestone Title

Final Project Report & Wrap-Up

Milestone Outputs

Final Project Report (Project Close-Out Report)

• Detailed report covering project scope, development process, deployment details, challenges, and solutions.

Recap Video

• A complete video walkthrough of the system, including backend, frontend, CLI, and gateway components.

Technical Insights & Community Contributions

• Summarized technical learnings, optimizations, and recommendations for Hydra developers.
• Document contributions submitted to Hydra Core or related open-source repositories.

Acceptance Criteria

1. All documentation and video content are submitted and approved by Catalyst reviewers.
2. Final public GitHub repository contains complete, functional code with clear documentation.
3. Documentation is reusable and beneficial for other developers in the Hydra/Cardano community.

Evidence of Completion

1. PDF report detailing project process, including timeline, team roles, progress tracking, and challenges.
2. Final recap video summarizing development, deployment, and results.
3. Public GitHub repository with full source code and installation instructions.
4. Written summary of GitHub issues, pull requests, and technical contributions to Hydra Core.

Delivery Month

1

Cost

10000

Progress

100 %

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

A. Personnel Costs (Reference rate: 1 ADA = 0.8 USD)

• 2 Backend Developers
• 2 Frontend Developers
• 1 UI/UX Designer
• 1 DevOps Engineer
• 1 Security Engineer
• 1 QA/Tester
• 1 Project Manager

Implementation Phases:

Phase 1 (1 month): Build backend core, set up infrastructure, initial UI

Phase 2 (2–3 months): Complete UI Dashboard, integrate Hydra & Cardano

Phase 3 (1–1.5 months): Testing, optimization, real Hydra Party deployment

Total personnel cost: ~60,000 ADA

B. Infrastructure & Tools (1 year)

Development, staging, and production servers (Hydra/Node/Backend), test environments → ~15,000 ADA

C. Long-term Maintenance & Version Upgrades

Bug fixing, protocol updates, performance optimization, user support, and risk mitigation for ADA price fluctuations → ~20,000 ADA

Total estimated cost:

60,000 ADA + 15,000 ADA + 20,000 ADA = 95,000 ADA

(Reference rate: 1 ADA = 0.8 USD)

[Final Pitch] Value for Money

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

Hydra Hexcore provides a developer-friendly infrastructure for managing Hydra nodes and running multiple Hydra Parties at scale — critical to unlocking real-world adoption of Layer 2 on Cardano.

With Hydra Hexcore, developers no longer need to manually set up Docker, TUI tools, or CLI commands — drastically reducing integration time and lowering the barrier to building Hydra-powered dApps.

Furthermore:

• We have real working products already: Hydra Wallet, Hydra FastPay, and a Rock-Paper-Scissors game running on Hydra.
• We are actively collaborating with the IOG Hydra core team via GitHub bug reports, feature requests, and technical testing.
• The system will be open-source, supporting community reuse, forks, and collective development.

Given the complexity, strategic impact, and team experience, the requested 95,000 ADA reflects fair and sustainable value for the Cardano ecosystem — especially in accelerating adoption of Hydra Layer 2 technology.

[Required Acknowledgements] Consent & Confirmation

Terms and Conditions:

Yes