ZeroSwaps

We’re closing the ambassador application form - thanks to everyone who applied. We’ve already reached out to some candidates and are still reviewing submissions, so a few more of you may hear from us soon. Appreciate all the interest 🤍

Applications for the ZeroSwaps Ambassador Program are live. We’re looking for people who enjoy explaining complex ideas, testing new systems, and contributing to discussions around privacy and decentralized trading. If you want to be involved beyond surface-level marketing, you can apply here: form.zeroswaps.xyz

How ZeroSwaps Balances Privacy and Verifiability in DEX Design Decentralized exchanges were never about being elegant. They were about removing trust. Settlement moved on-chain, contracts became public, and verification stopped being a privilege. If a trade happened, anyone could check it. That was the deal. This worked. Not perfectly, but well enough. Non-custodial trading became normal, liquidity stopped being experimental, routing logic got smarter. The core mechanics of DEXs are no longer the hard part. What never really got revisited is how much of the execution needed to be public for this system to function. Most DEX designs quietly assume the answer is “all of it”. ZeroSwaps doesn’t. Verifiability and Visibility Are Not the Same Thing A DEX needs to be verifiable. That part isn’t negotiable. Trades must follow the rules, balances must add up, nothing can be created or destroyed arbitrarily. Classic DEXs achieve this by exposing everything. Addresses, assets, amounts, timestamps, routing paths. The entire execution trail is written to the chain and left there permanently. It works, but it also conflates two different ideas. Verifiability gets bundled together with full visibility, as if one cannot exist without the other. That assumption is mostly historical, not technical. Zero-knowledge systems showed a long time ago that correctness can be proven without revealing inputs. A computation can be verified as valid while the data that produced it stays hidden. The proof is public. The details are not. ZeroSwaps applies this logic to trade execution. Instead of saying “look at everything and decide if it’s correct,” the protocol says “here is a proof that it followed the rules.” That’s a different trust model, but not a weaker one. What Public Execution Actually Costs Fully transparent execution has side effects that are easy to ignore until they become normal. When trades are visible before settlement, intent leaks. Size, direction, timing - all of it can be inferred early enough to react to it. MEV strategies aren’t some accidental exploit; they are the rational response to public execution. Over time, this has been reframed as market behavior rather than a design consequence. There’s also the long tail. On-chain histories don’t fade. Once a wallet is linked to an identity, its behavior across months or years becomes trivial to reconstruct. Strategies, habits, even mistakes stay permanently accessible. None of this breaks verification. But it does change who benefits from transparency and who pays for it. ZeroSwaps treats these outcomes as architectural, not incidental. How ZeroSwaps Approaches Execution ZeroSwaps does not try to hide outcomes. Trades still settle. State still updates. The chain still enforces the rules. What changes is what gets revealed in order to prove that this happened correctly. Using zero-knowledge proofs, ZeroSwaps can show that a trader had sufficient balance, that the swap followed protocol constraints, and that settlement was valid, without publishing addresses, amounts, or linkable execution traces when privacy mode is enabled. The chain verifies correctness. It does not learn intent. This moves transparency away from raw data exposure and toward rule enforcement. The system remains auditable, but execution details stop being the audit surface. Privacy Is an Execution Choice One deliberate decision in ZeroSwaps is not to force privacy. When privacy mode is off, execution looks familiar. Trades behave like they would on a classic DEX. When it’s on, execution becomes private, but it doesn’t move into a separate system or pool. This matters. Treating privacy as an execution option rather than a parallel architecture avoids isolating private trades or fragmenting liquidity. It also avoids framing privacy as something “special” or exceptional. It’s just another way to execute a trade. Non-Custodial, Still None of this introduces custody. Users control their funds. There is no intermediary that needs to be trusted to behave correctly or keep secrets. Proof verification is permissionless. Anyone can check that the protocol followed its rules. What disappears is not verifiability, but unnecessary exposure. That distinction is easy to miss, and central to the design. Rethinking What DEX Transparency Is For Transparency enabled DeFi to exist. It made systems inspectable and composable. That part doesn’t go away. But transparency at the execution layer also creates adversarial dynamics that aren’t strictly required for trustlessness. ZeroSwaps sits in that gap, not trying to undo transparency, but to scope it. Correctness stays public. Intent does not have to be. Closing Thoughts DEXs solved custody. That was the first milestone. Execution transparency came with it, mostly unquestioned. ZeroSwaps builds on what already works and asks whether full visibility is actually a requirement, or just an inherited assumption. By separating verifiability from visibility, it sketches a different execution model - one that keeps decentralized guarantees intact while reducing the cost of being on-chain. As DeFi matures, this may stop being a preference and start being a constraint.

ZeroSwaps is designed around a simple but often ignored constraint of decentralized markets: transparency is a tool, not a default. DEXs have proven that non-custodial trading works at scale. Liquidity, routing, composability - all of that is solved well enough to support real volume. What remains unresolved is how much information is leaked in the process of execution. Every public order reveals intent. Size, timing, routing logic, even strategy can be inferred before execution is finalized. This exposure isn’t a flaw in a specific protocol, it’s a structural consequence of how execution is currently handled. ZeroSwaps introduces zero-knowledge execution as a native layer. Not to obscure markets, but to reduce unnecessary leakage while preserving verifiability and decentralization. The goal is not to replace existing DEX primitives, but to extend them with privacy guarantees that align with how efficient markets should function.

If you’re interested in the difference between @zeroswaps and classic DEXs, this article breaks it down in detail. zeroswaps.medium.com/the-difference…

Our website is live. You can now: - join the waitlist - explore the documentation - get a preview of ZeroSwaps All in one place. Explore ZeroSwaps → zeroswaps.xyz