Running Your Own Mostro Node

Mostro v0.16.3 — Community Guide · February 2026

1. What is Mostro and Why Should Your Community Run One?

Mostro is a peer-to-peer Bitcoin exchange that lets people buy and sell Bitcoin using local currencies (dollars, euros, pesos — any currency) without needing to provide identity documents (KYC). Think of it as a decentralized marketplace where buyers and sellers can trade directly.

It works using two technologies:

• Lightning Network — a fast, low-cost Bitcoin payment layer (think of it as Bitcoin's express lane for small, quick payments)
• Nostr — a censorship-resistant communication protocol (think of it as a messaging system that nobody can shut down)

Mostro acts as an escrow coordinator — it holds the seller's Bitcoin in a temporary "lock box" (called a hold invoice) until the buyer confirms they've sent the local currency payment. Mostro never actually controls anyone's funds; it just holds them briefly during the trade.

Why Would Your Community Want to Run a Mostro Node?

1. Fee income — Every trade earns you a fee (0.6% by default). If your community does $10,000 in monthly trades, that's ~$60/month in fees.
2. P2P trading without KYC — Your community members can buy and sell Bitcoin without providing identity documents. Especially important in regions with unstable currencies or restrictive regulations.
3. Disputes in your language — When a trade goes wrong, your community resolves it, in your language, understanding your local payment methods.
4. Independence — No company can shut down your exchange. No government can pressure a single operator to close it.
5. Customization — You choose which currencies to support, what payment methods to allow, and what fees to charge.

How Mostro Works (Simplified)

If something goes wrong (e.g., Bob says he paid but Alice didn't receive it), either party can open a dispute, and your community's assigned arbiters investigate and resolve it.

2. Prerequisites — What You Need Before Starting

2.1 A Server (VPS)

A VPS (Virtual Private Server) is a computer in a data center that runs 24/7. You'll rent one to host your Mostro node.

Minimum specs:

Estimated monthly cost: $10–$24/month.

Popular VPS providers:

• Hostinger — from ~$7/month (promotional price; renewal may be higher) (KVM 2: 2 vCPU, 8GB RAM, 100GB NVMe, 8TB bandwidth) · Accepts Bitcoin
• Hetzner — €3.49-8/month (CX23 from €3.49, good value, EU-based)
• Digital Ocean — $24/month (4GB RAM, 2 CPUs, 80GB SSD) or $32/month (4GB RAM, 2 Intel CPUs, 120GB NVMe)
• OVH — ~$6-12/month
• Linode/Akamai — $12/month
• Lunanode — Accepts Bitcoin payments

You need to be comfortable connecting to a server via SSH. If you've never done it, search for a tutorial on "Connect to a VPS via SSH" — it's simpler than it sounds.

2.2 A Lightning Network Node (LND)

Lightning Network is a "layer 2" system built on top of Bitcoin that enables fast, cheap payments. To run Mostro, you need an LND node (Lightning Network Daemon) — the specific Lightning software that Mostro works with.

Your options:

What you need from your LND node:

• The tls.cert file (a security certificate)
• The admin.macaroon file (an authentication token)
• The gRPC address (typically https://127.0.0.1:10009 if on the same machine)

2.3 Lightning Liquidity

To facilitate trades, your Lightning node needs channels with Bitcoin in them. Think of Lightning channels as pre-funded payment tunnels. The Bitcoin inside these channels is your "liquidity".

How much do you need?

Start small, grow incrementally. Begin with enough for your community's initial needs and monitor feedback. When traders report orders failing due to insufficient capacity, that's your signal to add more. Listen to your community.

Getting liquidity:

• Open channels to well-connected nodes (use Lightning Network+ or Amboss to find good peers)
• You need outbound capacity (to pay buyers) and inbound capacity (to receive from sellers)
• Getting inbound liquidity is usually harder — consider Lightning Loop, Magma, or channel swap services

2.4 Nostr Keys

Your Mostro node needs its own identity on the Nostr network — a cryptographic key pair with a public key (your node's address) and a private key (your secret).

Generating secure Nostr keys locally with rana:

# Install Rust (if not already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Install rana - local Nostr key generator
cargo install rana

# Generate a new key pair (with 12-word seed phrase)
rana --generate 12

Rana will generate your private key (nsec), public key (npub), and a backup seed phrase. Keep everything safe! Note: running rana without arguments starts PoW mining (difficulty 10) which can take minutes — use --generate for instant generation. Never generate important keys using online services.

2.5 Technical Skill Level

💡 Our recommendation: If your community has someone comfortable with the Linux command line, they can handle the Docker installation. Native compilation requires system administration experience. Lightning node setup is the most complex part — consider asking someone experienced for help, or using a node-in-a-box solution.

3. Step-by-Step Setup

All installation options share the same first steps. Then choose your preferred option:

• Option A (Docker Hub): Fastest. No compiling, no cloning. Recommended for most.
• Option B (Docker Build): Build the image locally from the repository.
• Option C (Native Build): More control, better for experienced sysadmins.

All assume you already have: ✅ A VPS with Ubuntu · ✅ SSH access · ✅ A working LND node.

Common Steps (for all 3 options)

Step 1: Connect to your VPS

ssh root@YOUR_VPS_IP_ADDRESS

Step 2: Update the system

# Download the latest package information
apt update

# Install all available updates
apt upgrade -y

Step 3: Install Docker and Docker Compose

# Install Docker using the official script
curl -fsSL https://get.docker.com | sh

# Verify Docker is installed
docker --version

# Verify Docker Compose
docker compose version

Step 4: Install additional tools

apt install -y git make

✅ Common steps completed. Now choose your installation option:

Option A: Docker Hub (Fastest — Recommended)

Run Mostro directly from Docker Hub without cloning the repository or compiling. Perfect for VPS deployments.

Step 5: Create configuration directory

mkdir -p ~/mostro-config/lnd

Step 6: Get the configuration template

curl -sL https://raw.githubusercontent.com/MostroP2P/mostro/v0.16.3/settings.tpl.toml \
  -o ~/mostro-config/settings.toml

Step 7: Copy LND credentials

cp /path/to/your/tls.cert ~/mostro-config/lnd/tls.cert
cp /path/to/your/admin.macaroon ~/mostro-config/lnd/admin.macaroon

If LND is on the same machine, typical paths are:

• /root/.lnd/tls.cert
• /root/.lnd/data/chain/bitcoin/mainnet/admin.macaroon

Step 8: Edit the configuration

nano ~/mostro-config/settings.toml

Required changes:

[lightning]
lnd_cert_file = '/config/lnd/tls.cert'
lnd_macaroon_file = '/config/lnd/admin.macaroon'
lnd_grpc_host = 'https://host.docker.internal:10009'  # If LND on same VPS
# Or use 'https://YOUR_LND_IP:10009' if LND on different server

[database]
url = "sqlite:///config/mostro.db"

[nostr]
nsec_privkey = 'YOUR_NSEC_KEY_HERE'
relays = ['wss://relay.mostro.network', 'wss://nos.lol']

[mostro]
fee = 0.006                    # 0.6% fee per trade
max_order_amount = 1000000     # Maximum order in sats
min_payment_amount = 100       # Minimum order in sats
fiat_currencies_accepted = ['USD', 'EUR']  # Your currencies

Save: Ctrl+X, then Y, then Enter.

Step 9: Fix permissions

sudo chown -R 1000:1000 ~/mostro-config
chmod 700 ~/mostro-config
chmod 600 ~/mostro-config/settings.toml
chmod 600 ~/mostro-config/lnd/admin.macaroon

Step 10: Run the container

If LND is on the same VPS:

docker run -d --name mostro \
  --restart unless-stopped \
  --add-host=host.docker.internal:host-gateway \
  -v ~/mostro-config:/config \
  mostrop2p/mostro:v0.16.3

If LND is on a different server:

docker run -d --name mostro \
  --restart unless-stopped \
  -v ~/mostro-config:/config \
  mostrop2p/mostro:v0.16.3

Step 11: Check the logs

docker logs -f mostro

Look for these messages:

• Settings correctly loaded — Configuration is valid
• Connected to LND — Lightning connection successful
• Connected to relay — Nostr relay established

🎉 Congratulations! If you see successful connections in the logs, your Mostro node is running!

Updating (Docker Hub)

export MOSTRO_TAG=v0.16.3
docker pull mostrop2p/mostro:$MOSTRO_TAG
docker stop mostro
docker rm mostro
docker run -d --name mostro \
  --restart unless-stopped \
  --add-host=host.docker.internal:host-gateway \
  -v ~/mostro-config:/config \
  mostrop2p/mostro:$MOSTRO_TAG

Option B: Docker Build (Build image locally)

Step 5: Download Mostro

cd /opt
git clone https://github.com/MostroP2P/mostro.git
cd mostro

Step 6: Set up configuration files

cd docker
mkdir -p config
cp ../settings.tpl.toml config/settings.toml

Step 7: Edit the configuration file

nano config/settings.toml

Edit the same settings as Option A, Step 8.

Step 8: Build the Docker image

cd ..
LND_CERT_FILE=/root/.lnd/tls.cert \
LND_MACAROON_FILE=/root/.lnd/data/chain/bitcoin/mainnet/admin.macaroon \
make docker-build

Step 9: Start Mostro

make docker-up

# Check status
docker compose -f docker/compose.yml ps

# View logs
docker compose -f docker/compose.yml logs -f mostro

🎉 Congratulations! If you see successful connections, your Mostro node is running!

Option C: Native Build (For Technical Operators)

Step 5: Install Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source /root/.cargo/env
rustc --version
cargo --version

Step 6: Install build dependencies

apt install -y cmake build-essential libsqlite3-dev libssl-dev \
  pkg-config git sqlite3 protobuf-compiler

Step 7: Download and compile Mostro

cd /opt
git clone https://github.com/MostroP2P/mostro.git
cd mostro
cargo build --release

fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

Steps 8–10: Install, initialize, and clean

install target/release/mostrod /usr/local/bin
cargo install sqlx-cli --version 0.6.3
./init_db.sh
cargo clean  # Saves 2+ GB of space

Steps 11–12: Create user and configure

adduser --disabled-login mostro
mkdir -p /opt/mostro
cp settings.tpl.toml /opt/mostro/settings.toml
nano /opt/mostro/settings.toml

Edit the same settings as Option A, Step 8.

Steps 13–15: Test, permissions, and systemd service

# Test run
/usr/local/bin/mostrod -d /opt/mostro

# Set permissions
chown -R mostro:mostro /opt/mostro

Create the systemd service:

# /etc/systemd/system/mostro.service
[Unit]
Description=Mostro daemon
After=network.target

[Service]
Type=simple
User=mostro
WorkingDirectory=/home/mostro
Environment=RUST_LOG=info
ExecStart=/usr/local/bin/mostrod -d /opt/mostro
Restart=on-failure

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable mostro.service
systemctl start mostro.service
systemctl status mostro.service

🎉 Congratulations! Your Mostro node is running as a system service.

4. Configuration In Depth

The settings.toml file controls everything about your Mostro node.

4.1 Nostr Keys — Your Node's Identity

[nostr]
nsec_privkey = 'YOUR_NSEC_KEY'
relays = [
  'wss://relay.mostro.network',
  'wss://nos.lol',
  'wss://relay.nostr.band'
]

Which relays to use?

• wss://relay.mostro.network — Mostro's own relay, recommended
• wss://nos.lol — Reliable and well-connected relay
• Add 3–5 relays for reliability. More relays = better availability but more bandwidth.

4.2 Fees — How You Earn Revenue

[mostro]
fee = 0.006
dev_fee_percentage = 0.30

Trading fee (fee): Percentage charged per trade, split between buyer and seller.

• 0.006 = 0.6% (each party pays 0.3%)
• 0.01 = 1.0% (each party pays 0.5%)
• 0 = free (good for growing your user base)

Example: On a 100,000 sat trade with fee = 0.006: The buyer pays 300 sats, the seller pays 300 sats, your node earns 600 sats total.

Development fee (dev_fee_percentage): A percentage of your fee earnings that goes to Mostro development.

• 0.30 = 30% (default) — out of 600 sats, 180 go to the development fund
• Minimum: 10% (0.10), Maximum: 100% (1.0)
• Paid by your node from its earnings, not charged to users
• All payments publicly auditable via Nostr events (kind 8383)

4.3 Order Limits and Currencies

[mostro]
max_order_amount = 1000000
min_payment_amount = 100
fiat_currencies_accepted = ['USD', 'EUR', 'ARS', 'CUP']

• max_order_amount: Largest trade in satoshis. Set based on your Lightning channel capacity.
• min_payment_amount: Minimum trade in satoshis. 1,000 or 10,000 is more practical than 100.
• fiat_currencies_accepted: Use ISO 4217 codes. Empty array [] accepts all currencies.

4.4 Node Profile (Optional but Recommended)

[mostro]
name = "LatAm Mostro"
about = "P2P Bitcoin exchange for Latin America. Spanish support."
picture = "https://example.com/your-logo.png"
website = "https://your-community-site.com"

These set your Mostro's profile on Nostr (NIP-01 kind 0 metadata). Clients display this information so users know which Mostro they're trading on.

4.5 Timing and Expiration

[mostro]
expiration_hours = 24        # How long an order stays open
expiration_seconds = 900     # Time to complete (15 min)
hold_invoice_expiration_window = 300  # Hold invoice validity (5 min)

4.6 Anti-Spam

[mostro]
pow = 0  # 0 = disabled; 10-20 = moderate. Start with 0.

4.7 RPC Admin Interface (Optional)

[rpc]
enabled = false
listen_address = "127.0.0.1"
port = 50051

Enable this for admin tools like MostriX (terminal interface) for dispute resolution.

5. Operating Your Mostro Node

5.1 How Disputes Work

Disputes are your most important operational responsibility.

When do disputes happen?

• The buyer says they paid, the seller says they didn't receive it
• The seller refuses to release Bitcoin after receiving payment
• Either party becomes unresponsive

The dispute process:

1. User opens a dispute — Either party clicks "Dispute" in their client
2. Mostro flags the order — Status changes to "Dispute", funds remain locked
3. Arbiter takes the case — An admin assigned to your node investigates
4. Investigation — Communicates with both parties, requests evidence
5. Resolution — Arbiter decides: release to buyer, or refund to seller

5.2 Mostrix — Your Admin Tool

Mostrix is a terminal-based (TUI) client for dispute resolution. If you run a Mostro node, you need Mostrix.

Option A: Download Pre-built Binary (Recommended)

Download the latest release for your platform from GitHub Releases:

# Linux (x86_64)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-x86_64-unknown-linux-musl
chmod +x mostrix-x86_64-unknown-linux-musl
./mostrix-x86_64-unknown-linux-musl

# Linux (ARM64 / Raspberry Pi 4)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-aarch64-unknown-linux-musl
chmod +x mostrix-aarch64-unknown-linux-musl
./mostrix-aarch64-unknown-linux-musl

# Windows
# Download mostrix-x86_64-pc-windows-gnu.exe from the releases page

# Import developer keys (one-time)
curl https://raw.githubusercontent.com/MostroP2P/mostrix/main/keys/negrunch.asc | gpg --import
curl https://raw.githubusercontent.com/MostroP2P/mostrix/main/keys/arkanoider.asc | gpg --import

# Download manifest and signatures
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt.sig.negrunch
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt.sig.arkanoider

# Verify signatures
gpg --verify manifest.txt.sig.negrunch manifest.txt
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Verify checksum matches
shasum -a 256 mostrix-x86_64-unknown-linux-musl
# Compare output with the hash in manifest.txt

Option B: Build from Source

If you prefer to compile from source or need a platform not in the releases:

# Install dependencies (Ubuntu/Debian)
sudo apt install -y cmake build-essential pkg-config

# Install Rust (if not already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Clone and build
git clone https://github.com/MostroP2P/mostrix.git
cd mostrix
cargo build --release

# Run
./target/release/mostrix

First Run & Configuration

On first run, Mostrix automatically generates a ~/.mostrix/settings.toml with sensible defaults including a fresh Nostr keypair. Your generated npub will be printed to the terminal.

# Edit the config
nano ~/.mostrix/settings.toml

# Change this line to YOUR Mostro node's pubkey:
mostro_pubkey = "YOUR_MOSTRO_PUBKEY_HEX"

For admin mode (dispute resolution), also configure:

# ~/.mostrix/settings.toml
mostro_pubkey = "YOUR_MOSTRO_PUBKEY_HEX"
nsec_privkey = "nsec1your_personal_key"      # Auto-generated on first run
admin_privkey = "nsec1your_admin_key"        # Your admin key from Mostro config
relays = ["wss://relay.mostro.network"]
currencies_filter = []                        # Empty = show all currencies
user_mode = "admin"                           # Enable admin mode

5.3 mostro-watchdog — Dispute Notifications on Telegram

mostro-watchdog monitors your Mostro node for disputes and sends instant alerts via Telegram. Essential for fast response times.

Option A: Automatic Installation (Recommended)

# Download and run the installation script
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash

Option B: Manual Binary Download

# Linux x86_64 (Intel/AMD)
curl -LO https://github.com/MostroP2P/mostro-watchdog/releases/latest/download/mostro-watchdog-linux-x86_64
chmod +x mostro-watchdog-linux-x86_64
sudo mv mostro-watchdog-linux-x86_64 /usr/local/bin/mostro-watchdog

# Linux ARM64 (Raspberry Pi, ARM servers)
curl -LO https://github.com/MostroP2P/mostro-watchdog/releases/latest/download/mostro-watchdog-linux-aarch64
chmod +x mostro-watchdog-linux-aarch64
sudo mv mostro-watchdog-linux-aarch64 /usr/local/bin/mostro-watchdog

Option C: Build from Source

git clone https://github.com/MostroP2P/mostro-watchdog.git
cd mostro-watchdog
cargo build --release
sudo cp target/release/mostro-watchdog /usr/local/bin/

Configuration:

cp config.example.toml config.toml
nano config.toml

[mostro]
pubkey = "YOUR_MOSTRO_PUBKEY"

[nostr]
relays = ["wss://relay.mostro.network", "wss://nos.lol"]

[telegram]
bot_token = "YOUR_BOT_TOKEN"
chat_id = "YOUR_CHAT_ID"

5.4 Uptime Monitoring

Your node needs to be running 24/7.

# Native
systemctl status mostro.service
journalctl -u mostro -f
journalctl -u mostro | grep -E "(error|warn|connected)" --ignore-case

# Docker Hub (Option A)
docker ps --filter name=mostro
docker logs -f mostro

# Docker Build (Option B)
docker compose -f /opt/mostro/docker/compose.yml ps
docker compose -f /opt/mostro/docker/compose.yml logs -f mostro

5.5 Updating Mostro

Docker Hub:

export MOSTRO_TAG=v0.16.3
docker stop mostro
docker rm mostro
docker pull mostrop2p/mostro:$MOSTRO_TAG
docker run -d --name mostro \
  --restart unless-stopped \
  --add-host=host.docker.internal:host-gateway \
  -v ~/mostro-config:/config \
  mostrop2p/mostro:$MOSTRO_TAG

Docker Build:

cd /opt/mostro
git pull origin main
make docker-build
make docker-down
make docker-up

Native:

cd /opt/mostro
git pull origin main
cargo build --release
install target/release/mostrod /usr/local/bin
cargo clean
cargo install sqlx-cli --version 0.6.3
sqlx migrate run
systemctl restart mostro.service

5.6 Backups

Critical files to back up: settings.toml (contains your private Nostr key!) and mostro.db (order history, reputation).

# Manual backup — Docker Hub:
mkdir -p /root/mostro-backups
cp ~/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp ~/mostro-config/mostro.db /root/mostro-backups/mostro.db.$(date +%Y%m%d)

# Manual backup — Native:
cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp /opt/mostro/mostro.db /root/mostro-backups/mostro.db.$(date +%Y%m%d)

Automated daily backup (add to crontab with crontab -e):

# Docker Hub (Option A):
0 3 * * * mkdir -p /root/mostro-backups && cp ~/mostro-config/mostro.db /root/mostro-backups/mostro.db.$(date +\%Y\%m\%d) && cp ~/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d)

# Native (Option C) / Docker Build (Option B):
0 3 * * * mkdir -p /root/mostro-backups && cp /opt/mostro/mostro.db /root/mostro-backups/mostro.db.$(date +\%Y\%m\%d) && cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d)

5.7 Reviewing Trade Activity

# Count all orders
sqlite3 /path/to/mostro.db "SELECT COUNT(*) FROM orders;"

# Recent successful trades
sqlite3 /path/to/mostro.db "SELECT id, fiat_code, fiat_amount, amount, fee, status, created_at FROM orders WHERE status = 'success' ORDER BY created_at DESC LIMIT 10;"

# Pending orders
sqlite3 /path/to/mostro.db "SELECT id, fiat_code, fiat_amount, status, created_at FROM orders WHERE status = 'pending';"

# Total fee revenue (node fee + dev_fee)
sqlite3 /path/to/mostro.db "SELECT SUM(fee) as node_fees, SUM(dev_fee) as dev_fees, SUM(fee + dev_fee) as total_fees_sats FROM orders WHERE status = 'success';"

6. Cost Breakdown

Monthly Operating Costs

One-time / Capital Costs

Revenue Potential

Time Commitment

7. Frequently Asked Questions

Do I need to be a developer to run a Mostro node?

No, but you need to be comfortable with basic command line operations (typing commands, editing text files). The Docker path (Option A) is designed to be accessible.

Can I run Mostro on a Raspberry Pi?

Technically yes (using Start9 or similar), but not recommended for production due to CPU and RAM limitations. A VPS is more reliable.

Can I use Core Lightning (CLN) instead of LND?

No. Mostro currently only supports LND because it depends on LND's specific hold invoice implementation. Support for other implementations may come in the future.

How do users connect to my Mostro?

Users need a Mostro client app (like Mostro Mobile or mostro-cli) and your Mostro's public key (npub). They add your npub to their client, and the client communicates through Nostr relays. No direct connection needed.

Can I run multiple Mostro instances?

Yes, but each one needs its own Nostr key pair, LND node (or at least separate channels/liquidity), and configuration.

Is it legal?

It depends heavily on your jurisdiction. Mostro is software for peer-to-peer trading. In some jurisdictions, operating a P2P exchange may require licenses. Check local regulations and seek legal advice.

How much bandwidth does Mostro use?

Very little — mostly small Nostr events. A few GB per month is typical even with moderate volume.

What happens if my node goes offline?

Pending orders eventually expire. Active trades with locked funds continue when you come back online. If you're offline too long, users may lose trust.

Can I change my Nostr key later?

You can, but you'll lose your node's identity and reputation. Users will see it as a new Mostro. Treat your key as your brand identity.

Can I lose money running a Mostro node?

Yes, it's possible: Lightning channel funds could be at risk from bugs (rare); forced channel closures during high fee periods can be costly; VPS costs are ongoing.

Is Lightning liquidity "at risk"?

Your Lightning liquidity is yours. It's not at risk from Mostro itself — hold invoices are temporary locks. However, standard Lightning Network risks apply (forced closures, stuck channels, bugs).

When will I break even?

It depends on your costs and trading volume. With $20/month in costs and 0.6% fee, you need ~$5,000/month in trades to cover costs (before the development fee). Most communities take 3–6 months to build significant volume.

8. Security Considerations

Operating Under Authoritarian Regimes

If you operate in a country with an authoritarian government, privacy is not optional — it's a security requirement.

1. Run your Mostro node behind Tor and/or a VPN. This hides your server's IP from Nostr relays.
2. If Tor/VPN is not possible (common in developing countries with slow internet), only publish events to relays you own or trust.
3. Be very careful about which relays you use. In the future, governments could create Nostr relays specifically to collect IP addresses.
4. Consider your Lightning node's privacy as well. Running LND behind Tor is possible and recommended in sensitive environments.

9. Troubleshooting

Mostro won't start

"Configuration error: dev_fee_percentage below minimum"

Set dev_fee_percentage to at least 0.10 in settings.toml.

Configuration file or database not found

Make sure the -d flag points to the directory containing settings.toml. For Docker Hub: verify that ~/mostro-config/settings.toml exists.

"Failed to connect to LND"

• Verify LND is running: lncli getinfo
• Check that lnd_grpc_host matches your LND address
• Verify tls.cert and admin.macaroon paths are correct
• Docker + LND on host: use host.docker.internal

Connection problems

Mostro starts but doesn't connect to relays

• Check relay URLs (must start with wss://)
• Make sure your VPS firewall allows outbound connections on port 443
• Try different relays — some may be temporarily down

Trade problems

Orders don't appear in clients

• Check relay connections in the logs
• Make sure clients use the same relays as your node

Payments failing

• Check liquidity: lncli listchannels
• Make sure you have enough outbound capacity
• Check the max_routing_fee setting

Database problems

Database locked errors

ps aux | grep mostrod
# If multiple processes, kill the extras:
kill <PID>

Getting help

1. Check the logs first — most errors explain what went wrong
2. Telegram (Developers): @mostro_dev
3. Telegram (Community): @MostroP2P
4. GitHub Issues: github.com/MostroP2P/mostro/issues
5. DeepWiki: deepwiki.com/MostroP2P/mostro

When asking for help, always include: your Mostro version, relevant log output, and what you've already tried.

Appendix: Quick Reference

Important File Locations

Essential Commands

# Docker
docker logs -f mostro         # View logs
docker restart mostro          # Restart
docker stop mostro             # Stop

# Native (systemd)
systemctl start mostro         # Start
systemctl stop mostro          # Stop
systemctl restart mostro       # Restart
systemctl status mostro        # View status
journalctl -u mostro -f        # View logs

# Database
sqlite3 mostro.db "SELECT COUNT(*) FROM orders;"                           # Total orders
sqlite3 mostro.db "SELECT COUNT(*) FROM orders WHERE status='success';"    # Successful trades
sqlite3 mostro.db "SELECT SUM(fee + dev_fee) FROM orders WHERE status='success';"  # Total fees

Recommended Configuration for New Nodes

[mostro]
fee = 0.006
max_order_amount = 500000
min_payment_amount = 1000
expiration_hours = 24
expiration_seconds = 900
pow = 0
dev_fee_percentage = 0.30
fiat_currencies_accepted = ['USD']  # Change to your local currency

[nostr]
relays = [
  'wss://relay.mostro.network',
  'wss://nos.lol',
  'wss://relay.nostr.band'
]