Private, Recoverable, and Still Yours: How Bread Wallet Works

Bread is a private wallet on Miden, built for sending, receiving, swapping, and earning yield. Underneath, the account is private by default and stays recoverable without ever handing over control. 

Privacy made simple, complexity tucked away.

The launch article covers how Bread came to be and its place in the broader Miden story. This one is for readers who want to know how Bread works: what “private” means here, how Bread stays secure and recoverable, and how transactions, crosschain moves, and earning work.

Private from other users

On most chains, an account's balance and full history live on a public ledger that anyone can read. Miden works differently: a private account keeps its state (i.e. its balances and its history) on the user's device, and the only things that ever reach the publicly readable chain are the account's address and a commitment to that state. Note: a commitment is a hash of the state, a short cryptographic fingerprint that gives nothing away about its contents.

So from outside, all the chain shows is that "someone" did "something." Who they are, what they did, how much they moved – all these stay private. When you look up an account on a block explorer, you'll see that it exists and that its state has changed, but you won’t see what changed or how.

‍

This is what we mean by private from other users: the people you transact with can see their own transaction, but they cannot inspect the rest of your balance or history. Neither can anyone else watching the chain.

Getting started

When setting up Bread users need to make one real decision: whether to back it up with Guardian, a third-party service that makes privacy practical to use.

A Guardian-backed account, the recommended path, can be recovered on a new device and is protected by more than one key, so a lost or stolen phone isn't the end of the story. At this stage of development, the Guardian operator can see the account state. This allows Guardian to keep the account backup up to date without being able to move funds on its own.

Users can also select a more private account that keeps all personal data on the device and shares nothing with an operator. In return, there's no recovery: lose the device and the account state is gone, along with the funds. As they say, “with great power comes great responsibility.”

‍

Both options are private from other users. The choice is about recovery, and about who else can see the state. For most users, Guardian offers the best balance between privacy and practical recovery.

Staying in control: three keys

A Guardian-backed account spreads control across three keys:

• Everyday key: stored on the device, for regular wallet actions
• Emergency key: recreated from the recovery phrase
• Guardian key: acknowledges state updates

The rule tying them together is simple: every action needs two of the three keys, so no single key can move funds alone. Sending, receiving, and swapping take the everyday key plus Guardian. Replacing a lost device takes the emergency key plus Guardian. Switching Guardian takes the two user keys: everyday key and emergency key. The Guardian key is not used for this operation, which means the user can switch Guardian unilaterally.

‍

Guardian acknowledges state updates but can never act on its own; the owner can walk away from it at any time using their own two keys. For the full picture of why and how Guardian coordinates without ever taking custody, read What is Miden Guardian.

Behind a single transaction

Sending feels simple, abstracting the complexity taking place underneath. 

When the "Send" button is tapped, the everyday key signs the transaction locally, gated by the device's biometrics. The wallet hands the state change to Guardian, which backs it up and acknowledges the update. The device then submits the proven transaction to Miden, and the only thing that lands onchain is a fresh commitment. The balance, the details of the payment, and everything else stay private.

‍

Three parts of the system are involved in every transaction: the device, Guardian, and Miden. Each has a separate job, even though the user performs a single action.

Recovering a lost device

On Miden, because accounts are private by default, recovery is harder to pull off than it sounds. There is no public history to rebuild from: recovering the account requires both its latest state and the keys needed to regain control.

But, because Guardian keeps a backup of the account, a lost phone doesn't have to mean a lost wallet. It works like the backup process on a phone, except it automatically refreshes with every transaction so the saved copy stays up to date.

So when users reinstall Bread on a new device, the recovery phrase rebuilds the emergency key. Together, the emergency key and Guardian unlock the backed-up state and establish a fresh everyday key tied to the new device, effectively restoring the wallet and its state, including its balance. The diagram below traces the full round trip across the device, Guardian, and Miden.

‍

The division of labor is the whole point: Guardian keeps the backup, and the emergency key keeps control.

Moving across chains

Bread moves funds between private accounts on Miden and the chains people already use, all from one place.

Bread can use several routes, depending on the asset and whether it needs to be swapped along the way. The fast route uses a solver, as is typical of intent-based protocols like Epoch or NEAR Intents. The solver briefly holds the funds and delivers the equivalent on the other side. This route is quick and can swap the token in transit. The tradeoff is trusting the solver for those few seconds, and availability being limited to a fixed list of tokens. 

For direct transfers, Bread uses Agglayer as a canonical bridge. These routes transfer the specified asset without using a solver: funds are claimed on arrival, with no swap in transit.

‍

Some crosschain transfers are already possible in the current beta version of Bread: sending to an Ethereum address bridges the assets to Ethereum Sepolia. Crosschain swaps will come later.

Earning, privately

Earning yield will also happen from inside the wallet. Funds will be deposited from Bread, routed across to a lending market on Ethereum where they earn yield, and then returned to Bread upon withdrawal.

There's a real privacy line here, and it's worth stating plainly: the funds will be private on Miden, become visible on Ethereum while they earn, and return to a private account on the way back. Bread will handle the round trip, so it stays smooth for the user.

Earn is not available in the current beta and will come later, when Bread is available on mainnet.

‍

Built on Miden

Bread is a wallet, but it’s also an application built on Miden, and proof that building on Miden is much easier than it used to be. Not long ago, developing an app like this would have required months (if not more) of low-level work. Those foundations now exist: the protocol and cryptography behind the network, a way to write smart contracts entirely in Rust, and a web toolkit that lets browser apps interact directly with Miden.

That groundwork took years and makes Bread possible today. Building an app now mostly means writing Rust and a web frontend in TypeScript; the stack handles the math and low-level mechanics. 

In that sense, Bread is one of the clearest examples of what Miden is for: private accounts that people can actually use. It's also an example of what's now possible, and one of many apps already taking shape in the ecosystem.

Just taste it!

Join the early access list for a chance to use Bread on mainnet when access opens – you can do that from the Bread wallet page.

Guardian-backed recovery, sending, receiving, Miden-native Swap, and crosschain transfers are available in the current beta version. Crosschain swaps and Earn will come later. 

Curious to read more? The launch article tells the story of how Bread was built. For more on the recovery and coordination infrastructure described here, read What is Miden Guardian.

Glossary

Private account

A Miden account whose state is kept offchain rather than being publicly recorded on the network. On Miden, accounts are private by default.

Account state

The private data that represents an account at a given moment, including its assets, balance and activity.

Commitment

A cryptographic fingerprint of the account state. Allows the network to verify that the state has changed without revealing what the state contains.

Hash

A fixed-length value generated from data using a cryptographic function. The same input always produces the same hash, while even a very small change in the input produces a very different output. A hash acts like a fingerprint and is designed to be extremely impractical to reverse back into the original data. Miden uses hashes when creating commitments to private account state.

Block explorer

A tool for viewing the information publicly recorded on a blockchain.

Guardian

A third-party service that backs up private account state and coordinates account updates and recovery actions. At the current stage of development, the operator can see the state of a Guardian-backed account but cannot move its funds on its own.

Key

A value used by cryptographic software to authorize or verify actions. Keys commonly come in related pairs: a private key that must be kept secret and a public key that can be shared. This setup is widely used in internet security and crypto wallets. Bread uses the everyday and emergency keys for wallet actions, while the Guardian key acknowledges state updates.

Seed phrase (aka recovery phrase)

A sequence of words containing the information needed to recreate one or more private keys. In Bread, the recovery phrase recreates the emergency key on a new device. The phrase is the backup used to rebuild the key, rather than the key itself.

Signing

Using a private key to create a cryptographic signature linked to specific data, such as a transaction. It works like a tamper-evident stamp: the corresponding public key can verify that someone controlling the private key signed that exact data. Changing any part of the transaction invalidates the signature, while the private key remains hidden.

Solver

A service that fulfills requests such as moving or swapping assets across chains. In Bread’s faster route, the solver briefly holds the funds while completing the request.

Intent-based protocol

A system where the user specifies the outcome they want and a solver handles the steps needed to complete it. Bread can use intent-based protocols such as Epoch or NEAR Intents for its faster crosschain route.

Bridge

A system for moving assets between blockchains. Bread can use fast solver-based routes through Epoch or NEAR Intents, or Agglayer canonical bridges.