OgmiosDotnet: Cardano Blockchain Events & Visualisation

[Proposal setup] Proposal title

Please provide your proposal title

OgmiosDotnet: Cardano Blockchain Events & Visualisation

[Proposal Summary] Budget Information

Enter the amount of funding you are requesting in ADA

100000

[Proposal Summary] Time

Please specify how many months you expect your project to last

7

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

Developers need a simple way to filter Cardano blocks and get only needed transactions via HTTP or gRPC, removing Ogmios SDK barriers, with a scalable queue and reliable, retriable delivery.

[Proposal Summary] Supporting Documentation

Supporting links

• https://github.com/ItsDaveB/OgmiosDotnet
,
• https://ogmios.dev/clients/

[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. Ogmios is a mature, open-sourced well-integrated project.

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

MIT License. Fully open sourced.

I chose the MIT License because it is simple, flexible, and business friendly. It maximizes adoption by allowing anyone to use, modify, and share the code freely including for commercial purposes while ensuring proper credit to me as the original creator. This approach encourages collaboration, accelerates innovation, and makes it easier for the ecosystem to build upon my work without restrictive legal barriers.

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

I will make the source code publicly accessible from the start by publishing it on my GitHub repository, where the original OgmiosDotnet implementation is also hosted. This repository is fully open source and already benefits from community contributions.

How will you provide high quality documentation?

I will provide clear developer setup steps and relevant project context, referencing Fund 14 so it is easily searchable and attributed back to Catalyst. For reference, my OgmiosDotnet project funded in Fund 12 and successfully completed demonstrates the time and effort I put into producing thorough documentation, as seen in its README https://github.com/ItsDaveB/OgmiosDotnet/blob/main/README.md.

I will apply the same standard here to ensure developers can get started quickly and confidently.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

This proposal expands OgmiosDotnet by introducing custom pluggable rules to filter transactions directly from Cardano blocks and stream them into a queue-based, event-driven architecture. Developers will be able to receive only the transactions they require, delivered via HTTP or gRPC, enabling integration from any programming language without relying on dedicated Ogmios SDKs. This reduces community-wide maintenance and language SDK integration costs while broadening ecosystem accessibility.

Filtered transactions can be routed to multiple consumers at the same time, with each consumer able to subscribe to the same or entirely different rule sets. This abstracts away node synchronization, enabling infrastructure to be shared, decoupled, and operated more efficiently at both the rule and subscriber level. The approach also opens the door to external integrations beyond the Cardano ecosystem, allowing companies and partners to route precisely the transactions they require into their existing systems.

Reliability is built in through automatic retries, optional dead-letter handling, and acknowledgment-based processing. The delivery layer will be broker-agnostic, ensuring that the underlying messaging technology can be swapped or scaled without code changes.

The solution will be fully open source and runnable locally straight from the repository, empowering developers to experiment, customise, and deploy in their own environments without licensing or infrastructure barriers.

To showcase its power, an example consumer application will be delivered that demonstrates real-time transaction visualisation, highlighting how the enhanced OgmiosDotnet can support interactive dashboards, integrations, and innovative new applications across the ecosystem.

Evidence of Demand

The official Ogmios site lists clients in TypeScript, Go, Kotlin, Java, Python, Elixir, C++, and C#. However, most of these are community-maintained with no guaranteed long-term support, funding, or clear pathway to expanding coverage into additional languages. Importantly, none provide an enterprise-ready, queue-based architecture that ensures reliable transaction delivery without requiring consumers to repeatedly replay full chain synchronization. This highlights a significant gap in the ecosystem that OgmiosDotnet.BlockchainEvents is uniquely positioned to fill by delivering a resilient, scalable, and language-agnostic solution built for both developers and enterprises.

[Your Project and Solution] Impact

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

By delivering filtered transactions through pluggable rules, the system removes the need for every application to ingest and process full block data. This reduces compute and storage overhead, accelerates application logic, and allows developers to focus only on the transactions that matter while improving reliability.

The project improves accessibility by removing language barriers. With delivery via HTTP or gRPC, developers in any programming language can consume transactions without depending on a dedicated Ogmios SDK. The architecture is designed for scalability and reliability, with at-least-once delivery guarantees, automatic retries, and optional dead-letter handling. Multiple consumers can share the same infrastructure, lowering costs and supporting deployments from local environments through to enterprise Kubernetes clusters.

Language-agnostic delivery expands Cardano’s reach and enables faster adoption without the need to create and maintain new Ogmios SDKs in every language. Configurable filtering also creates potential business models, such as subscription-based transaction streams tailored to specific use cases, similar to Blockfrost’s webhook notifications.

The queue-based, event-driven design ensures many consumers can receive the same or different sets of filtered transactions simultaneously. This allows DApps, dashboards, monitoring systems, and analytics tools to work from the same data pipeline without duplicating effort or replaying chain sync.

Broker-agnostic integration makes the system adaptable to different environments, from lightweight local message brokers to cloud-native pub/sub services, without requiring code changes. Built-in observability provides insights into throughput, error handling, and system health, ensuring operational reliability.

As a fully open-source project that can be run directly from the repository, any developer can experiment, customise, and deploy the system without licensing or vendor lock-in. This supports rapid prototyping as well as production-grade adoption.

Ultimately, this project strengthens the Cardano ecosystem by diversifying developer tooling, improving scalability and reliability, lowering integration and maintenance costs, and enabling new commercial and community-driven services.

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

I created OgmiosDotnet, the first .NET client for Ogmios integration, which has achieved nearly 2,000 downloads in under a year and already benefits from community contributions. This demonstrates both proven delivery capability and ecosystem adoption.

I am a Lead Full Stack Engineer with over 10 years of experience across enterprises and startups, specialising in development, operations, and architecture. My track record includes delivering large-scale, production-ready systems in regulated pharmaceutical industries. In 2024, a project I led development efforts on and contributed to was publicly recognised by the Google CEO during a keynote presentation, highlighting its success as an AI-driven enterprise initiative that delivered over $1M in cost savings.

I have successfully delivered 2 out of 2 Catalyst-funded proposals, both completed in Fund 12 with excellent community and reviewer feedback. In addition, I have the ability to outsource development to trusted professionals I have worked with in the past if required, ensuring flexibility and delivery capacity.

This combination of domain expertise, Cardano-specific delivery, and enterprise-level engineering experience provides strong assurance that this proposal will be delivered successfully.

[Milestones] Project Milestones

Milestone Title

OgmiosDotnet.BlockchainEvents – Core Transaction Filtering

Milestone Outputs

• Establishment of the OgmiosDotnet.BlockchainEvents project and public GitHub repository.
• Implementation of the core filtering engine that ingests Cardano blocks (via OgmiosDotnet) and applies pluggable custom transaction rules.
• Definition of a standardised event schema (transaction payload + metadata) to ensure consistent downstream delivery.
• Delivery of starter rule implementations, such as filtering by address, policy ID/asset, metadata key/value, or governance/treasury-related transactions.
• Comprehensive unit tests and developer documentation, including a clear guide on building and integrating custom rules.

Acceptance Criteria

• All unit tests pass, confirming the filtering engine behaves as expected.
• At least three example rules (e.g., by address, metadata, governance/treasury) execute successfully against live block data.
• The engine correctly filters transactions according to active rules and produces outputs ready for emission into the event pipeline.
• A README is available and complete, explaining OgmiosDotnet.BlockchainEvents, local setup instructions, and a step-by-step guide to creating and integrating custom rules with examples.

Evidence of Completion

• A public GitHub repository for OgmiosDotnet.BlockchainEvents containing open-source code, documentation, and passing unit tests.
• Example configuration demonstrating at least three filtering rules functioning in practice.
• A recorded demo of a live run showing filtered transactions being captured and emitted in real time.

Delivery Month

2

Cost

25000

Progress

20 %

Milestone Title

OgmiosDotnet.BlockchainEvents – Event Delivery Layer

Milestone Outputs

• Extension of the filtering engine with a queue-backed delivery system for publishing filtered transactions.
• Implementation of HTTP (CloudEvents) and gRPC endpoints, enabling consumption from any programming language.
• Reliable event flow with at-least-once delivery and automatic retry of failed deliveries.
• API documentation including example Postman requests to demonstrate subscribing and receiving events.
• Example Docker Compose setup showing how to run the service locally with a message broker.

Acceptance Criteria

• Filtered transactions are placed into a queue and delivered successfully to consumers over HTTP and gRPC.
• Postman examples confirm that events can be subscribed to and received without requiring an Ogmios SDK or WebSocket connection.
• Service resiliency validated: restarting the publisher or a consumer does not result in event loss.
• Events are delivered in CloudEvents format by default, with option to output raw JSON payload.
• Documentation provides clear step-by-step instructions for local setup, running, and subscription testing.

Evidence of Completion

• Public GitHub repository updated with delivery layer implementation and Docker Compose configuration.
• Postman collection demonstrating subscription to and receipt of filtered transaction events.
• A recorded demo showing events delivered, consumed, and retried reliably under restart conditions.
• Documentation updated with detailed instructions on running the service and testing subscriptions locally.

Delivery Month

4

Cost

30000

Progress

50 %

Milestone Title

OgmiosDotnet.BlockchainEvents.UI - Interactive Consumer & Visualisation

Milestone Outputs

• Development of a React-based web application that subscribes to the event delivery layer.
• Real-time visualisation of filtered transactions as they are received, showcasing the power of custom rules.
• Example filtering scenarios demonstrated (e.g., by metadata, treasury withdrawals, governance-related transactions).
• Clear separation of backend and frontend layers, showing how different consumers can be built independently.
• Documentation for developers to build their own consumers based on the example UI.

Acceptance Criteria

• A React web app runs locally via Docker Compose alongside the delivery service.
• The UI connects to the delivery layer via HTTP or gRPC and displays filtered transactions in real-time.
• At least two example rule configurations demonstrated visually (e.g., governance/treasury transactions, metadata-based).
• Application is fully open source and documented, with clear local setup instructions.
• Example screenshots and/or demo video of the app running and visualising transactions.

Evidence of Completion

• Public GitHub repository updated with React application code and Docker Compose setup.
• Documentation covering local setup, configuration, and extending the UI with additional visualisations.
• A recorded demo showcasing the application receiving and displaying filtered transactions in real time.

Delivery Month

6

Cost

20000

Progress

80 %

Milestone Title

Finalisation, Documentation & Community Release

Milestone Outputs

• Finalised packaging of all system components into Docker images, published to a public container registry.
• Versioned release published on GitHub, including source, configuration templates, and setup instructions.
• Example configurations included to demonstrate practical use cases (e.g., filtering by governance, treasury, or metadata rules).
• Code quality improvements, and technical debt resolved, ensuring enterprise adoption standards.
• Final recorded demo/tutorial providing a reusable guide for running the full system end-to-end, from filtering through to visualisation whilst also showing sidecar health, logs / metrics of the integration.
• Community onboarding materials to guide developers in running, extending, and adopting the solution, ensuring long-term maintainability and adoption.
• Close-out report detailng whats been completed, what went well, learnings and potential improvments.

Acceptance Criteria

• Docker images for all system components are published and publicly accessible.
• A versioned release is tagged and available in the GitHub repository.
• Example configurations are included and demonstrated in the final showcase.
• Documentation is complete, covering usage, deployment, and contribution guidelines, with instructions verified by a test setup.
• A final demo/tutorial demonstrates the system running end-to-end.

Evidence of Completion

• Public GitHub repository with tagged release(s), Docker image references, and configuration examples.
• Docker images available for pull/run.
• Published final demo/tutorial accessible to the community.
• Close-out report is published and accessible.

Delivery Month

7

Cost

25000

Progress

100 %

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

Milestone 1 – Core Transaction Filtering Engine (₳25,000)

• Engineering & architecture: ₳19,750
• Documentation & developer guides: ₳3,000
• Project management & reporting: ₳2,000
• Tooling/software: ₳250

Milestone 2 – Event Delivery Layer (₳30,000)

• Engineering & integration: ₳23,850
• Documentation & examples: ₳3,000
• Project management & reporting: ₳2,900
• Tooling/software: ₳250

Milestone 3 – Interactive Consumer & Visualisation UI (₳20,000)

• Engineering (React application): ₳10,850
• UI/UX design & integration: ₳5,000
• Documentation & reporting: ₳3,900
• Tooling/software: ₳250

Milestone 4 – Finalisation, Documentation & Community Release (₳25,000)

• Engineering (packaging, release, polishing): ₳8,100
• Documentation, tutorials, onboarding: ₳6,200
• Technical debt resolution & code quality: ₳7,450
• Project management & reporting: ₳3,000
• Tooling/software: ₳250

[Final Pitch] Value for Money

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

This proposal represents strong value for money by focusing on reusability, scalability, and accessibility. Instead of each project funding the creation of language-specific SDKs or maintaining separate integrations, this solution provides a single, open-source pipeline that any developer can use. By removing the need to rely on new Ogmios SDKs for every programming language, the community avoids duplicated effort and ongoing maintenance costs.

The ability to filter and receive only the transactions that are required, combined with a resilient queue-based integration that ensures delivery, provides the type of architecture enterprises expect. Having this solution completely open sourced allows companies to focus on building their applications rather than low-level infrastructure, ultimately driving on-chain activity and utility into the Cardano ecosystem.

The architecture is designed to scale efficiently, allowing multiple consumers to share the same infrastructure and receive only the transactions they require. This reduces operational costs and enables teams to concentrate on higher-level features instead of re-implementing the same low-level integrations. The ability to run locally ensures there are no licensing or vendor lock-in costs, while Kubernetes compatibility makes it suitable for enterprise deployments without requiring rework.

Investment in this proposal creates lasting ecosystem value by delivering tooling that lowers barriers to entry for developers across diverse programming backgrounds. It enables faster adoption of Cardano data, supports community and enterprise use cases alike, and opens opportunities for sustainable business models. The result is a cost-effective solution with long-term benefits, serving both immediate developer needs and the broader growth of the Cardano ecosystem.

[Required Acknowledgements] Consent & Confirmation

Terms and Conditions:

Yes