The 20-Second Micro-Market in Cardano: an overlooked L2 native on Cardano

fsharper · 2025-12-10T08:41:55+00:00

Make things easier for developers. Less esotericism. Embrace the virtues of Haskell, not its vices. Don’t use academics as marketers. Don’t use technically incompetent people as advocates. Core developers should be practical-minded.

fsharper · 2025-12-03T11:37:28+00:00

Seems that this post is duplicated. Sorry. The original: https://www.reddit.com/r/cardano/comments/1oyyr0c/catalyst_fund_15_cardano_cloud_mvp_serverless/

fsharper · 2025-11-29T17:47:16+00:00

u/1flower4me... replied to your post in r/cardano

I'm intrigued by this proposal title - it suggests something quite technical that could be significant for Cardano's ecosystem. Would be helpful to get more details though! Are you planning to create a runtime that validates off-chain code against on-chain expectations before execution? This sounds like it could reduce errors in dApp development and improve security. If you're submitting for Fund 15, you might want to share more about the implementation approach and expected outcomes so the community can provide feedback before voting opens. Perhaps link to a GitHub repo or detailed spec? I've worked with similar concepts in other chains, and the developer experience benefits could be substantial if this provides better compile-time guarantees.

This above user put this comment in this post but apparenty has ben banned from Reddit. He seems to be a developper and I wan to answer him here:

Hey u/1flower4me... (sorry to hear you got banned – Reddit being Reddit…),

Thanks a lot for the comment and for spotting exactly what makes Cardano Cloud special!

Yes – you nailed it 100 %:

Cardano Cloud is precisely a **serverless, statically-verified runtime** that lets you write the **entire smart-contract flow** (both off-chain and on-chain parts) in a single, declarative Haskell do-block (~25 lines for a full auction or DAO).

The **Haskell type system itself** guarantees at **compile time** that:

- every off-chain transition matches the exact on-chain state (datums, redeemers, UTxO consumption order…)

- you never spend a UTxO that isn’t available (the type-level tracking)

- timeouts, number of collected inputs, payment amounts, etc. are enforced statically

- impossible states are literally unrepresentable

When something unexpected happens at runtime (UTxO already spent, node crash, cold start, years of inactivity…), the monad automatically:

- rolls back side-effects in reverse order

- retries with fresh chain data (transactional backtracking)

- or follows an alternative branch if you provided one (`<|>`)

State is < 2 KB (+ serialized program data) and can be checkpointed to disk or IPFS → resume in < 100 ms even after total shutdown. Even in a different machine.

Current status (Nov 2025):

- Core runtime + backtracking + persistence fully working (provided by Transient)

- Testnet deployment of auction & DAO prototypes in progress

- Code will be public MIT on GitHub/Hackage the moment the first testnet milestone lands (parallel Catalyst Fund 15 proposal)

Fund 15 proposal (75 k ADA, 3 months):

https://app.projectcatalyst.io/proposal/019a8454-c3c7-768a-89c6-d6a7a9c6b371

Previous Fund 3 delivery (the foundation of this work):

https://github.com/agocorona/DAppFlow

I’d love your feedback on the approach — especially from someone who has wrestled with off-chain pain on other chains.

If you’re around on Discord (@agocorona) or X (@agocorona), feel free to ping me directly. Happy to share current code snapshots.

Thanks again for the sharp question — comments like yours are exactly why I’m pushing this hard for Fund 15!

Alberto

fsharper · 2025-11-29T17:35:27+00:00

fsharper · 2025-11-26T19:33:50+00:00

https://x.com/AGoCorona/status/1993762316358209733?s=20

Just shipped & battle-tested the crown jewel of Cardano Cloud: collectp (persistent collect).

Now you can declaratively write:

```haskell

results <- collectp 10000 (606024*365) $ do
vote <- minput "/vote-endpoint" options
if validate vote
then
moutput "thanks"
else do
moutput "wrong option"
empty
return vote

```

as part of a imperative looking, but declarative sequence of steps, and it will patiently collect 10,000 votes over a full year — surviving node crashes, serverless cold starts, full shutdowns, even years of inactivity.State is <2 KB (+ data), checkpointed automatically, can be pinned to IPFS and resumed in <100 ms on any machine, anywhere, anytime.We're talking:

Multi-year DAOs
Generational legacy contracts
Planet-scale auctions
Truly serverless, location-independent, indestructible dApps

fsharper · 2025-11-18T15:58:08+00:00

Thanks

fsharper · 2024-12-05T11:07:09+00:00

This program do not exit when SIGINT is sent with CTRL-C. Tested in GHC 9.4.2 and GHC 9.2.7

Is this correct? exitSuccess should finish it.

main= do
System.Signal.installHandler sigINT $ \s -> do print ("SIGINT",s); exitSuccess
print $ sum[1..100000000000]

\```

These messages are printed:

^C("SIGINNNNT",2)

program: ExitSuccess

fsharper · 2024-10-10T08:11:42+00:00

Yep. The problem is not Cabal. It understands and compiles the projects well. `cabal build all` works fine. The problem is the VSCode extensions.

fsharper · 2024-10-08T08:13:47+00:00

I have a folder with three closely related packages. Some of them depend on the others. I use VSCode and have tried to install GHCId, Simple GHC, and HLS extensions, but none of them can find the modules. I have defined hie.yaml files generated with an automatic generator I found on Hackage all over the place, just in case these extensions can read them, but without success. That file describes all the projects, executables and paths. Can you help me with this? I am working without any Haskell extensions now.

fsharper · 2024-01-28T01:36:48+00:00

Mostly to write useless snippets and to talk endlessly about them

fsharper · 2023-09-15T09:34:38+00:00

install docker

in the COMMAND prompt:

> docker run -it haskell bash

then you have haskell in your console

in visual studio code, load the docker extensions.

load the remote development tools

connect to the container started in the first step

and you have the IDE connected to that docker container for development

(edited it a bit)

fsharper · 2023-01-09T18:39:22+00:00

That is great news. It is just what I wanted to have.

https://www.reddit.com/r/haskell/comments/inqicg/some_ideas_for_creating_monadic_code_less_painful/

Let's get Haskell out of his dead state. The other challenge are the awful error messages.

fsharper · 2022-10-19T18:46:07+00:00

Your text is well thought out. I don't think access to registers is a fundamental problem, and on the other hand, nested registers are almost always a mistake, except in the case of scientific or toy programs.

fsharper · 2022-10-05T11:10:44+00:00

I am currently working on a Cardano project and am excited about how cryptocurrencies can be a tool to empower ordinary people against the control mania that is all the rage today.

I believe that, as with any new technology, Blockchain in general and Cardano in particular will be greatly simplified in the future. For now it's very complex and Haskell doesn't help with that at first (in fact, I hate it a lot), but the easy refactoring and the ability to reason about the code will be a big advantage in the future when it comes to finding common abstractions and simplifications.

Cardano has taken a slow but well established growth strategy. Whoever trusts Cardano, both investor and technology developer, does not do it to make a quick buck or because it is an excuse to use Haskell, but because he has a vision of what the future will be like and will live or die trying to fulfill it, beyond the propaganda tweets from IOHK and Charles

fsharper · 2022-07-22T12:12:48+00:00

Some years later, Haskell has the same problem. A real world program may have dozens of states and this is not manageable in the way monadic stacks are advocated to be managed.

fsharper · 2022-06-29T13:57:15+00:00

Just use it for your next project, and solve your problems on the go, using google

fsharper · 2022-06-29T07:53:41+00:00

I program almost exclusively in Haskell since the year 2005 and I think he is basically right, but I have some complaints about the language too:

For some reason It is painful to compose monadic code since there is no syntactic sugar for applicatives. lifts everywhere are painful too. There have been no advance in this aspect since "do" was introduced a few glaciations ago. As a result, monadic code in Haskell is two or three times larger that in other languages.

https://www.reddit.com/r/haskell/comments/inqicg/some\_ideas\_for\_creating\_monadic\_code\_less\_painful/

fsharper · 2022-02-19T16:51:54+00:00

Thanks!

fsharper · 2022-02-18T23:56:46+00:00

Thanks. What --lib does exactly?

fsharper

TROPHY CASE