The single biggest time sink was zcashd and lightwalletd syncing. Before I could even start testing atomic
swaps, I had to wait hours for initial blockchain sync. This wasn't a one-time setup either — every
configuration change, every parameter tweak meant restarting services and praying they'd sync correctly.
Most of my development time wasn't spent writing code; it was spent figuring out what works and what
doesn't through endless docker exec and curl trial-and-error sessions.

The documentation around Zcash RPC is sparse and scattered. Simple questions like "do I use account
numbers or addresses in z_sendmany?" required reading through GitHub issues from 2019. The
AllowRevealedAmounts privacy policy error? Only discovered after multiple failed transactions and diving
into zcashd source code. Every curl command in CURL.md represents hours of debugging.

Then came the worst possible timing: during the final days of the hackathon, lightwalletd completely
corrupted. The database became unreadable, the service refused to start, and there was no way to recover
it. I had to nuke everything and rebuild from scratch — full blockchain resync, full wallet rescan, hours
of waiting while the submission deadline approached. This meant re-testing the entire escrowdv2 funding
verification flow when I should have been polishing features.

Mina Compilation Delays

On the Mina side, the challenge wasn't infrastructure — it was compilation speed. Every single change to
the smart contract or offchain state required 2-3 minutes of recompilation before I could even know if my
fix worked. Debugging became agonizingly slow: write one line, wait 3 minutes, see it fail, repeat. This
isn't a Mina flaw (ZK circuits are complex), but it turns rapid iteration into a patience test.

The offchain state settlement proofs added another 5-6 minutes per test cycle. When you're hunting a bug
that requires multiple contract calls to reproduce, you're looking at 15+ minute feedback loops.
Traditional smart contract development gives you sub-second compilation; zkApps demand planning every
change carefully because you won't know if it works until you've waited long enough to make coffee.

The Breaking Point

There was a moment — somewhere around 3 AM during the final 48 hours — where everything failed
simultaneously. Middleware couldn't connect to escrowdv2. Port allocation was throwing collisions despite
the allocator showing free ports. ZEC transactions were getting mined but escrowdv2 wasn't detecting them.
Mina settlement proofs were timing out. The logs made no sense. Every fix broke something else.

I genuinely considered scrapping the entire integration and submitting a simplified mock version. The
circular debugging was maddening: fix the port allocator, breaks the API key flow. Fix the API keys, now
lightwalletd can't find the notes. Fix the memo encoding, now zcashd rejects the privacy policy. It felt
like playing whack-a-mole with a system that actively resisted coherence.

The solutions however came from a pretty popular term "KISS": unified operator token (no per-trade key generation),
sequential port allocation (no hash-based logic), and accepting that the POC doesn't need production-grade
complexity. Once I stopped fighting the architecture and embraced "make it work first, optimize later,"
the pieces finally clicked. But those dark hours of everything failing taught me more about distributed
system debugging than any tutorial ever could.

Finally, there's still a lot to be done, things to be fixed, but I am pretty happy with what I have with me right at this moment. And no one can take that from me.

Bonsoir Elliot.