Public testnet

Join the testnet. Try real private payments.

MoneroUSD is live on a public testnet. Get free test coins, send private payments, bridge test BTC and XMR, try the wallet, run a node. No real money. No risk.

Chain specifications

What you're running on. The numbers.

The testnet runs byte-for-byte production code. These are its specs; every block's real time is on the explorer, read from the chain.

~5 s measured Block time measured on two real nodes (11.4–11.6 blocks a minute, Nov 17, 2026). Today's target: 1,953 ms, derived from relay constants. Goal: 500 ms.
32 parallel DAG width — blocks produced in parallel, ordered by GHOSTDAG
≤ 1.8 MB constant Recursive proof size — one proof covers the whole chain
O(1) always Node state — constant size regardless of chain height or note count

Cryptography — post-quantum, no elliptic curves

Every primitive resists quantum computers. There is nothing to harvest now and break later.

ML-KEM-768 ML-DSA-65 BLAKE3 SHA-3 / Keccak Poseidon2 WHIR
Node requirements

One kind of node. Runs on anything.

There are no tiers on MoneroUSD. Every node mines, verifies, proves and relays. A phone can run a full node.

Minimum hardware

CPU: Any 64-bit processor (x86-64 or ARM64). Mining hardware is proving hardware — no ASICs, no GPUs.

RAM: Under 512 MB. Node state is constant — the chain never grows your memory use.

Disk: Under 10 GB including the binary, Tor and data. No blockchain history to store.

Network

Transport: All traffic runs over Tor v3 onion services. The node bundles Tor — no setup needed.

Bandwidth: every payment carries its own proofs, so throughput is bounded by the relay's bandwidth, not by the block cap.

Ports: No inbound ports required. The node reaches the network over Tor.

Software

OS: macOS (Apple Silicon), Windows (64-bit), Linux (x86-64 or ARM64).

Dependencies: None. The binary is self-contained and includes its own Tor client.

Sync: A new node checks one recursive proof and joins at the tip — no history replay.

What the testnet offers

The full ecosystem. Test value only.

Every feature runs on the testnet with the production code, byte-for-byte. The only difference: test coins instead of real money.

Private payments

Send and receive USDm with zero-knowledge proofs. Hidden amounts, senders, receivers and metadata. Post-quantum from the first byte.

Test faucet

Free test USDm on demand. One tap in the wallet or one CLI command. Built into the node and gated by the genesis — cannot mint on mainnet.

Test bridge

Bridge test BTC (testnet4) and test XMR (Monero testnet) through the real custody code. Native assets, no wrapping.

No risk

Test coins have zero value. The faucet is gated by the chain's own genesis identity: it cannot create real money, however you launch the node.

Usernames & Letter

Register a private username. Send encrypted messages with Letter. Try the full name system and private messaging layer.

Tap-to-pay

Point-of-sale payments over Bluetooth LE. Set up a merchant terminal, scan a code, tap your phone. The same UX as a contactless card.

Test coins only — no real funds at risk

  • The testnet faucet prints free USDm on demand. These coins have zero real-world value.
  • The bridge connects to Bitcoin testnet4 and Monero testnet — test BTC and test XMR only. More assets are planned.
  • The faucet is gated by the chain's own genesis identity: it is physically impossible for it to run on a mainnet chain.
  • The testnet may be reset at any time as the protocol evolves. Test balances do not survive a reset.
  • The production code is byte-for-byte identical — only the network identity differs. Every bug found here is a bug fixed before real money.
Get started

Three steps. Under five minutes.

Download the wallet

The MoneroUSD wallet runs the node for you. Download it, open it, and it connects to the testnet automatically.

One-time step on a Mac. The app is not notarized by Apple yet, so macOS blocks it until you allow it once:

  1. Open the downloaded MoneroUSD-Wallet-macOS-testnet.dmg and drag MoneroUSD Wallet onto Applications.
  2. Open Terminal: press ⌘ Space, type Terminal, press Return.
  3. Tap Copy on the command below, click into the Terminal window, paste with ⌘ V and press Return. Nothing is printed when it works.
xattr -dr com.apple.quarantine "/Applications/MoneroUSD Wallet.app"

Then open MoneroUSD Wallet from Applications.

On Windows. The installer is not code-signed yet, so Windows may show Windows protected your PC. Click More info, then Run anyway, and follow the installer. Then open MoneroUSD Wallet from the Start menu. Prefer an MSI? It is on the release page.

On Linux (x86-64). Debian or Ubuntu: install the .deb with the command below, then open MoneroUSD Wallet from your applications. Any other distribution: download the AppImage, make it runnable with chmod +x ~/Downloads/MoneroUSD-Wallet-Linux-testnet-x86_64.AppImage and open it.

sudo apt install ~/Downloads/MoneroUSD-Wallet-Linux-testnet-amd64.deb

Get test coins

Open the wallet and tap Get free test USDm on the home screen. The test USDm lands with the next block. The same tap is under Browser → Testnet Tap. You can also receive test BTC or test XMR through the bridge.

Send a payment

Tap Send, enter any testnet address or username, pick an amount. A zero-knowledge proof is generated on your device, broadcast to the network, and settled in seconds. Nobody — not even the nodes — can see the amount or the parties.

Build and start the node

The node builds from source with Rust (rustup, stable). It reaches the network only over Tor onion addresses with the Tor client it carries; there is nothing else to install.

# Clone and build git clone https://github.com/casdevmonero/monerousd.git cd monerousd/monerousd-node-zkdag cargo build --release --bin usdmd-node # Start the node on the testnet (RPC on 127.0.0.1:27780) MONEROUSD_NET=testnet MONEROUSD_RPC_PORT=27780 \ ./target/release/usdmd-node serve

The desktop wallet already carries this node inside it; build it yourself only to run a node without the wallet.

Get test coins

Hit the faucet on your own node's RPC. The address is your wallet's receive address.

# Request test USDm from the built-in faucet curl -X POST http://127.0.0.1:27780/faucet/drip \ -H 'Content-Type: application/json' \ -d '{"amount": 100, "to": "YOUR_ADDRESS"}'

Run a validator

Bond test SAT to validate. The node derives its validator key from its own seed — no setup, no passwords.

# Start a validator (bonds SAT from a mined reward or the faucet) MONEROUSD_NET=testnet MONEROUSD_RPC_PORT=27780 MONEROUSD_VALIDATOR_BOND=1 \ ./target/release/usdmd-node serve
What to expect

This is the production code

The testnet runs the exact same binary as mainnet — every consensus rule, every privacy guarantee, every hard fork activated at height 1. The only variable that changes is the network identity.

Resets happen

As the protocol evolves, consensus changes require a fresh genesis. Your test balances start over. The faucet pays again immediately.

Bugs found here are bugs fixed

Every defect found on the testnet is fixed before real money touches the chain. Found something? Tell us on Telegram.

Testnet documentation

Everything you need to know

How the testnet works

The testnet runs byte-for-byte identical code to the future mainnet. The only difference is the network identity in the genesis block, which gates the faucet and separates test coins from real value. All consensus rules, all privacy guarantees, all hard forks are active from height 1.

Blocks are produced by a GHOSTDAG block-DAG with K=32, meaning up to 32 blocks can be produced in parallel and ordered deterministically. Measured on two real nodes, a block lands about every 5 seconds (11.4–11.6 blocks a minute, Nov 17, 2026); today's target is 1,953 ms, derived from what the relay can carry, and the goal is 500 ms. Every transaction is a zero-knowledge proof: amounts, senders, receivers and all metadata are hidden from every observer, including the nodes themselves.

Running a node

Requirements: Any 64-bit machine (macOS Apple Silicon, Windows 64-bit, Linux x86-64/ARM64). 2 GB RAM, 1 GB disk. Any internet connection — the node reaches the network over Tor v3 onion services and requires no open ports or public IP address.

What the node does: Every MoneroUSD node mines, verifies, proves and relays. There are no tiers — a validator is the same node with a SAT bond. A new node joins at the tip by checking one recursive proof of the entire chain (no block-by-block sync, no downloading history). Node state stays a constant size as the chain grows.

Measured footprint: 0.9 GB memory, 290 MB disk; the macOS release binary is 45 MB (testnet-v0.2.0). The binary is self-contained and includes its own Tor client.

Building from source: Requires a recent stable Rust toolchain.

# Clone the repository git clone https://github.com/casdevmonero/monerousd.git cd monerousd/monerousd-node-zkdag # Build the node (first build compiles the prover — takes a while) cargo build --release --bin usdmd-node # Start the node on the testnet MONEROUSD_NET=testnet MONEROUSD_RPC_PORT=27780 \ ./target/release/usdmd-node serve

Using the wallet

The wallet bundles a full node inside it. Download it, open it, and it connects to the testnet automatically — there is nothing else to set up. The wallet is built with Tauri (Rust core, web front end) and runs on macOS (Apple Silicon), Windows (64-bit) and Linux (x86-64).

Download: macOS wallet (testnet-v0.2.0) — open it and drag the app into Applications; verify the SHA256 checksum from the release page.

macOS quarantine: The build is not yet notarized by Apple, so macOS blocks it until you allow it once. After dragging the app into Applications, open Terminal (press ⌘ Space, type Terminal, press Return), paste this command with ⌘ V and press Return:

xattr -dr com.apple.quarantine "/Applications/MoneroUSD Wallet.app"

Getting test coins: Open the wallet and tap Get free test USDm on the home screen; it lands with the next block.

The bridge (BTC and XMR)

The testnet bridge connects to Bitcoin testnet4 and Monero testnet. It uses the same threshold-signed custody code (PQ-FROST) that mainnet will use. Assets are native — no wrapping, no IOUs. You deposit test BTC or test XMR and receive USDm on the MoneroUSD chain; withdraw to get them back.

More bridged assets (ETH, SOL, ZEC) are planned for future releases.

Cryptography

Every cryptographic primitive is post-quantum. There are no elliptic curves anywhere in the protocol — no ECDSA, no secp256k1, no Ed25519, no RSA.

  • ML-KEM-768 — key encapsulation (quantum-resistant key exchange)
  • ML-DSA-65 — digital signatures (quantum-resistant signing)
  • BLAKE3 — fast hashing
  • SHA-3 / Keccak — domain separation
  • Poseidon2 — arithmetic-friendly hashing inside ZK circuits
  • WHIR — recursive zero-knowledge proofs (the light decider)

What to expect

  • Resets: Consensus changes require a fresh genesis. Test balances start over. The faucet pays again immediately.
  • Block time: Measured about 5 s on two real nodes (11.4–11.6 blocks a minute, Nov 17, 2026). The target today is 1,953 ms and the goal is 500 ms; a machine under heavy load measures slower.
  • Throughput: bounded by the relay's bandwidth, not by a block cap: every payment carries its own zero-knowledge proofs.
  • Privacy: All privacy guarantees are active. Viewing the chain reveals nothing — not amounts, not parties, not transaction counts, not timing patterns.
  • Bugs: This is pre-launch software. Bugs found here are bugs fixed before real money touches the chain. Report issues on Telegram or GitHub Issues.

Source code

The full source is open: github.com/casdevmonero/monerousd. Licensed Apache 2.0 (IonSwap front end is BSL until 2029-12-01). Contributions welcome.

Community

Questions? Join the conversation.

Report bugs, ask questions, follow development. The community decides the direction.