2) Technical review I wanted to approach this differently from a normal launch review because I’ve been following the technical side of Nullmask since before release, including the whitepaper, previous PoC, Sepolia transactions and contracts. Now that the actual product is live, the main question for me was simple: Did they actually ship what they’ve been describing? So far, from what I’ve tested myself, the answer is largely yes. Nullmask isn’t simply a mixer or a deposit → withdraw privacy pool. The architecture is designed around a shielded UTXO environment that you access through your existing wallet. Under the hood, the official documentation describes a UTXO-based privacy pool using Poseidon2 commitments, Merkle membership proofs, client-side ZK proofs and relayers. The current ZK stack is Noir + Barretenberg. The protocol supports shielded deposits, transfers, withdrawals and swaps while keeping the familiar EVM wallet UX instead of requiring users to manage a completely separate privacy wallet. The basic flow can be simplified as: existing wallet → screening → shield → private UTXO state → private transfers/swaps → withdrawal One of the first things I tested was the compliance layer. I deliberately tested wallets I know have been flagged. They failed the AML screening and were prevented from entering the shielded pool, with a refund path available instead. Low-risk wallets were able to proceed normally. Fresh wallets also go through an initial ~15-minute quarantine on their first deposit. During this period, the user still has the option to refund rather than continue shielding. Once that first process is completed, the wallet becomes recognized by the system. The documentation also describes deposit screening and retrospective taint recovery through revocation keys. Conceptually, I think this is one of the more interesting parts of Nullmask: Compliance before entering the privacy set. Privacy once you’re inside it. Then there are the Waves. This is probably one of my favorite parts of the product because Nullmask doesn’t pretend privacy is binary. Generating a valid ZK proof doesn’t automatically make behavioral correlation disappear. If you deposit funds and immediately withdraw a similar amount, timing and amount analysis can still provide clues to an observer. Nullmask makes this trade-off visible in the UI. Instead of simply telling the user “your transaction is private,” the interface shows how the deposit progresses through privacy waves/crowds and provides different withdrawal possibilities depending on whether your priority is speed or stronger privacy. In simple terms: withdraw sooner → faster access, but potentially easier temporal correlation wait through additional privacy activity/waves → harder correlation and potentially stronger practical anonymity I really like this because it exposes an important part of operational privacy that most users would otherwise never think about. There are also different scenarios depending on where you send the funds. If you send shielded funds to another wallet registered within Nullmask, the transfer can remain inside the shielded environment. The protocol documentation describes these shielded transfers as hiding sender, recipient and amount on-chain. This means two Nullmask users can transact without continuously leaving the private state. If the destination is a normal wallet outside the Nullmask shielded environment, however, the funds eventually have to touch the transparent blockchain again. At that point, information such as the exit amount and destination can become publicly observable. That distinction is extremely important. Nullmask isn’t making a public blockchain magically invisible. The objective is to break the observable relationship between the funds entering the pool, the activity happening privately inside it and their eventual exit. So there’s a major difference between: Nullmask → Nullmask and Nullmask → normal public address The first can remain shielded. The second eventually creates a public on-chain event. Gas is another detail I think people will overlook. Before performing certain withdrawals, you need enough gas available within the Nullmask flow. This makes sense from a privacy perspective: if your transparent wallet had to directly fund every shielded action, the gas payer itself could become another correlation vector. So gas isn’t just a UX issue here. How gas is funded and relayed is part of the privacy model. Then there are the swaps. The live version I tested currently allows ETH ↔ USDT swaps using shielded funds inside the private pool. The documentation also describes shielded swaps and ERC-20 support. This is where I think Nullmask becomes significantly more interesting than a traditional mixer. You don’t necessarily have to: shield → wait → withdraw You can instead: shield → hold privately → send privately → swap privately → continue operating privately → withdraw when you actually want to return to the public chain That starts looking much more like a private DeFi environment than a mixer. Another part worth mentioning is Points. The live product includes a points system tied to usage, with points intended to play a role in future ecosystem rewards/airdrops. I’d personally wait for the final distribution mechanics before assigning any monetary value to those points, but from a product perspective, it creates an incentive for people to actually use the privacy infrastructure rather than simply hold solana:HuAXPyDWDaMYFKuwQHpqL1oPnj93zdzWmtvFGzCeCUa7 and speculate. There’s also a broader multichain thesis here. The documentation describes Nullmask across multiple EVM environments, making the long-term idea much bigger than a privacy application isolated to a single chain. From a technical perspective, what impresses me most after using the actual product is that several different layers have been combined into one relatively understandable UX: existing wallet authorization AML / deposit screening shielded UTXO state client-side ZK proofs relayer execution privacy waves / timing protection shielded transfers shielded swaps different withdrawal strategies gas management points / usage incentives The underlying technology is obviously much more complicated than what the average user sees, but that’s exactly the point. Good privacy infrastructure shouldn’t require the average person to understand Merkle trees, commitments, nullifiers or ZK circuits just to make a private transaction. And after testing the live product, the biggest difference versus what I was analyzing before launch is that I no longer have to judge Nullmask purely from a whitepaper or PoC. There is now an actual product to interact with. What I’ve tested so far is consistent with the architecture Nullmask has been describing: shield funds, enter a private UTXO environment, transact within that shielded state, swap shielded assets and eventually choose how and when to exit. That doesn’t mean I’m ready to claim the protocol is cryptographically bulletproof. A working frontend and successful transactions do not replace independent audits. I still want to dig further into the production contracts, ZK circuits/verifier, nullifier enforcement, relayer infrastructure, AML/revocation model and exactly how the privacy/wave indicators shown by the UI are calculated. Those are important distinctions between a product that works and a privacy protocol whose security guarantees have been independently validated. But as a product review? This is very close to what I wanted Nullmask to ship. The easiest way I can describe my thesis after actually using it is: Nullmask isn’t trying to give you somewhere to temporarily hide your funds. It’s trying to give your existing wallet an entire private financial environment. Shield privately. Hold privately. Send privately. Swap privately. Choose when and how you return to the public chain. Now the real test begins: adoption, liquidity, anonymity set growth, volume and how the infrastructure performs as more users enter the system. But technologically, there is finally something real here to evaluate. solana:HuAXPyDWDaMYFKuwQHpqL1oPnj93zdzWmtvFGzCeCUa7