The first private DeFi layer. Trading and smart contracts nobody can watch.
On every other chain, DeFi is a glass box: anyone can see who traded, how much, and every position. Ion Swap trades in sealed batches that publish one price and nothing else, and its smart contracts are written in Dark Solidity — a zero-knowledge VM whose contracts are proven, never re-executed in public.
Built · testing on real nodes
Every order sealed. Only the price comes out.
Your order is encrypted to the current epoch's threshold key and placed with a private spend, so who placed it is hidden unconditionally. At each batch, the bonded validators clear the whole book together on secret shares — no single validator ever sees an order — and open exactly one number: the clearing price. Your fill comes back as a fresh private note only you can open.
- One clearing price per pair per batch — published every batch, traded or not, so even activity stays hidden
- Settlement is proven: no coalition of validators can steal, inflate or misprice; at worst it can delay a batch
- If a batch is late, your order refunds itself as a private note — nobody has to cooperate
A public DEX shows everything. Ion Swap shows a price.
On a public exchange, every trade is a permanent record of who, how much and when; every liquidity position is a public map of where the money sits, ready to be front-run. Ion Swap's DeFi layer may publish only a closed list: the clearing price of each batch, and protocol-wide totals the chain already publishes. Anything else would be treated as a privacy bug.
- No volume, depth, positions, fills or traders — ever
- Nothing links a trade to a payment, a deposit or a withdrawal on the cash layer
- Nothing to front-run: orders are sealed until the batch clears
Smart contracts that can keep a secret.
Dark Solidity (DSOL) is MoneroUSD's smart-contract language and its zero-knowledge virtual machine. On Ethereum, every node re-runs every contract call in public, so every input and balance is visible. In DSOL, your wallet runs the call and produces a zero-knowledge proof that it ran exactly as the contract's code says. Every node checks that proof — in milliseconds — without re-running the contract and without seeing what went in.
- Values are commitments from start to finish — there is no instruction that reveals an amount
- Post-quantum throughout: ML-DSA signatures, ML-KEM notes, SHA-3 and Poseidon2 hashing, WHIR proofs
- A contract can't mint or hold funds: it emits effects, and the chain's own rules decide what moves
Solidity vs Dark Solidity
| Solidity on Ethereum | Dark Solidity on MoneroUSD | |
|---|---|---|
| Who runs a call | Every node re-runs it, in public | Your wallet runs it and proves it; nodes only verify the proof |
| What the chain sees | Every input, balance and transfer | A proof, commitments and a new state root |
| Quantum safety | Elliptic-curve signatures | ML-DSA, ML-KEM, SHA-3, Poseidon2, WHIR |
| Funds in contracts | Contracts hold funds — the source of most drains and re-entrancy hacks | A contract can't hold or mint value; the chain's rules move it |
| Node storage | Grows with every contract and slot | One contract-state root; each call carries the paths it touches |
| Builder income | Off-chain or by convention | A publisher fee set at deploy, enforced by the chain on every call |
Built, and being proven.
- Built: the DSOL zk-VM laws and its prover and verifier; the contract deploy and call doors (two nodes move one state root from the block alone, and forged callers, wrong roots, flipped proofs and replays are refused); sealed orders, threshold clearing and proven settlement; the direct SAT/BTC and SAT/XMR pools.
- Being proven on real nodes: a sealed-batch trade settling end to end is one of the public-testnet checks.
- Next for DSOL: contract-to-contract calls, wider arithmetic and developer tooling.