MonteZecret: A Desktop Wallet for Zcash in Rust Instead of Tweets

[topcrypto]

The Zcash crypto wallet that I boldly named MonteZecret (still a working title) — yes, this is a reverence to the Count of Monte Cristo with his love for elegant secrets and treasures.

If you asked me what the secret to successful development is, I’d answer: stop feeding social media. More than 4 months ago, I made a deal with myself. Instead of pouring my thoughts into X (formerly Twitter), every day I write an amount of code equivalent to several tweets.

And you know what? Regular micro-steps work better than any personal growth trainings. Drop by drop, line by line — and now I already have the first tangible results of creating a new desktop wallet for Zcash.

You can already watch the ritual of seed phrase generation:

• YouTube: https://youtu.be/svOYnoj8MbE
• Odysee: Birth of a Secret: Forging Your Digital Key in MonteSecret | Zcash Seed Phrase Generation

1. Night Shifts, Napkins, and Cyberpunk Spirits

It all started with the difficult choice of architecture and long sleepless nights. During the day, I was busy with my main job — physical labor. And at night, when the city fell asleep, my inner programmer woke up.

You know what happens when you work with your hands during the day and design a crypto wallet at night? On weekends, you become that weird guy in a café drawing diagrams on napkins. Waitresses looked at me with suspicion — usually people draw hearts or phone numbers on napkins, not the architecture of GUI interaction with Zcash RPC.

Chronic sleep deprivation manifested itself in quite an original way. During brief periods of shallow sleep, it seems the spirits of Satoshi Nakamoto and Hal Finney began visiting me. We sat in a virtual crypto-bar, they threw valuable ideas for the Zcash wallet at me and condescendingly helped me debug code. (Hal — thanks for the help!)

It was during this period that I learned Rust from scratch and how to work with the librustzcash library: GitHub - zcash/librustzcash: Rust-language assets for Zcash · GitHub

2. Choosing the Technology Stack: Why Rust Is a Philosophy

I chose Rust — a language that programmers either passionately love or haven’t tried yet. This is a language where the compiler treats you like a strict but fair mentor.

The Zcash team has already chosen Rust for librustzcash — so I’m on the right track. Rust is like a Swiss Army knife for developing secure applications: sharp, reliable, and requires some skill so you don’t cut yourself.

Dream and Reality

Ideally, I would like to write a wallet in pure C and compile it through the tiny Tiny C Compiler (TCC) by the genius Fabrice Bellard. But this is still an unattainable peak.

The reality of cryptography is harsh: an application that works with your money requires the highest level of security. Rust with its memory-safe guarantees is unrivaled here. It’s the optimal balance between security and performance.

3. The Great GUI Choice: A Crusade Against “Electronic Obesity”

The graphical interface is the face of the application. And which face to choose?

I considered many options:

• KDE? Beautiful, but a bit heavy.
• Gnome? Lighter, and my favorite editor Geany is based on it.
• wxWidgets? Those who worked with CodeLite IDE know these sudden phantom errors that even modern AI capitulates before.
• Electron? Anything but that.

Electron — A Gluttonous Monster

Let me speak separately about wallets based on Electron. It’s like inviting Godzilla to live in your apartment. Yes, some Monero wallets use Electron, but my computer wants to live without having all available resources seized.

Have you even noticed how modern applications have stopped respecting our resources? One Chrome tab can eat up a gigabyte of RAM. No matter how powerful your computer is, after a while even that’s not enough. We’re burning incredible computational power in a completely non-ecological way. And it’s sad.

Revelation: Lite XL and SDL2

And then I found Lite XL — an editor that uses the SDL2 library directly. Light, fast, elegant. Installation size?
About 1.2 MB. Now that’s what I call minimalism!

This was a revelation among heavyweight frameworks. This approach became the foundation for Monte Zecret.

4. The Philosophy of Zcash: Why Standards Matter

Let’s dig deeper. What makes Zcash special? Privacy? Yes, but that’s just the tip of the iceberg.

The true credo of Zcash is the implementation of innovative standards in the cryptocurrency industry.

• New privacy standards
• New security standards
• New cryptography standards (remember zk-SNARKs? Zcash brought them to the masses)

The Taylor Hornby Story — An Example of a Living Ecosystem

On May 29, 2026, white hat hacker Taylor Hornby discovered a critical vulnerability in the Orchard pool. He found and neutralized the threat before malicious actors, and Zcash became even more secure.

Details here: The Orchard Counterfeiting Vulnerability - Shielded Labs

This demonstrates that the Zcash ecosystem is alive, vigilant, and constantly improving.

The industry needs new standards. Which means it’s time for a new crypto wallet.

5. The Monte Zecret Manifesto: Five Pillars of the Perfect Wallet

5.1. Conciseness and Minimalism

Less is more. Every line of code must be justified. Every byte of size — earned.

5.2. Aesthetics and Functionality

Perhaps Scandinavian design style. Clean, functional, pleasing to the eye. The beauty of code should be reflected in the beauty of the interface.

I also spent quite a bit of time searching for the perfect font and found a real uncut diamond — the Hack font.

What I needed:

• Monospaced (for code and addresses)
• Excellent readability
• Clear distinction between 0 and O, 1 and l
• Beautiful
• Open source

Hack meets all requirements perfectly.

5.3. Keyboard Control

No mouse needed! In the Accounts tab, you can open or create a wallet with the well-known combinations `Ctrl+O` and `Ctrl+N`.

And switching between tabs works via `F1`, `F2`, `F3` — a fiery greeting to **Midnight Commander**.

5.4. Lightness

My battle laptop is a Dell Latitude 3550 from 2015. And don’t try to convince me to buy a new one! Until this one physically falls apart, I won’t buy a new computer. It’s this old hardware that keeps me sharp and motivates me to create truly optimized applications.

Application Size Comparison:

CodeLite IDE: 72.21 MB
Geany: 16.34 MB
Vim: 5.33 MB
Lite XL: 1.18 MB
Monte Zecret: 1.82 MB

The result is excellent! But there’s sad news: the wallet no longer fits on one classic 3.5" floppy disk (1.44 MB). We’ll have to split it with an archiver into two parts.

Someone will say: “What floppies in 2026?”

I’ll answer: “And what’s the point of a gigabyte application that does the same thing?”

Progress is not when applications get bigger. Progress is when they get smarter at a smaller size.

5.5. Security at the Cutting Edge

This is a crypto wallet. People’s money is stored here. Errors are unacceptable here. Rust helps, but programmer vigilance is paramount.

6. The Philosophy of Regularity: Code Instead of Tweets

Here’s the secret to productivity: every day I write some code instead of writing tweets on X.

Several hours of code instead of endless scrolling. And you know what?
Regular small actions lead to huge results.

This works flawlessly and better than any motivation. Motivation comes during work, not before it.

No need to wait for inspiration. No need to plan a great leap. Just open the editor and write:

• Today — seed phrase generation function
• Tomorrow — input validation
• Day after tomorrow — integration with librustzcash

After 4 months, you have a working prototype.

7. How You Can Support the Project (and Influence History)

Every day Monte Zecret gains features and gets better. And you can directly accelerate this process.

Donations Welcome

Grants are slow and bureaucratic.
Patrons are fast and effective.

Patrons should always be respected, because they make the world (and open source) better, kinder, and freer.

Donations can significantly accelerate development — they’re more efficient than any cumbersome grants. Moreover, you can communicate with me by leaving messages directly in the **Memo** field of your transaction!

Naming Contest

Monte Zecret is just a working title. You can suggest your own!

When sending a donation, write your wallet name suggestion in the Memo.

The rules are simple: the winner will be the variant from the author of the most generous donation. But if you, like me, like the Monte Cristo vibe, vote with your coins for the original name so it doesn’t get outbid!

Personal Messages via Memo

Want to write to me personally? Use the Memo field in a Zcash transaction. Privacy in action!

Voting for Open Source

Very soon we will hold a community vote to fully open source the project.

You’re not just spectators. You’re co-authors of new Zcash standards. Join in!

Support the Project

To support development, leave a message for eternity (in the encrypted Memo field), and suggest your own name for the wallet at this address:
u1c9qqs5knwe360w6snjuhcldtpf6tcc9nz6xuanmz2xwyf7l4ufze89tze43yz90ajgcej5ylh0a4h2ac65flsvp7a8ewaauvtt4hwsxuhuqvv9h5fkxntw9yk0eyrrlcu004e2havqs0yx58u7kk75e8hff47srsaslc9g6u6rxfn7j9es2g6zc0drd6ajus8wjj2f8p3als53dfc9l

Epilogue: A Manifesto of Reasonable Resource Use

Monte Zecret is not just a wallet. It’s a manifesto of reasonable resource use. It’s a return to the roots, when every byte was worth its weight in gold. It’s respect for your computer, your time, and your privacy.

And yes, this is a wallet written at night, under the whispers of crypto-revolution ghosts, on an old laptop, with Hack as the font, and a dream of a world where applications fit on floppy disks again.

Zcash. Privacy. Code. Repeat.

P.S. If you read to the end — you’re a real hero. Or you also suffer from insomnia and write code at night. Either way, welcome to the club!

[ZKZeek]

Learning Rust from zero and reaching a working prototype on librustzcash in 4 months is real discipline. Which backend will sync use, zebrad RPC or a lightwalletd style server?

[topcrypto]

Dev Update: Month 4.5. We have some worrying news—things aren’t quite as rosy as we thought.**

MonteZecret: The lightest Zcash desktop wallet in Rust (instead of just tweeting)

Remember how we proudly called MonteZecret the lightest Zcash desktop wallet in Rust?
Well, it seems it’s started eating at night, and maybe even sneaking midnight snacks.
Just two weeks ago, the binary weighed 1,820,744 bytes.
It was as graceful as a ballerina.
Today? 7,330,888 bytes.
Now it looks like a programmer after three months of remote work.
We’re on a bulk, folks.

If the program used to fit on 2 floppy disks, now it needs 5.
Of course, some of the blame lies with the libraries, but more on that later.

But we will continue the fight to keep it slim. First, we’ll build the core functionality, and optimization won’t be the top priority just yet—but that will change soon. Especially since we already have experience optimizing libsecp256k1—our version runs 2.4x faster than the original!

libsecp256k1: 2.4x Speedup

We couldn’t settle for standard performance, so we rewrote the libsecp256k1 implementation (yes, that one from the Bitcoin world). Our custom version in batch mode runs 2.4 times faster than the original!

📊 Iterations: 100000 
+---------------------------+------------+--------------+------------+ 
| Implementation            | Time (sec) |  Speed (h/s) |   Keys/sec | 
+---------------------------+------------+--------------+------------+ 
| 1. libsecp256k1 (Base)    |     4.5015 |        22215 |      22215 | 
| 2. Custom v1              |    30.6389 |         3264 |       3264 | 
| 3. Custom v2              |    15.0258 |         6655 |       6655 | 
| 4. Custom v3              |     4.4087 |        22682 |      22682 | 
| 5. Custom v4 (single)     |     3.6087 |        27711 |      27711 | 
| 6. Custom v4 (batch)      |     1.8738 |        53368 |      53368 | 
+---------------------------+------------+--------------+------------+ 
⚡ v4 (batch) vs libsecp256k1: 2.40x faster

Why do we need this kind of speed? We have an ambitious (and slightly insane) goal—Bitcoin Puzzle #71. We are optimizing every single CPU clock cycle to solve it. And if we crack it… well, you get the drill: all those bitcoins are flying straight into private Zcash.

Plan B: If the wallet gets too heavy anyway, we’ll just release it as a plugin for Emacs or Vim.

---

The Problem of Digital Obesity

Imagine this: you invite a librarian to a party to help you slice some bread. But she shows up with a suitcase that turns out to contain an entire food processor with attachments for making sushi, a watermelon carving tool, and a manual for shaping marzipan figures.
“I just need to slice some bread,” you say.
“But what if you suddenly need a GIF animation!” the library replies, winking slyly.

That’s exactly how modern development works. Libraries are stuffed with “just in case” features. When you plug in a graphics library, say for QR codes, it drags along support for GIFs, animations, and shadow rendering. And you don’t even plan to use GIFs! It’s a classic conflict of interest: the library dev wants to cram everything in, while the app dev only needs one function.

By the way, I’m sure AI will soon change the paradigm of libraries. Instead of pulling in a giant repository, AI will read its source code and compile a “micro-library” for you, consisting of only the 3 lines of code your app actually needs. I wouldn’t be surprised if tools like this appear sooner than we think.

Optimization is coming. But first—functionality.
First the heart. Then the abs.

---

But there is good news

The most secure half-finished wallet in the world

We’ve updated the Zcash Rust libraries to the latest versions:

zcash_keys = { version = "0.14", features = ["sapling", "orchard", "transparent-inputs"] }
zcash_primitives = "0.28"
zcash_transparent = { version = "0.8", features = ["transparent-inputs"] }
zcash_protocol = "0.9.0"

So right now, we have the most secure wallet in the world that doesn’t quite do everything yet.

UI like a Slide Projector: Nostalgia beats minimalism

We finished the functionality for the Receive tab. Initially, we wanted to make TabSheet tabs, like in good old Delphi. But then it hit us.

Remember slide projectors (Diafilms)?
That magical device in a dark room, where you turn the dial, the shutter clicks, and the next image appears on the bedsheet, illuminated by a beam of light.

We brought this intuitive magic into the interface. The address slider (Main, Orchard, Sapling, Diversified, Transparent) switches with a smooth animation, as if you’re turning the film reel. This isn’t just an innovation; it’s a philosophy.

A Universe Inside the Progress Bar

You know what’s the most fascinating thing about developing from scratch? You realize that simple things don’t exist. We started writing a Progress Bar. We thought, “Well, it’s just a rectangle, how hard can it be?” Turns out, we discovered an entire universe. We couldn’t pick just one, so we made 4 different progress bar designs: from ascetic to ultimate stylish. Most likely, we’ll leave the choice to the user. Let everyone decide for themselves how their wallet will “load.”

The Hell and Heaven of Neural Networks: How We Made the Icons

You’d think, why draw icons when there’s AI? You write a prompt—you get a masterpiece. Let’s take off the rose-tinted glasses. Here’s how it actually goes down:

1. You write a 300-word prompt, trying to explain to the neural network what early 2000s skeuomorphism in the style of Opera 7 looks like.
2. You generate 10 images at a time in Qwen, Seedream, and Flux.
3. You set a timer on your phone because the free tier limit is 5 generations per hour. You sit there like an addict, waiting for the timer to ring so you can hit “Generate” again.
4. Over 20 hours, you generate 3,000 images.
5. Out of those, you select 92 decent ones.
6. Out of the 92, you pick one, which you then manually tweak.

Here’s our “modest” prompt for the Contacts icon (excerpt):

“A skeuomorphic 3D app icon… Early 2000s software design aesthetic, exact Opera 7 browser icon visual style… The book body is made of smooth, semi-transparent glossy blue acrylic plastic… Leaning against the front-bottom corner is a single large metallic gold Zcash coin… Clean mirror-like downward reflection… Negative Prompt: flat design, 2d, vector, modern minimalist, dark background…”

Total: 20 hours of work for a single icon. 5 out of 7 icons are done now. The pain was immense, but the joy of how they look in the interface is even greater.

---

How much is the code worth?

I got curious: how much is the code I’ve already written for MonteZecret actually worth?
I asked my AI security auditor (who knows every single commit of mine).
Here’s what it replied:

Estimated workload: ~640 hours

• Architecture and design: ~80 hrs
• UI system (SDL2 + Rust): ~150 hrs
• Zcash integration: ~100 hrs
• Cryptography and Zeroize: ~80 hrs
• Debugging Rust lifetimes (yes, the borrow checker is pain): ~100 hrs

Realistic market value:

• Minimum (freelance): $15,000 - $25,000
• Average (Senior / Studio): $50,000 - $70,000

If you add R&D (learning Rust and librustzcash from scratch), the real cost crosses $100,000+.

There could be a subtle hint here that patrons could speed up development, but let’s just enjoy the fact that in 4.5 months, working solo, an intellectual asset worth tens of thousands of dollars was created.

640 hours of work. Over 5,000 lines of Rust code. Integration with zk-SNARK-level cryptography. SDL2 UI. Architecture built from scratch.
For comparison:

• A typical startup spends $200,000–$500,000 on a crypto wallet MVP.
• A team of 3-4 developers does this in 6-12 months.
• I’m doing it solo in 4.5 months.

A lone wolf can run faster than the pack, if it chose the right route.

---

The price of Zcash falls and rises

But the truth is simple:
Zcash with zero lines of code = $0
Zcash with millions of lines of high-quality code = billions of dollars

Don’t look at the price right now. Invest in the code.

Zcash isn’t held up by speculation, but by science: zk-SNARKs, Halo, ECC research, dozens of ZIP proposals, and years of cryptographic work.
And yes—there are very few people in the world capable of writing a full-fledged Zcash wallet from scratch.
Maybe less than a hundred.
We are a rare species. Listed in the Red Book of rare developer species.
Protect us…
and feed us.

What’s next?

• Receive funds functionality — done
• Sending Zcash — in progress
• Transaction handling — in progress
• Performance optimization — coming soon
• Icons (5 out of 7) — almost there

And in the next episode, I’ll show you the very first version of MonteZecret.
You’ll be horrified.

But for now—enjoy what we have today in a fresh screencast of the current version:
https://youtu.be/6RzEo-19Ddg

---

Postscriptum for Patrons

There could be a hint about donations here. But instead, I’ll say this: if you want there to be another truly lightweight, fast, and private Zcash wallet in the world—just support it and keep an eye on updates.

Code is the currency of the future. Good code is gold. And optimized Rust code for Zcash is a treasure.

Zcash isn’t just a cryptocurrency. It’s a manifesto of privacy in the digital age. And MonteZecret is my contribution to that manifesto.

One developer. One wallet. Infinite persistence.

Support the Project

To support development, leave a message for eternity (in the encrypted Memo field), and suggest your own name for the wallet at this address:
u1c9qqs5knwe360w6snjuhcldtpf6tcc9nz6xuanmz2xwyf7l4ufze89tze43yz90ajgcej5ylh0a4h2ac65flsvp7a8ewaauvtt4hwsxuhuqvv9h5fkxntw9yk0eyrrlcu004e2havqs0yx58u7kk75e8hff47srsaslc9g6u6rxfn7j9es2g6zc0drd6ajus8wjj2f8p3als53dfc9l

[dismad]

Love your thought process, love the ideas with slide projectors!

[topcrypto]

@ZKZeek

Learning Rust from zero and reaching a working prototype on librustzcash in 4 months is real discipline. Which backend will sync use, zebrad RPC or a lightwalletd style server?

Regarding the backend — we haven’t chosen between the two options yet.

Most likely, we’ll implement both:
Sync via zebrad RPC
Sync via a lightwalletd-style server

Not because we enjoy complexity — but because we want real benchmarks.

We want to measure:

• performance,
• latency,
• stability,
• overhead,
• scalability.

Theory is nice.
But metrics are better.

We may even keep both modes in the long run:

• Full node mode (via zebrad) for maximum sovereignty.
• Light mode (via lightwalletd) for speed and usability.

MonteZecret aims to be not only lightweight — but technically honest.
First we measure. Then we decide.

[topcrypto]

Update: Extreme Optimization Sprint – MonteZecret is Back to Being Lightweight

Hello Zcash Community!

It’s been an intense couple of weeks in the MonteZecret development cave, and I wanted to share both the struggle and the triumph with you all.

The Problem: Binary Bloat Gone Wild

Those who followed my previous updates remember where we left off: after adding new functionality, our binary mysteriously ballooned from a modest 1,820,744 bytes to 7,330,888 bytes. Unexpected and concerning, but we pushed forward.

Over the next few days, as we continued implementing features, the executable size kept growing, eventually reaching a whopping 9,277,384 bytes. For a wallet that aims to be the lightest Zcash desktop solution, this was completely unacceptable.

The Decision: Stop Feature Development, Start Optimization

At 9+ MB, we made a hard decision: pause all new features and focus exclusively on optimization. Sometimes you need to stop moving forward to remember why you started the journey in the first place.

The Result: Mission Accomplished

After several sleepless nights of refactoring, analyzing dependencies, tweaking compiler flags, and ruthlessly eliminating bloat, I’m proud to announce:

MonteZecret is now down to 3,336,512 bytes (~3.3 MB)

We’ve reclaimed our title as the lightest Zcash desktop wallet. The binary is lean, mean, and ready to continue evolving.

What’s Next

Still on the roadmap and actively in development:

• Full blockchain synchronization
• Transaction sending functionality

These features are being written with optimization in mind from day one this time.

4 Lessons from This Development Sprint

For anyone working on crypto projects (or any project, really), here’s what kept me going:

1. Change your goal to eliminate doubt. Instead of “build a Zcash wallet” (outcome uncertain, anxiety-inducing), aim for “make maximum progress today” (100% achievable daily).

2. Write at least one line of code every day. Consistency beats motivation. Motivation fades; habits compound.

3. Master the documentation. For Zcash development, librustzcash docs are your bible. Know them intimately.

4. Find financial support. Enthusiasm is powerful, but rent doesn’t pay itself. (Still searching for sponsors/grants – if anyone has leads, I’m all ears!)

Watch the Full Story

I documented this entire optimization journey in a video (with some philosophical musings on indie development):

Extreme Optimization: How We Put Our Zcash Crypto Wallet on a Brutal Diet

Extreme Optimization: How We Put a #Zcash Crypto Wallet on a Strict Diet (MonteZecret)

Final Thoughts

MonteZecret isn’t just a wallet project anymore. It’s become proof that one determined developer, armed with the right tools and community support, can build something meaningful in the Zcash ecosystem.

If you believe in lightweight, privacy-focused tools built by independent developers, consider supporting the project or spreading the word. Every bit helps.

Code is being written. Progress is being made. The dream is becoming real, one optimized byte at a time.

Stay shielded,
MonteZecret Dev

---

Links:

• Video: https://youtu.be/sDv8B1neJGI
• Previous forum post: MonteZecret - A Desktop Wallet for Zcash in Rust

Support the Project

To support development, leave a message for eternity (in the encrypted Memo field), and suggest your own name for the wallet at this address:
u1c9qqs5knwe360w6snjuhcldtpf6tcc9nz6xuanmz2xwyf7l4ufze89tze43yz90ajgcej5ylh0a4h2ac65flsvp7a8ewaauvtt4hwsxuhuqvv9h5fkxntw9yk0eyrrlcu004e2havqs0yx58u7kk75e8hff47srsaslc9g6u6rxfn7j9es2g6zc0drd6ajus8wjj2f8p3als53dfc9l

[topcrypto]

Update 4 MonteZecret: How We Made Zcash 800x Faster and Why Dash Is Still Quicker

"To catch a criminal, you need to pretend to be a criminal and think like a criminal.
To become a Zcash developer, you need to pretend to be a Zcash developer and think like a Zcash developer."

---

The Problem Nobody Talks About

There’s one serious UX problem with Zcash. A really serious one.

Imagine this: a regular user downloads Unstoppable Wallet, enables Zcash and Dash cryptocurrencies, hits the “Sync” button, and… waits.

Dash loads in seconds. Zcash crawls like a snail on sedatives.

Regular users don’t think about technology. They don’t know what Zero-Knowledge Proofs, Sapling, Orchard, or SPV are. They see only one thing: one cryptocurrency is faster than another.

And this is a serious problem for Zcash.

Because in the world of cryptocurrency, speed = trust. If your wallet is slow, the user thinks: “Maybe the coin itself is sluggish?”

We solved this problem. And here’s what we came up with.

---

Why Is Dash Faster? (Spoiler: It’s Not Fair)

At first glance, it might seem impossible to fix.

Dash uses SPV (Simplified Payment Verification) technology. The wallet asks the node: “Give me only those block headers that contain my address”. And gets them in seconds.

Zcash can’t do that. The wallet needs to download all blocks and check them itself using an IVK (Incoming Viewing Key) to see if there are transactions for our address.

It’s like the difference between:

• Dash: “Bring me only the pages I need from the book”
• Zcash: “Bring me the whole book, I’ll find the pages I need myself”

Sounds like a death sentence, right?

But as it turned out, a combination of modern technologies can solve this problem.

To do this, we had to conduct a whole study—a series of benchmarks (performance measurements) that, as far as we know, no one had ever conducted before.

And we decided to share this study on GitHub—as a treasure map for all new Zcash wallet developers.

Using this data, you’ll be able to find the best way to write the fastest wallet for Zcash.

---

Have You Ever Wondered Why Thin Smartphones Are So Expensive?

Fitting a huge number of boards, microchips, and other equipment into a thin case is a true miracle of engineering.

But it’s a very expensive pleasure.

Although people who buy such devices know how to appreciate quality and human ingenuity. That’s why demand for such devices exists only among premium customers.

That’s exactly what we want to create—the lightest and fastest wallet for Zcash—MonteZecret.

Written in Rust instead of C++. Because Rust is like a thin smartphone: hard to create, but the result is worth it.

So let’s see what we came up with and what technologies need to be used in a modern Zcash wallet for working with the blockchain.

---

Optimization 1: Batch Size (Group Requests)

The Idea

The biggest speed boost comes from using group request and block range retrieval technology.

This is very convenient for both the server and the wallet.

Instead of asking:

• “Give me block 1001000”
• “Give me block 1001001”
• “Give me block 1001002”
• … (1000 times)

We say:

• “Give me blocks from 1001000 to 1002000”

And get data for 1000 blocks at once in a single request.

Results

This gives a speed increase from:

• 7 blocks per second with sequential loading of 1 block at a time (Test 2: Zcash Sequential and Test 4: Zcash Reverse)
• to 3096 blk/sec with Batch Size 5000 (Test 3.1)
• or to 3277 blk/sec with Batch Size 10000 (Test 3.1)

The speed increase is:

((3096 + 3277) / 2 - 7) / 7 × 100% = +45,421%

Forty-five thousand percent. That’s not a typo.

What’s the Best Batch Size?

The direct answer: it’s best to use a dynamic batch size—large for fast nodes, small for slow nodes.

But if you need specific numbers, our tests provide those too.

First, the maximum batch size for Dash wallet is 2016 blocks. Accordingly, a modern Zcash wallet’s batch size should not be less than 2000 blocks.

Second, in the results of a series of block loading tests with different batch sizes, you’ll find the following data:

Batch Size: 10000
blk/sec: 7071
Increase vs previous: +60%
Increase vs 500: +657%

Batch Size: 20000
blk/sec: 10277
Increase vs previous: +45%
Increase vs 500: +1000%

Batch Size: 50000
blk/sec: 11641
Increase vs previous: +13% 🔴
Increase vs 500: +1147%

That is, the speed increase when changing Batch size from 10000 to 20000 is +45%, while the speed increase when changing Batch size from 20000 to 50000 is only +13%.

The efficiency of increasing batch size drops significantly.

Our Recommendation

The optimal batch size is from 2000 to 20000 blocks.

On slow servers, you can even use batch size = 1000 if you apply dynamic batch size technology.

---

Optimization 2: Zero-Copy (Zero Copies)

The Idea

The winning test is Zero-Copy (Test 7).

Average speed: 3748 blk/sec

It wins because it doesn’t use the unnecessary functionality of SQLite and other relational databases.

Relational databases aren’t needed for storing blockchain blocks because we have no relationships with other tables—this functionality is simply unnecessary.

It’s better to use non-relational databases (or just store in memory) for storing Zcash blockchain blocks.

Results

The speed increase is:

(3748 - 7) / 7 × 100% = +53,442%

or

(53442 - 45421) / 45421 × 100% = +17.66%

compared to batch optimization.

This seems small, but the cumulative effect from combining such optimizations can be enormous.

Zero-Copy Is the Absolute Leader

Place: 1
Test: Zero-Copy
Wins: 6 out of 11 runs
Percentage: 55%

Why is Zero-Copy so fast?

• Skips Protobuf deserialization (stores raw bytes)
• Uses Arc<[u8]> for zero-copy conversion
• Parallel processing via rayon
• Shared memory without data copying

---

Optimization 3: True Reverse Batch (Spend Before Sync)

The Idea

This optimization won’t increase speed—on the contrary, it will slightly decrease it.

But it’s very important for user experience.

True Reverse Batch (Test 4.2)
Average speed: 2243 blk/sec

The thing is, the latest blocks are more relevant for an active crypto wallet.

Loading them allows the user to spend received Zcash even before all other blocks are loaded.

This is Spend before Sync technology.

Comparison with Competitors

The YWallet wallet doesn’t have reverse blockchain loading.

So, by implementing this functionality, we’ll be better than YWallet.

By the way, we recently switched from YWallet to the ZKool2 wallet. But even ZKool2 doesn’t use this technology.

Why Is This Important?

Imagine: you received Zcash for work. You need to buy coffee urgently.

Without True Reverse Batch:

• Wait 15 minutes for the entire blockchain to load
• Only then can you spend Zcash

With True Reverse Batch:

• The latest blocks load in seconds
• You see your balance immediately
• You spend Zcash right away
• The remaining blocks load in the background

This is a huge difference in UX.

---

Optimization 4: Work-Stealing (Parallel Loading)

The Idea

Loading data in parallel from different nodes.

Work-Stealing (Test 6)
Average speed: 738 blk/sec

Multi-Node (Test 5)
Average speed: 575 blk/sec

At the same time, if we—like in BitTorrent technology—distribute more work to fast nodes, taking work from slow nodes, this gives a performance boost:

(738 - 575) / 575 × 100% = +28%

Bonus: Reliability

And this also increases the reliability of the Zcash wallet.

If one node goes down, others continue working. Like in a distributed system.

---

Optimization 5: Dynamic Node List

The Idea

If we read active nodes on request from another node, we get a more complete list of 26 active nodes.

This is more than the 15 nodes initially hardcoded in the config.toml file, and gives a noticeable speed boost.

Results

Work-Stealing (15 nodes): 452 blk/sec
Work-Stealing (26 nodes): 976 blk/sec
Improvement: +116%

One hundred sixteen percent. Almost doubling the speed.

Just because we load an up-to-date list of nodes from the network instead of using a hardcoded list.

---

Optimization 6: zImport (Instant Import)

The Problem

When you’ve fully loaded the wallet, you know which blocks contain your transactions.

It’s all the more sad when, when importing a wallet via seed-phrase, you lose this data and have to redo the work to gather this information.

Our Solution

In our opinion, the best solution is a technology we called zImport.

In the import file [wallet_name].zimport, we write not only the seed-phrase, but also an array of block numbers containing the user’s transactions.

Encryption

The file itself is encrypted just like wallet.key, with the master password:

[array of block numbers] + master password
    → bincode::serialize()
    → Blake2b512(salt + master password)
    → PBKDF2-HMAC-Blake2b512(25,000 iterations)
    → AES-256-GCM(key, nonce, data)
    → [wallet_name].zimport

After import, we scan blocks only from last_synced_height to the current one.

Result

With this format, we can synchronize the wallet almost instantly.

Maybe someone has already done this before us, but then we reinvented it.

---

Final Performance Table

Ranking by Number of Wins

Place 1: Zero-Copy — 55% wins
Place 2: Batch Size 10000 — 27% wins
Place 3: Batch Size 5000 — 18% wins

Top 3 Strategies

🥇 Zero-Copy: 3748 blk/sec (average)
🥈 Batch Size 10000: 3277 blk/sec
🥉 Batch Size 5000: 3096 blk/sec

Sync Time Forecast

For the full Zcash blockchain (3.4M blocks):

Sequential:              6.3 days      ❌ Unacceptable
Reverse Single:          6.9 days      ❌ Unacceptable
Dash SPV (Blockchair):   8.7 hours     ⚠️ Long
Multi-Node (15 nodes):   2.5 hours     ⚠️ Acceptable
Work-Stealing (15 nodes):2.1 hours     ⚠️ Acceptable
Multi-Node (26 nodes):   1.3 hours     ✅ Good
Work-Stealing (26 nodes):58 min        ✅ Good
Dash SPV ElectrumX:      36 min        ✅ Excellent
Batch Size 5000:         18 min        ✅ Excellent
Batch Size 10000:        17 min        ✅ Excellent
Zero-Copy:               15 min        ✅ BEST RESULT

---

Bonus: Treasure Map for Developers

We’ve published all our benchmarks on GitHub:

https://github.com/openkoder/benchmarks_zcash/

There you’ll find:

• Full benchmark code in Rust
• Results from 11 runs
• Charts and visualizations
• Recommendations for optimal parameters
• Implementation examples for each optimization

Use this data as a treasure map for creating the fastest Zcash wallet.

---

Conclusion

We’ve proven that Zcash can be just as fast as Dash.

To do this, you need to use a combination of optimizations:

1. Batch Size from 2000 to 20000 blocks (+45,421%)
2. Zero-Copy without relational databases (+53,442%)
3. True Reverse Batch for Spend before Sync
4. Work-Stealing for parallel loading (+28%)
5. Dynamic node list (+116%)
6. zImport for instant import

Together, these optimizations give an 800x speed increase compared to naive sequential loading.

Zcash no longer has to be a snail.

Now it’s up to wallet developers. You have the treasure map. Use it.

---

Acknowledgments

Thanks to the Zcash Community for support and inspiration.

Thanks to Rust for existing.

---

Additional Resources

• Zcash Documentation
• Rust Programming Language
• Zero-Knowledge Proofs Explained

---

If you liked this article, give it a and share it with your Zcash developer friends.

Let’s make Zcash faster together!

We’re Still Looking for Sponsors

We’re still seeking sponsors for our project — the lightest and now, quite possibly, the fastest crypto wallet for Zcash. Because, you know, rent doesn’t pay itself.

Jokes aside, developing a high-performance wallet in Rust requires time, coffee, and electricity. If you believe in our mission to make Zcash faster and more user-friendly, your support would mean the world to us.

Every contribution, no matter how small, helps us continue this work and bring a better Zcash experience to the community.

To support development, leave a message for eternity (in the encrypted Memo field):
u1c9qqs5knwe360w6snjuhcldtpf6tcc9nz6xuanmz2xwyf7l4ufze89tze43yz90ajgcej5ylh0a4h2ac65flsvp7a8ewaauvtt4hwsxuhuqvv9h5fkxntw9yk0eyrrlcu004e2havqs0yx58u7kk75e8hff47srsaslc9g6u6rxfn7j9es2g6zc0drd6ajus8wjj2f8p3als53dfc9l