Ion Swap · the DeFi layer

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

Sealed batches

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
What the chain shows

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
Dark Solidity

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
Side by side

Solidity vs Dark Solidity

Solidity on EthereumDark Solidity on MoneroUSD
Who runs a callEvery node re-runs it, in publicYour wallet runs it and proves it; nodes only verify the proof
What the chain seesEvery input, balance and transferA proof, commitments and a new state root
Quantum safetyElliptic-curve signaturesML-DSA, ML-KEM, SHA-3, Poseidon2, WHIR
Funds in contractsContracts hold funds — the source of most drains and re-entrancy hacksA contract can't hold or mint value; the chain's rules move it
Node storageGrows with every contract and slotOne contract-state root; each call carries the paths it touches
Builder incomeOff-chain or by conventionA publisher fee set at deploy, enforced by the chain on every call
Where it stands

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.
Privacy of the DeFi layer holds against any group controlling less than a third of the validators' bonded weight; liveness needs two thirds online. Soundness never relies on the validators: every batch settles only with a proof the chain verifies.

SAT tokenomics FAQ