> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/apps-on-rome/privacy-dex/what-is-private.md).

# What is private

What Solana observers, Rome, and Helius can see when you use Privacy DEX.

Your **private balance** holds encrypted records called **notes**, each containing a token and an amount. Privacy DEX encrypts those details. It does not hide the addresses involved in transactions. Your browser decrypts your notes so you can see your balance and activity.

The table describes visibility to someone watching Solana. Information hidden from the chain can still be visible to the services that quote, match, or prove a transaction. Rome's **market maker** offers signed swap terms called **quotes** and supplies the tokens you trade for. Its **matcher** pairs limit orders. Helius's **hosted prover** builds proofs that private transactions are valid.

Vault **shares** are tokens you hold in your private balance and can exchange back for USDC through the vault.

| Action                                  | What an observer sees on chain                                                                                                           | What stays hidden from the chain                                                                      |
| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Set up a private account                | Your wallet address and registered public keys.                                                                                          | Your private keys and private balance.                                                                |
| Add to private balance                  | Your address, the deposited token, and its amount.                                                                                       | The contents of later private notes.                                                                  |
| Swap from the wallet                    | Your address, the payment token and amount, the maker, and the addresses that own the received notes.                                    | The received note's contents, though the pair and public payment let observers estimate them.         |
| Swap from the private balance           | Your address, the maker, and the addresses that own the received notes.                                                                  | Both amounts and the note contents. With one pair, observers can still work out the tokens.           |
| Send privately                          | The sender and recipient addresses.                                                                                                      | The token and amount.                                                                                 |
| Move to wallet or send publicly         | Your address, the destination, token, and withdrawn amount.                                                                              | Your other private notes.                                                                             |
| Put in a vault from the wallet          | Your address, the USDC amount, and that it went into the vault.                                                                          | The share note's contents, but the shares received can be calculated from the public amount and rate. |
| Put in or take out of a vault privately | Your address, the vault, and the addresses that own the received notes.                                                                  | The amounts and whether the trade put money in or took it out.                                        |
| Hold vault shares                       | No transaction as the share rate rises.                                                                                                  | Your share balance and its value, except what earlier public payments allow an observer to infer.     |
| Place an order privately                | Your address, the order address (which links later matches or cancellation to this placement), and that the transaction placed an order. | The token, amount, price, and expiry at placement.                                                    |
| Place an order from the wallet          | Your address, the deposited token and amount, the order address, and that the transaction placed an order.                               | The price and expiry at placement. With one pair, the payment token identifies the token you receive. |
| Cancel an order                         | Your address, the order, and that it still held unfilled funds.                                                                          | The price and remaining note contents, except what paying from the wallet already exposed.            |

## What public payments reveal

An **entry swap** pays from your wallet and makes a public USDC payment. With USDC to SOL as the available market swap pair, an observer can identify the receive token and estimate the amount using the payment and market price. Encryption of the received note does not remove that information.

Sending to someone without a registered private account is a public withdrawal. The app asks for separate confirmation before doing this. Timing and amounts can also link a public deposit to a later withdrawal.

## Order matches

A match reveals both order addresses, both traders, the fee recipient, and both orders' expiry slots. The order addresses link the match back to the original placements.

One order receives a remainder note; the other is visibly completely filled. The remainder can be zero, so observers cannot tell from that note alone whether its order is still open. The amounts and price stay hidden when both orders were funded privately.

If a completely filled order was funded from a wallet, its public payment lets observers work out what the counterparty received, allowing for the fee. If both orders were funded from wallets and both fill completely, their public amounts reveal the price too.

## What Rome learns

Rome records the pair and amounts of each firm quote against your account. The maker knows which funds it reserved for that quote. For a private swap, it also learns which private note pays for the trade. It does not learn your keys or your other private balances from that swap. Rome also sees the tokens and amounts in vault quotes.

Rome's matcher sees every order's token, amount, and price. It chooses matches and sets a price within the signed limits. It cannot cancel your order, and it cannot move your order's funds outside the signed terms without a valid proof. On devnet, Rome generated the proving keys alone, so whoever ran that setup could forge a match and take order funds. A multi-party setup comes before mainnet. You rely on Rome to apply its matching rules and to keep matching available. You also rely on Rome not to trade against your orders using what it sees. On devnet, Rome places no orders of its own.

## What Helius learns

Helius's hosted prover sees the tokens, amounts, and note details supplied to build a transaction proof. Whenever you spend your own private notes, it also receives your nullifier secret, which lets it recognise later spends of your private funds. This includes private swaps, vault put-ins from the private balance, vault take-outs, limit-order placements, sends, withdrawals, and the step that prepares an exact-amount note. A limit order paid from **Wallet** spends private notes in its second step. That secret does not authorize spending; spending your own notes still requires your wallet's signature.

## Keys and trust

This is a test release on **Solana devnet**. **Helius Privacy is in beta**.

Your Solana spending key stays in your wallet. The app derives viewing and nullifier keys in browser memory when you unlock. It stores an encrypted note snapshot and decrypts your balance locally. Rome never holds your keys; the hosted prover receives the secret described above.

A compromised page could obtain your unlock signature and expose your private balance and activity. It could also ask you to sign a harmful transaction. Rome can also upgrade the escrow program. Swaps depend on the maker's proof service even after it has issued a quote.

The [backup](https://docs.rome.builders/apps-on-rome/privacy-dex/swaps.md#unlock-and-back-up) restores private-account keys, but spending still requires access to the original wallet.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/apps-on-rome/privacy-dex/what-is-private.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
