DEV Community: Anthony Montanez

From Build Club to MainNet Building Shadow labz on Midnight

Anthony Montanez — Mon, 05 Oct 2026 11:35:58 +0000

From Build Club to Mainnet: My Journey as a Midnight Developer

I'd like to introduce a project I've been working on throughout the summer: Shadow Labz.

It started as a project during Midnight Build Club, an eight-week program where I joined a group of developers building products using Midnight technology.

Over those eight weeks, an idea slowly turned into an actual platform.

But before I show you what we built, we have to go back to where everything started.

Surveys!

Have you ever completed a poll or survey?

You know the type: a few multiple-choice questions, maybe some ratings, and a little feedback box at the bottom.

They may seem simple, but surveys can be incredibly useful.

You can gather data, identify patterns, discover problems you may have overlooked, and learn more about the people you're trying to build for.

Usually, you create a group of questions, send them to a particular audience, collect the responses, and then use that information to form a hypothesis.

That's exactly what we did.

We created a survey focused on DAOs and Web3 communities and shared it with DAO members, community managers, and people interested in starting their own DAOs.

One thing stood out:

Communities were spending a lot of money and effort piecing together their infrastructure.

Voting might happen on one platform.

Treasury information might live somewhere else.

Community discussions happen on Discord.

Token or NFT verification requires another tool.

Calendars, proposals, analytics, and other community tools are often scattered across completely different services.

That gave us an idea:

What if we could build something similar to platforms like Snapshot or Tally, but focused on private governance, community tooling, and cross-chain functionality?

And that is how Shadow Labz was born.

Wait... What Is a DAO?

DAO stands for Decentralized Autonomous Organization.

That sounds complicated, but the idea is much simpler than the name.

At its core, a DAO is a way for a community to govern itself.

One of the most common features of a DAO is a proposal.

A proposal could be:

A budget request
A new feature
A community decision
A change in direction
A funding request
A new rule

Community members then vote on that proposal.

Ideally, the result represents what the community wants.

But there is one major problem with traditional Web3 governance:

Everything is often public.

Your wallet is public.

Your vote can be public.

Your voting history can be public.

Your delegation can be public.

Depending on the community, that can create pressure around how someone votes.

That is where Midnight became especially interesting to us.

With Midnight, we can explore governance where certain information can remain private while still allowing the system to verify that the rules were followed.

For Shadow Labz, that means building toward things like private voting and private governance, where users do not necessarily need to publicly expose how they voted.

No public vote history.

No pressure to explain why you voted a certain way.

The community gets the result without requiring every participant to reveal everything about themselves.

Building the Tools Communities Actually Need

Voting was only the beginning.

Once we started thinking about community governance, another question came up:

What else does a community need?

Quite a lot, actually.

Treasury Tracking

A proper treasury is one of the most important parts of many communities.

Who controls it?

How much money is coming in?

How much is going out?

Where are funds being sent?

Is the community able to see what is happening?

Blockchain already gives us something incredibly useful here: transparency.

For example, imagine your community treasury is on the XRP Ledger.

The wallet already exists on-chain.

So instead of forcing the community to manually search through transactions, why not give them a dashboard?

That's essentially what we built.

A DAO can add a wallet address that it wants the community to monitor.

Shadow Labz can then display information such as:

Treasury activity
Incoming transactions
Outgoing transactions
Balance information
Visual charts and statistics

It gives the community a much easier way to understand what is happening with its treasury.

Keeping Everyone in Sync

Another feature I built was a calendar.

It sounds simple, but community coordination becomes difficult very quickly when you're part of several groups.

Our calendar syncs events across the DAOs you've joined.

For example, it can show upcoming proposal deadlines so you don't forget to vote before a proposal closes.

Communities can also create custom events and attach links.

Maybe it's:

A community call
A governance meeting
An AMA
A livestream
A funding deadline
A product launch

Even creators could use it.

If you run a YouTube channel, for example, your community could see when you're planning to go live.

Governance isn't only about voting.

It's also about helping communities stay organized.

Gating Your Community

Another feature we're excited about is community gating.

There are thousands of NFT communities that want more ways to give their NFTs utility.

Governance is one possible use case.

Imagine owning an NFT that doesn't simply sit inside your wallet.

Instead, that NFT could grant access to a community, unlock governance features, or determine a member's role inside that community.

It also provides another layer of verification.

We are exploring things like different permissions for different NFT tiers.

For example, a particular NFT collection or NFT trait could eventually unlock a special community role.

We're also exploring weighted voting.

Maybe a community wants members holding a particular asset to have additional voting weight.

Or perhaps users need to hold a minimum amount of a token before they can join a DAO.

These systems have to be designed carefully, so we're actively gathering feedback and figuring out what makes the most sense for different types of communities.

And gating isn't limited to NFTs.

Tokens can be used as well.

That opens up a lot of possibilities for how communities determine membership and participation.

A Full-Circle Moment

One of my favorite parts of this project is that we eventually came right back to where everything started.

Polls and surveys.

My partner actually brought this idea up very early in the project.

At the time, we were focused heavily on DAO governance.

But eventually we realized:

Why stop at governance proposals?

Private polling could be useful almost anywhere.

So we built Shadow Polls.

You could use a poll during a livestream to ask your audience:

Who should the next guest be?

Or:

What song should we play next?

You could use polls at events, inside online communities, for feedback, or simply to gather opinions.

Then we took it another step further.

Instead of only creating a single poll, you can create an entire survey.

Multiple questions.

Different answer types.

Feedback boxes.

Essentially the same kind of tool we originally used to gather the information that helped us design Shadow Labz in the first place.

That's probably my favorite full-circle moment of the entire project.

We used surveys to help us understand the problem.

And now surveys are part of the product.

Even better, people using the polling experience don't necessarily need to already understand Midnight or manage a crypto wallet themselves.

We can handle much of that complexity behind the scenes.

For me, that's important.

Blockchain applications shouldn't require every user to become a blockchain expert before they can use them.

From Build Club to Mainnet

And then came one of our biggest milestones.

Mainnet.

What started as an idea during Midnight Build Club became something we could actually build, test, iterate on, and bring forward as a real product.

Shadow Labz is now our attempt at building a privacy-focused governance and community platform that communities can actually use.

The goal is bigger than simply creating another voting website.

We want to give communities the tools they need to govern themselves while taking advantage of what blockchain and privacy technology can offer.

With our base experience, communities can start with features such as:

Private voting
Proposal management
Discord integration
Community tools

And if you just want to experiment with private voting without creating an entire DAO, you can check out the polling tools as well.

No deep blockchain knowledge required.

What I Learned

Build Club taught me something that I think a lot of developers eventually learn:

The first version of your idea probably isn't the product you end up building.

We started by asking questions.

Those questions led us to DAOs.

DAOs led us to private governance.

Governance led us to treasuries, calendars, token gating, Discord integrations, polls, and surveys.

And somehow, after building all of that, we ended up right back at the surveys that started the journey.

That's what made this experience so interesting.

Shadow Labz wasn't something I completely designed on day one.

It evolved through feedback, conversations, experiments, mistakes, and actually building things.

And we're still figuring out where it goes next.

A huge thank you to Midnight Build Club and everyone who gave us feedback throughout the process.

From Build Club to mainnet has been a crazy journey.

And I think we're only getting started.

Until Next Time

Love you all.

MrParanormal39

Shadow Labz: https://www.shadowlabz.io

How Midnight Brings Privacy to DAO's

Anthony Montanez — Sat, 18 Apr 2026 16:56:46 +0000

Why DAOs on Midnight Are Better

You may be wondering: what is a DAO?

A DAO, or decentralized autonomous organization, is basically a company, community, or group that is run by code instead of traditional leadership structures. So instead of a board of directors or a CEO making all the calls, you have a group of people who can vote on proposals and help guide decisions.

That part is not new.

What is exciting is what happens when you bring DAOs to Midnight.

The problem with traditional DAOs

On a regular public chain like Ethereum, you can absolutely build a DAO and let people vote on proposals.

The problem is that those votes are usually visible on the public ledger.

That is great for transparency and verifying results, but not so great if privacy actually matters. In some situations, people may not want their votes, activity, or participation exposed for everyone to see.

That is where Midnight stands out.

Why Midnight changes the game

On Midnight, you can cast a vote, keep that vote private, and still verify that the vote was made correctly.

That is a huge difference.

You still get verifiable outcomes, but without exposing everything publicly. That opens the door for a very different kind of DAO design, especially for use cases where privacy matters.

You can already imagine how this could change the way DAOs work across different industries and communities.

Want to see how it works?

If you are curious about the implementation, check out the GitHub link below.

paranormal39 / midnight-example-dao

Midnight DAO Voting DApp

A privacy-preserving DAO voting contract using a commit/reveal scheme with cryptographically enforced privacy:

Commit/Reveal Voting - Two-phase voting where votes are hidden during commit phase and revealed later
Circuit-Derived Nullifiers - Nullifiers computed inside ZK circuits using persistentCommit to prevent double voting
MerkleTree Commitments - Vote commitments stored in a MerkleTree for privacy
Tally Enforcement - Vote tallies incremented inside the reveal circuit (cryptographically enforced)
Three vote types - YES, NO, and APPEAL options
Proposal State Machine - Proposals progress through COMMIT → REVEAL → FINAL phases

For detailed DAO documentation, see:

DAO-CONCEPTS.md - Core concepts and architecture
DAO-DEPLOYMENT.md - Deployment and API reference

Network Targets

Supports Preprod testnet (recommended for getting started):

Network	Description	Command
Preprod	Public testnet	`npm run start-ps`

Project Structure

example-dao/
├── contract/                          # Smart contracts (Compact language)
│   ├── src/dao.compact                # DAO voting smart contract
│   ├── src/dao-witnesses.ts           # DAO witness

…

View on GitHub

You can also check out the YouTube demo linked below and follow along with the walkthrough.

In the demo, I go over the installation process and some of the core differences between a typical DAO and a DAO built on Midnight. The cool part is that you can take this code, customize it, and use it as the foundation for your own DAO.

A quick look under the hood

One big difference is that instead of traditional Solidity-style functions, Midnight uses circuits. These circuits define the logic that gets proven with zero-knowledge proofs.

The proof server then helps generate a proof showing that the transaction followed the contract rules, without exposing the private data behind it.

That means you can verify that something was done correctly without putting all the sensitive details out in public.

What about the data?

So how is that data handled?

Before it ever leaves your machine, it gets hashed. That means the information is already being transformed into something cryptographic before it reaches the proof server. That adds another layer of security to the overall flow.

Why this matters

This is really just the beginning.

We already see DAOs shaping governance, communities, and digital coordination. But privacy-first infrastructure like Midnight could help take DAOs into areas where privacy is not optional.

Think about things like:

health-related governance
personal finance
private organizations
sensitive voting systems

That is where this starts to feel a lot bigger than just another DAO demo.

Final thoughts

This is where things get exciting blockchain can now start stepping in these more regulated business sectors.Midnight helps with that by puting privacy first.

Follow me on all platforms: @mrparanormal39

Building a DAO Into My Game🎮

Anthony Montanez — Fri, 12 Sep 2025 14:47:56 +0000

What is a Decentralized Autonomous Organization (DAO)?

A DAO is a new way for communities to operate. But what does that really mean?
What is its purpose? Has it actually benefited us?

These are the questions I asked myself while diving deeper into Web3.

Back at Consensus 2024, I noticed something important: hackathon judges were especially drawn to projects that integrated DAOs. That’s when I realized my original project was falling behind. So I scrapped it and decided to start fresh, with a broader vision.

https://itch.io/blog/937235/-devlog-1-the-throne-is-empty

That’s how Kingdom of Gold evolved into not just a game, but a community-driven experiment in governance.

DAO Proposals That Fit Well in Games

Here are three proposal types I believe work perfectly with Kingdom of Gold:

Treasury Allocation

Simple but powerful: the community can decide to swap one asset for another. Example → Sell some GXG (the in-game token) for XRP, or flip it the other way. This gives real power to the community treasury and keeps governance meaningful.

Rule Changes

Players know their experience best. Proposals can address mechanics, economy tweaks, or community-driven balance changes. This helps developers avoid tunnel vision while giving the player base a true voice in shaping the game.

Story-Driven Decisions

This is my favorite. Imagine the DAO as a Dungeon Master in D&D.
Factions might split off, unite, or change the world’s narrative direction. It adds replayability and unpredictability that I can’t wait to see in action.I also love the idea of combining this with AI prompt allowing players to craft the story of the world they are playing in.

Finish Line Within Reach

(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wfqhgto5z4obqpdvzi6n.png)
Kingdom of Gold is almost ready. With NFT minting for Phase 1 on the horizon, I’m wrapping up core systems and preparing to test what works (and what doesn’t).

This project is more than just a game—it’s a testbed for community-driven governance, storytelling, and Web3 design.

Takeaways

DAOs aren’t just about finance—they can reshape how games are built and played.

Community governance can drive everything from treasury decisions to storyline changes.

Kingdom of Gold is my experiment in merging DAO mechanics + game design, and we’re almost at launch.

Follow Along

If you’d like to see how this unfolds:

🐦 Follow me on X
https://x.com/MrParanormal39

🎮 Check out the project on Itch.io

https://paranormal09.itch.io/

Also my most recent Hackathon Entry for Midnight

Thanks for reading, and I’ll share more updates soon 🚀

🛡️ ZK Guild Gate - Privacy-Preserving NFT Verification

Anthony Montanez — Sat, 06 Sep 2025 02:07:07 +0000

This is a submission for the Midnight Network "Privacy First" Challenge - Protect That Data prompt

What I Built

ZK Guild Gate is a privacy-preserving access system that uses Midnight’s Compact smart contracts and zero-knowledge proofs to verify NFT ownership without revealing wallet addresses or token IDs. It enables truly anonymous guild membership, gated content, and role-based access while protecting user identities and assets.

Still In development

Demo

https://github.com/paranormal39/zk-guild-gate

How I Used Midnight's Technology

ZK Guild Gate uses Midnight’s Compact contracts, proof server, and SDK to verify NFT ownership through zero-knowledge proofs and nullifiers. Only a Merkle root and one-time nullifiers are stored on-chain, ensuring eligibility checks without revealing addresses or token IDs.

Data Protection as a Core Feature

Privacy is the product: users prove membership without exposing who they are or which NFT they hold, with unlinkable proofs and replay protection. This makes guild access and gated perks truly anonymous, aligning directly with Midnight’s core value of data protection.

Set Up Instructions / Tutorial

Clone the repository: git clone https://github.com/paranormal39/zk-guild-gate and navigate into the folder.

Install dependencies with npm install.

Start your Proof Server (this step is required before running the app).

Launch the development server with npm run dev.

Closing Notes

As I explore DAOs through my game Kingdom of Gold, I see Midnight positioned as a cornerstone for privacy in the blockchain space. With further development, this project could serve as a foundation for a wide range of future applications.

Follow me for updates on my projects

https://x.com/MrParanormal39