Your guide
to Mist.

How Mist works

Your public wallet sits at the edges. Your private balance lives in the middle, as encrypted notes only your keys can read.

Getting started

Mist uses two wallets. Your private wallet lives in the browser and spends your notes; it's all you need to trade. Your usual wallet only comes in to deposit and to receive withdrawals.

1. Set up your private wallet. Pick a passphrase of at least 12 characters. Mist creates your keys in the browser and encrypts them into a recovery file.
2. Download your recovery file. Keep it somewhere safe and the passphrase somewhere else. Mist asks you to confirm before your first deposit.
3. Connect your wallet to deposit. It's the wallet you deposit from, and the only place withdrawals can go. Trading doesn't need it.
4. Deposit, then trade. Hold the button to confirm. Your browser builds the proof, a solver fills the trade, and the result lands in your private balance.
5. Withdraw when you're done. Mist checks whether the amount or timing would point back to one of your trades before you confirm.

Privacy model

Mist doesn't hide that trades happen. It takes your wallet out of them.

Backups and recovery

Your private balance can only be opened with your recovery file and its passphrase. Nobody can reset them, including us.

Keys unlock per browser tab. Close the tab or lock the wallet from the wallet menu and it locks again.

Deposit screening

New deposits go through a quick admission check before they enter the pool. The pool requires a short-lived signed approval for every deposit, including ones made outside this site.

• Only your public wallet address is checked. Your keys and notes stay on your device.
• Only deposits are checked. Trades, withdrawals, recovery and browsing never are.
• If the check can't approve a deposit, it stops before any funds move. If admission is paused, withdrawals keep working.

Fees

0.5% of each action's output. Depositing, trading and withdrawing each pay it once. The rate is fixed in the pool.

About 1.49% across a full cycle with prices unchanged. Network costs, solver spreads, slippage and token transfer taxes aren't included. Fees round down in the token's smallest unit.

Chains

Connect your Solana or Robinhood Chain wallet from the top of the app. Each chain has its own balances and transaction history.

SolanaNetwork fees in SOLRobinhood ChainNetwork fees in ETH

One private wallet works on every chain: the same passphrase and the same recovery file. Each chain has its own pool, so balances stay separate and nothing moves between chains.

Protocol and security

Questions

Run a solver

A solver listens for quote requests over Nostr, finds a route and signs an offer. When a user accepts, their proof authorizes that exact trade. Your contract settles it atomically with the Mist pool. There is no solver registration or application process.

1. Create an operator directoryThe CLI generates separate operator and Nostr keys in mist-operator/.env, with file permissions set to 0600. It prints the public operator address and refuses to overwrite existing keys.
   Initialize the solverShellCopy

   node packages/solver/src/cli.js init ./mist-operator

2. Configure the RPC and fund the operatorSet RH_RPC_URL in the generated file to your Robinhood Chain endpoint. Send ETH on chain 4663 to the printed operator address for deployment and settlement gas. The health check requires at least 0.0005 ETH; leave additional room for deployment and ongoing transactions. Keep an offline backup of the generated keys.
3. Deploy your settlement contractThe CLI verifies the router’s pinned code, deploys the reference OpenOceanSolver, and records its address in your operator configuration. Its router and operator are immutable. Deploy once for this operator.
   Deploy the solver contractShellCopy

   node packages/solver/src/cli.js deploy-contract ./mist-operator

4. Check the deployment, then start listeningThe read-only doctor checks the RPC, pool, contract ownership, router, routing API, gas balance and relays. Resolve failures before starting the process.
   Check the solverShellCopy

   node packages/solver/src/cli.js doctor ./mist-operator

   Start the solverShellCopy

   node packages/solver/src/cli.js start ./mist-operator

How the solver earns

The reference solver routes through OpenOcean and commits to a buy amount below the route’s expected output. After paying that amount into the pool, the settlement contract sends surplus tokens to the operator. Gas, failed transactions and price movement reduce the margin. Mist’s 0.5% protocol fee is deducted from the output credited to the user.

Your quote cannot change the user’s proved terms or redirect a withdrawal. If the route cannot pay the promised output, settlement reverts.

Configure and operate

Each command reads the operator directory’s .env. Process environment variables take precedence. Keep the generated contract setting intact; the deployment command fills it in for you.

# Optional settings in mist-operator/.env
SOLVER_SLIPPAGE_BPS=100
SOLVER_QUOTE_SAFETY_BPS=25
SOLVER_MAX_GAS_PRICE_WEI=1000000000
SOLVER_CONFIRMATIONS=2
SOLVER_STATE_PATH=solver-data/quotes.json

100 basis points is 1%. The reference defaults use 1% routing slippage and an additional 0.25% quote buffer. The gas cap above is 1 gwei. These are configurable limits, not guaranteed earnings.

Read the event stream

The process writes JSON logs to standard output. Track completed settlements, relay errors and the operator’s ETH balance.

Use the SDK

Initialize your SDK client with the Robinhood network configuration and a viem wallet client carrying the account that owns the notes. The examples accept that initialized client as mist. Use a dedicated RPC for sustained scanning and keep wallet signing credentials out of browser bundles.

1. Back up before depositing

For a new private wallet, create keys and save the encrypted recovery file before moving funds. Use a passphrase of at least 12 characters and store it separately. For an existing wallet, restore its backup instead of creating new keys.

import { writeFile } from "node:fs/promises";

// For a new private wallet. Pass your initialized SDK client.
export async function createPrivateWallet(mist, passphrase) {
  await mist.keys.create();
  const backup = await mist.keys.backup(passphrase);
  await writeFile("mist-recovery.json", backup, {
    flag: "wx",     // never overwrite an existing backup
    mode: 0o600,
  });
}

2. Deposit, request an offer and trade

Deposits check asset policy and obtain a screening approval before submission. After the deposit, sync to discover the new note. Set a minimum buy amount for your trade; offers are sorted by output, and an empty result means no solver answered. The example below deposits 5 USDG and trades 1 USDG.

// minimumBuy is a gross minimum in the buy token's base units.
export async function depositAndTrade(mist, minimumBuy) {
  const { USDG, WETH } = mist.network.assets;

  // 5 USDG. The deposit credits 4.975 USDG after the fee.
  await mist.deposit({ asset: USDG, amount: 5_000_000n });
  await mist.sync();

  const [best] = await mist.quote({
    sell: USDG,
    buy: WETH,
    amount: 1_000_000n,  // trade 1 USDG of the private balance
    minimumBuy,
  });
  if (!best) throw new Error("No solver quote received");

  // best.netBuyAmount is the amount after the protocol fee.
  const receipt = await mist.trade(best);
  await mist.sync();
  return receipt;
}

These calls submit real transactions. Display netBuyAmount when showing what the user receives. Use each offer once, request a new one after a trade attempt, and sync after settlement before reading balances.

3. Restore and withdraw

Restore with the same recovery file, passphrase and owning wallet, then sync. Withdrawals return to that wallet; there is no arbitrary recipient parameter. Close the client with mist.close() when your integration shuts down.

import { readFile } from "node:fs/promises";

export async function restorePrivateWallet(mist, passphrase) {
  const backup = await readFile("mist-recovery.json", "utf8");
  await mist.keys.restore(backup, passphrase);
  await mist.sync();
  return mist.balances();
}

export async function withdraw(mist, asset, amount) {
  const receipt = await mist.withdraw({ asset, amount });
  await mist.sync();
  return receipt; // includes receivedAmount after the fee
}

Methods and failure handling

Understand an offer

buyAmount is the gross payment to the pool; netBuyAmount is the private note’s value after the fee. executor identifies the settlement contract. deadline is a Unix timestamp in seconds. Route estimates such as expectedBuyAmount and impactBps are informational.

Handle failures explicitly