Cardano Cloud delivers the first runtime in all of cryptocurrency that enables no-compromise dApp development: easy code, full static verification, and serverless execution. This proposal completes a declarative, Haskell-based off-chain runtime that turns Cardano’s foundational strengths—Haskell, eUTXO, and type safety—into a structural advantage for scalable, secure DeFi and governance applications.

The Core Problem: Off-Chain Is the Bottleneck

In traditional blockchains (Ethereum, Solana), most business logic lives on-chain. This simplifies off-chain code to simple transaction submission and polling.

In Cardano, the opposite is true:

• Nearly all business logic is off-chain due to high on-chain costs and eUTXO constraints.
• Off-chain code must:
  • Query UTXOs
  • Build balanced transactions
  • Handle user inputs across phases
  • Persist state across node restarts
  • Align perfectly with on-chain datums/redeemers

Today, this is done with imperative, verbose, unverified code using cardano-api, ctl-haskell, and custom polling loops.

A simple 5-phase DeFi auction requires 500+ lines, no compile-time safety, and fails on node restart.

This is not sustainable.

As dApps grow in complexity (lending, DAOs, governance), off-chain code scales exponentially in bugs, cost, and risk.

The Solution: Cardano Cloud

Cardano Cloud is a declarative, continuation-based runtime that:

1. Statically verifies the entire contract (on-chain + off-chain) using Haskell types
2. Automatically checkpoints execution state (just the stack, <1KB) to disk or IPFS
3. Resumes from cold start in <100ms — no warm servers needed
4. Enables serverless, distributed dApps (browser ↔ node ↔ cloud)
5. Requires only basic Haskell — full contracts in ~25 lines

How It Works – Real Example (25 lines)

defiAuction :: Cloud ()
defiAuction = do
  – Phase 1: Lock funds (on-chain)
  lockTx <- liftCTL $ mustPayToScript script (lovelace 10_000_000) initialDatum
                                        – implicit await, checkpoint, resumes
                                        – from cold start

  – Phase 2: Collect bids (cold-start HTTP endpoints)
  bids <- collect 100 3600000000 $ do   – wait for 100 bids for 1hour  
    bid <- minput "/bid" …              – Generates a REST endpoint, Suspends, 
                                        – resumes from cold start
    validateBid bid                     – 100% type-checked
    return bid

  – Phase 3: Select winner
  let winner = maximumBy (comparing amount) bids

  – Phase 4: Payout (on-chain)
  liftCTL $ mustPayToPubKey (pkh winner) (lovelace $ amount winner)

Production-ready upon completion of Phase 1. Will be deployable on Preview testnet at Month 2 with the first example.

. Survives node crashes, scales to 100+ states, and is fully verified at compile time.

In the broader landscape of smart contract development, verifying the correctness of contract states remains a significant challenge. Traditional approaches often rely on dynamic testing or manual audits, which can miss subtle race conditions, off-chain inconsistencies, or unintended state transitions—issues that have led to high-profile exploits across blockchains, costing millions in lost funds. Off-chain logic, in particular, introduces additional complexities: asynchronous interactions, multi-actor coordination, and integration with on-chain primitives must be meticulously managed to ensure atomicity and predictability. Without robust tools, developers face fragmented workflows, error-prone event handling, and difficulties in simulating real-world scenarios, ultimately slowing innovation and increasing deployment risks. These challenges are exacerbated in complex contracts with numerous states, where verification costs grow exponentially, and persistence mechanisms become bottlenecks under distributed loads.

In the Cardano ecosystem, these general challenges are amplified by the unique eUTXO model and Plutus framework and the fact that most of the logic of the smart contract is off-chain. While on-chain validation via Plutus scripts provides strong guarantees through deterministic execution, off-chain code—responsible for querying UTXOs, building transactions, and handling user inputs—lacks equivalent static assurances. Developers must navigate intricate APIs (e.g., cardano-api, Ogmios) to bridge off-chain and on-chain worlds, often resulting in verbose, imperative code that obscures intent and invites bugs in state synchronization. For instance, ensuring that off-chain validations (like bid checks in a DeFi auction) align perfectly with on-chain redeemers requires manual simulation, which is time-intensive and non-exhaustive. Multi-phase contracts, such as those in governance or Catalyst proposals, compound this: pausing/resuming flows across actors, persisting state resiliently, and verifying all possible paths statically are not natively supported, leading to brittle prototypes that fail under production loads—especially as state complexity scales. This friction discourages broader adoption, especially among teams transitioning from more imperative ecosystems, and limits Cardano's potential in scalable DeFi, DAOs, and cross-chain applications.

Addressing these gaps collaboratively—building on Cardano's strengths in formal verification (e.g., Plinth) and Haskell's type system—presents an opportunity to empower developers with intuitive, verifiable tools that streamline off-chain development while enhancing overall contract security and scalability.

This is the only solution in all blockchains that statically verifies the entire off-chain + on-chain contract, persists execution state, optionally, to IPFS, and responds from cold start. It turns Cardano’s Haskell choice into a structural DeFi advantage.

Building on mature, battle-tested Haskell foundations (including the composable reactive architecture from the Transient ecosystem and DAppFlow), this project completes a declarative, continuation-based monad for off-chain flows that enables static verification of all contract states via Haskell's type system, automatic lightweight checkpointing (serializing only the execution stack, typically <1KB), instantaneous endpoint responses from cold start (zero-warmup via disk/IPFS deserialization), and seamless integration with Cardano primitives (ctl-haskell, Ogmios).

Developers need only basic Haskell knowledge to author full contracts declaratively—no loops, no mutable state, just intuitive sequencing and effectful algebraic operations, if needed. The result is self-documenting code: a complete multi-state DeFi contract is readable in ~20-30 lines, with types enforcing verifiable transitions at compile-time, extending Plutus's determinism to the full contract lifecycle.

Core functionalities resolve the identified problems:

Static State Verification: Each state is in typed statement in a sequence as defined in the specification, catching eUTXO mismatches and off-chain/on-chain inconsistencies before runtime—crucial for complex flows where errors compound exponentially. Automatic Lightweight Checkpointing: Flows pause transactionally, serializing just the execution stack incrementally to disk or IPFS, ensuring resilience without bloat; resumes are atomic. Cold-Start Endpoints: minput-like primitives expose HTTP/console inputs that respond in milliseconds from deserialized state, enabling serverless dApps. Distributed Scalability: Primitives support computation migration across nodes and browsers, with IPFS pinning for tamper-proof persistence—scaling linearly in high-state DeFi or DAO scenarios. Simulation & Production Parity: Toggle emulator mocks vs. live Ogmios, with types preserving guarantees. Example (verifiable auction):

defiAuction :: Cloud ()
defiAuction = do
  lockTx <- liftCTL $ lock 10_000_000 "initial"  – no need for await

  bids <-  collect 100 3600000000 $ do            – wait for 100 bids, 1 hour
    bid <- minput "/bid" Bid{midBid= minPayload} – collect all bids
    validateBid bid

  winner <- selectWinner bids
  liftCTL $ pay winner (amount winner * 1_000_000)
This flow verifies statically, checkpoints automatically, and responds from cold start—transforming complex DeFi from burdensome to elegant.

A Phase 2 will extend to a scripting language compiling to this runtime, making it usable by anyone (no Haskell required), further democratizing Cardano dApp development.

The solution will launch as a Hackage package, with templates and workshops to invite community collaboration.

A fine-tuning configuration for LLMs will also be provided to assist developers with code generation, debugging, and best practices specific to Cardano Cloud development.

The 6-month development is structured into clear, measurable milestones with deliverables, timelines, and success criteria:

1. Month 1 – Core Runtime (v0.1.0)

   • Deliverable: Hackage package cardano-cloud with Cloud monad, automatic checkpointing, and cold-start primitives.
   • Success: Compiles with GHC 9.6+, unit tests pass (>95% coverage), checkpoint file <1KB.
   • Timeline: End of Month 1.

2. Month 2 – First DeFi Example + Integration

   • Deliverable: Working auction dApp (full flow: lock → bid → payout) using ctl-haskell and Ogmios.
   • Success: Deploys to Preview testnet, survives 3 node restarts, resumes from cold start <100ms.
   • Timeline: End of Month 2.

3. Month 3 – Example Suite Expansion

   • Deliverable: 3 additional production-ready examples (DAO voting, NFT minting, lending protocol).
   • Success: All examples <30 lines, 100% type-verified, documented.
   • Timeline: End of Month 3.

4. Month 4 – Tooling & Templates

   • Deliverable: Cabal/Docker project template with one-click deploy, API docs, 5 video tutorials.
   • Success: New developer spins up dApp in <10 minutes.
   • Timeline: End of Month 4.

5. Month 5 – Testnet Validation & Audit Prep

   • Deliverable: All examples running on Preview, community beta feedback report, LLM fine-tuning configuration, security checklist.
   • Success: 10+ external testers, 0 critical bugs, scaling test (100-state flow compiles in <10s).
   • Timeline: End of Month 5.

6. Month 6 – Final Release & Community Handoff

   • Deliverable: v1.0.0 on Hackage, workshop at Cardano Summit (or recorded), Phase 2 roadmap published.
   • Success: 200+ Hackage downloads in first month, 100+ GitHub stars, 3+ Catalyst dApps using it.
   • Timeline: End of Month 6.

Each milestone includes a public GitHub release, demo video, and gov.tools progress report.

Cost Breakdown (100,000 ADA ≈ 57,000 USD at current rates – 1 ADA ≈ 0.57 USD)

| Item | ADA | USD (approx.) | Description | |-----------------------|--------|---------------|-----------------------------------------------------------------------------| | Development | 90,000 | 51,300 | 6 months full-time (1,000 hours @ 90 ADA/hour) – core runtime, examples, integration, testing | | Documentation & Tooling | 5,000 | 2,850 | API docs, video tutorials (5x), project templates, Docker setup, website | | Community Engagement | 3,000 | 1,710 | Workshop (Cardano Summit or virtual), feedback bounties, Discord moderation | | Infrastructure | 2,000 | 1,140 | Testnet faucets, IPFS pinning, CI/CD (GitHub Actions), domain/hosting | | Total | 100,000 | 57,000 | |

Notes:

• Rate based on current market average (0.57 USD/ADA) .
• All costs in ADA; USD for transparency only.
• No overhead, salaries, or third-party contractors.
• Milestone-based release of funds.

Team Size and Duration Estimates

Team Size: 1 full-time developer

• Lead Developer: @agocorona – sole contributor for Phase 1.
• Part-time community support: 2–5 volunteer contributors (via GitHub PRs) for testing, docs, and examples.
• No hired staff; all work by the proposer with open-source collaboration.

Duration: 6 months (180 days) full-time

• Total effort: ~1,000 hours (40 hours/week × 26 weeks).
• Breakdown by milestone:

| Milestone | Estimated Effort | Duration | |-------------------------------|------------------|------------| | Core Runtime | 160 hours | Month 1 | | First Example + Integration | 180 hours | Month 2 | | Example Suite | 200 hours | Month 3 | | Tooling & Templates | 150 hours | Month 4 | | Testnet & Audit Prep | 160 hours | Month 5 | | Final Release & Handoff | 150 hours | Month 6 |

Total: 1,000 hours over 6 months by 1 developer + community input.

This lean, focused approach ensures rapid delivery, low overhead, and direct accountability.

Previous Experience Relevant to Complete This Project

1. Catalyst Fund 3 Project – Successful Delivery (2021–2022)

   • Title: Write DApps as Continuous Workflows
   • Built and shipped: Production off-chain dApp using Haskell and Plutus Application Backend (PAB).
   • Outcome: Completed all milestones, passed audit, received full payout.
   • Limitations: Execution blocked in production due to known PAB issues (resolved in this proposal via independent runtime).
   • Link: Original proposal – https://cardano.ideascale.com/c/idea/333838
   • Repo generated: https://github.com/agocorona/DAppFlow
   • Key features delivered: Pausable, persistent, multi-user smart contracts in pure Haskell.
   • Adoption: Used in 2 live testnet deployments; 40+ forks.
   • Demonstrated: Automatic checkpointing and cold-start execution.

2. Transient Ecosystem – 600+ GitHub Stars (2016–present)

   • Lead developer of:
     • https://github.com/transient-haskell/transient
     • https://github.com/transient-haskell/transient-stack
   • Pioneered: Continuation-based concurrency, distributed computation, and zero-warmup resumption.
   • Used in: Web backends, reactive UIs, and cloud-native systems.

3. Plutus Pioneers & Cardano Developer Community

   • Active contributor since 2021 in #plutus-pioneers and #devs Discord channels.
   • Presented at 3 virtual meetups (recorded sessions available).

4. Hackage Publications & Haskell Expertise

   • 10+ packages published on Hackage with semantic versioning and documentation.
   • Deep expertise in GHC extensions, continuation-based solutions, and static verification.

This track record proves capability to design, implement, test, document, and deliver a production-grade, community-adopted Haskell tool for Cardano.

This proposal ensures long-term sustainability through open-source governance, community ownership, and scalable support models:

1. Open-Source Under MIT License

   • All code published on GitHub (https://github.com/agocorona/DAppFlow) with clear contribution guidelines.
   • Issues, PRs, and feature requests managed via GitHub Projects.

2. Hackage Publication

   • Stable releases (v1.0.0+) published to Hackage with semantic versioning.
   • Backwards compatibility maintained for at least 2 major versions.

3. Community-Driven Maintenance

   • Core team (@agocorona) commits to 12 months of active maintenance post-release (bug fixes, security patches).
   • Open invitation to co-maintainers from Intersect, MLabs, or community contributors.
   • Monthly sync calls (Discord) for roadmap and triage.

4. Documentation and Onboarding

   • Comprehensive docs (API, tutorials, deployment guides) hosted on GitHub Pages.
   • Video series and templates for rapid adoption.
   • Integration with Cardano Developer Portal.

5. Support Channels

   • Primary: GitHub Issues (response within 48 hours).
   • Community: #cardano-cloud Discord channel (moderated).
   • Enterprise: Optional paid support via future Intersect/MLabs partnerships.

6. Future Funding & Evolution

   • Phase 2 (scripting language) to be proposed via gov.tools or Catalyst.
   • Potential treasury allocation for security audits and performance upgrades.
   • Integration into official Cardano tooling (e.g., CTL, Ogmios extensions).

The project is designed to outlive initial funding—becoming a foundational layer maintained by the ecosystem it empowers. Open-Source Under MIT License

All code published on GitHub (https://github.com/agocorona/DAppFlow) with clear contribution guidelines. Issues, PRs, and feature requests managed via GitHub Projects. Hackage Publication

Stable releases (v1.0.0+) published to Hackage with semantic versioning. Backwards compatibility maintained for at least 2 major versions. Community-Driven Maintenance

Core team (@agocorona) commits to 12 months of active maintenance post-release (bug fixes, security patches). Open invitation to co-maintainers from Intersect, MLabs, or community contributors. Monthly sync calls (Discord) for roadmap and triage. Documentation and Onboarding

Comprehensive docs (API, tutorials, deployment guides) hosted on GitHub Pages. Video series and templates for rapid adoption. Integration with Cardano Developer Portal. Support Channels

Primary: GitHub Issues (response within 48 hours). Community: #cardano-cloud Discord channel (moderated). Enterprise: Optional paid support via future Intersect/MLabs partnerships. Future Funding & Evolution

Phase 2 (scripting language) to be proposed via gov.tools or Catalyst. Potential treasury allocation for security audits and performance upgrades. Integration into official Cardano tooling (e.g., CTL, Ogmios extensions). The project is designed to outlive initial funding—becoming a foundational layer maintained by the ecosystem it empowers.

This proposal builds on over 4 years of public, open-source development and active community engagement:

Transient Ecosystem – 600+ GitHub Stars

The foundational library (https://github.com/transient-haskell/transient) has been starred by over 600 developers and used since 2016. Its evolution into transient-stack (https://github.com/transient-haskell/transient-stack) continues to receive regular contributions and forks.

DAppFlow – Public Prototype & Community Testing

The current prototype (https://github.com/agocorona/DAppFlow) includes working examples of declarative off-chain flows with automatic checkpointing and cold-start endpoints. It has been:

Cloned/forked 40+ times Referenced in Cardano Discord (#plutus-pioneers, #devs) and Reddit (r/cardano, r/haskell) Used in 2 Catalyst Fund 7 follow-up experiments Active Community Presence

Regular posts and responses in Cardano developer channels since 2021 Presented early versions (based on the Plutus Application Backend) at Plutus Pioneers meetups (recorded sessions available) Pre-Submission Community Feedback

A draft of this proposal will be posted in gov.tools/budget_discussion within 24 hours of submission for open review. Early informal feedback from 3 DReps and 5 developers (via Discord DMs) has been positive, focusing on alignment with Plutus V3 and serverless dApp needs.

Open to Collaboration

The project welcomes co-maintainers from Intersect, MLabs, or community contributors. All code is MIT-licensed and Hackage-published for immediate adoption.

Endorsement is organic, technical, and ongoing — rooted in public code, real usage, and active participation in Cardano’s developer ecosystem.

This proposal has minimal dependencies, all of which are mature, actively maintained, and widely adopted in the Cardano ecosystem:

1. ctl-haskell (Cardano Transaction Lib)

   • Purpose: Seamless integration with on-chain transaction building and submission.
   • Status: Actively maintained by MLabs/Intersect, used in production dApps.
   • Link: https://github.com/Plutonomicon/cardano-transaction-lib

2. Ogmios

   • Purpose: Real-time chain indexing and WebSocket queries for UTXO state.
   • Status: Official Intersect tool, production-ready, runs on mainnet/testnet.
   • Link: https://ogmios.dev

3. cardano-api

   • Purpose: Low-level Cardano node interaction (optional fallback).
   • Status: Core IOG library, part of cardano-node.
   • Link: https://github.com/IntersectMBO/cardano-api

4. Hackage (GHC 9.6+)

   • Purpose: Package publishing and dependency management.
   • Status: Standard Haskell infrastructure.

No external funding, proprietary tools, or unproven tech is required. The core runtime builds on existing open-source Haskell libraries (Transient, DAppFlow) under MIT license. All dependencies are permissive, non-blocking, and can be replaced or mocked for testing.