Ejecutando Tu Propio Nodo Mostro

Mostro v0.16.3 — Guía de la Comunidad · Febrero 2026

1. ¿Qué es Mostro y por qué tu comunidad debería ejecutar uno?

Mostro es un exchange peer-to-peer de Bitcoin que permite a las personas comprar y vender Bitcoin usando monedas locales (dólares, euros, pesos — cualquier moneda) sin necesidad de proporcionar documentos de identidad (KYC). Piensa en él como un mercado descentralizado donde compradores y vendedores pueden comerciar directamente.

Funciona usando dos tecnologías:

• Lightning Network — una capa de pagos rápidos y de bajo costo para Bitcoin (piensa en ella como la vía rápida de Bitcoin para pagos pequeños y ágiles)
• Nostr — un protocolo de comunicación resistente a la censura (piensa en él como un sistema de mensajería que nadie puede apagar)

Mostro actúa como un coordinador de custodia — retiene los Bitcoin del vendedor en una "caja fuerte" temporal (llamada hold invoice) hasta que el comprador confirma que ha enviado el pago en moneda local. Mostro nunca controla realmente los fondos de nadie; solo los retiene brevemente durante la operación.

¿Por qué tu comunidad querría ejecutar un nodo Mostro?

1. Ingresos por comisiones — Cada operación te genera una comisión (0.6% por defecto). Si tu comunidad hace $10,000 en operaciones mensuales, son ~$60/mes en comisiones.
2. Trading P2P sin KYC — Los miembros de tu comunidad pueden comprar y vender Bitcoin sin proporcionar documentos de identidad. Especialmente importante en regiones con monedas inestables o regulaciones restrictivas.
3. Disputas en tu idioma — Cuando una operación sale mal, tu comunidad la resuelve, en tu idioma, entendiendo tus métodos de pago locales.
4. Independencia — Ninguna empresa puede cerrar tu exchange. Ningún gobierno puede presionar a un único operador para cerrarlo.
5. Personalización — Tú eliges qué monedas soportar, qué métodos de pago permitir y qué comisiones cobrar.

Cómo funciona Mostro (Simplificado)

Si algo sale mal (ej: Bob dice que pagó pero Alice no lo recibió), cualquiera de las partes puede abrir una disputa, y los árbitros asignados de tu comunidad investigan y resuelven.

2. Prerequisitos — Lo que necesitas antes de empezar

2.1 Un Servidor (VPS)

Un VPS (Servidor Virtual Privado) es una computadora en un centro de datos que funciona 24/7. Alquilarás uno para alojar tu nodo Mostro.

Especificaciones mínimas:

Costo mensual estimado: $10–$24/mes.

Proveedores populares de VPS:

• Hostinger — desde ~$7/mes (precio promocional; la renovación puede ser mayor) (KVM 2: 2 vCPU, 8GB RAM, 100GB NVMe, 8TB bandwidth) · Acepta Bitcoin
• Hetzner — €3.49-8/mes (CX23 desde €3.49, buena relación calidad-precio, con base en la UE)
• Digital Ocean — $24/mes (4GB RAM, 2 CPUs, 80GB SSD) o $32/mes (4GB RAM, 2 Intel CPUs, 120GB NVMe)
• OVH — ~$6-12/mes
• Linode/Akamai — $12/mes
• Lunanode — Acepta pagos en Bitcoin

Necesitas sentirte cómodo conectándote a un servidor por SSH. Si nunca lo has hecho, busca un tutorial sobre "Conectarse por SSH a un VPS" — es más simple de lo que parece.

2.2 Un Nodo Lightning Network (LND)

Lightning Network es un sistema "capa 2" construido sobre Bitcoin que permite pagos rápidos y baratos. Para ejecutar Mostro, necesitas un nodo LND (Lightning Network Daemon) — el software Lightning específico con el que Mostro trabaja.

Tus opciones:

Lo que necesitas de tu nodo LND:

• El archivo tls.cert (un certificado de seguridad)
• El archivo admin.macaroon (un token de autenticación)
• La dirección gRPC (típicamente https://127.0.0.1:10009 si está en la misma máquina)

2.3 Liquidez Lightning

Para facilitar operaciones, tu nodo Lightning necesita canales con Bitcoin en ellos. Piensa en los canales Lightning como túneles de pago pre-financiados. El Bitcoin dentro de estos canales es tu "liquidez".

¿Cuánta necesitas?

Empieza pequeño, crece incrementalmente. Comienza con lo suficiente para las necesidades iniciales de tu comunidad y monitorea el feedback. Cuando los traders reporten que las órdenes fallan por capacidad insuficiente, esa es tu señal para agregar más. Escucha a tu comunidad.

Obteniendo liquidez:

• Abre canales a nodos bien conectados (usa Lightning Network+ o Amboss para encontrar buenos pares)
• Necesitas capacidad saliente (para pagar a compradores) y capacidad entrante (para recibir de vendedores)
• Obtener liquidez entrante suele ser más difícil — considera Lightning Loop, Magma, o servicios de intercambio de canales

2.4 Claves Nostr

Tu nodo Mostro necesita su propia identidad en la red Nostr — un par de claves criptográficas con una clave pública (la dirección de tu nodo) y una clave privada (tu secreto).

Generando claves Nostr seguras localmente con rana:

# Instalar Rust (si no está instalado)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Instalar rana - generador local de claves Nostr
cargo install rana

# Generar un nuevo par de claves (con frase semilla de 12 palabras)
rana --generate 12

Rana generará tu clave privada (nsec), tu clave pública (npub) y una frase semilla de respaldo. ¡Guarda todo de forma segura! Nota: ejecutar rana sin argumentos inicia minería PoW (dificultad 10) que puede tardar minutos — usa --generate para generación instantánea. Nunca generes claves importantes usando servicios online.

2.5 Nivel de conocimiento técnico

💡 Nuestra recomendación: Si tu comunidad tiene a alguien cómodo con la línea de comandos de Linux, puede manejar la instalación con Docker. La compilación nativa requiere experiencia en administración de sistemas. La configuración del nodo Lightning es la parte más compleja — considera pedir ayuda a alguien experimentado, o usar una solución nodo-en-caja.

3. Instalación Paso a Paso

Todas las opciones de instalación comparten los mismos primeros pasos. Luego elige la opción que prefieras:

• Opción A (Docker Hub): La más rápida. Sin compilar, sin clonar. Recomendada para la mayoría.
• Opción B (Docker Build): Construyes la imagen localmente desde el repositorio.
• Opción C (Compilación nativa): Más control, mejor para sysadmins experimentados.

Todas asumen que ya tienes: ✅ Un VPS con Ubuntu · ✅ Acceso SSH · ✅ Un nodo LND funcionando.

Pasos Comunes (para las 3 opciones)

Paso 1: Conéctate a tu VPS

ssh root@TU_DIRECCION_IP_DEL_VPS

Paso 2: Actualiza el sistema

# Descargar la información más reciente de paquetes
apt update

# Instalar todas las actualizaciones disponibles
apt upgrade -y

Paso 3: Instalar Docker y Docker Compose

# Instalar Docker con el script oficial
curl -fsSL https://get.docker.com | sh

# Verificar que Docker está instalado
docker --version

# Verificar Docker Compose
docker compose version

Paso 4: Instalar herramientas adicionales

apt install -y git make

✅ Pasos comunes completados. Ahora elige tu opción de instalación:

Opción A: Docker Hub (La más rápida — Recomendada)

Ejecuta Mostro directamente desde Docker Hub sin clonar el repositorio ni compilar. Perfecto para deployments en VPS.

Paso 5: Crear directorio de configuración

mkdir -p ~/mostro-config/lnd

Paso 6: Obtener el template de configuración

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

Paso 7: Copiar credenciales LND

cp /ruta/a/tu/tls.cert ~/mostro-config/lnd/tls.cert
cp /ruta/a/tu/admin.macaroon ~/mostro-config/lnd/admin.macaroon

Si LND está en la misma máquina, las rutas típicas son:

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

Paso 8: Editar la configuración

nano ~/mostro-config/settings.toml

Cambios requeridos:

[lightning]
lnd_cert_file = '/config/lnd/tls.cert'
lnd_macaroon_file = '/config/lnd/admin.macaroon'
lnd_grpc_host = 'https://host.docker.internal:10009'  # Si LND en el mismo VPS
# O usar 'https://TU_IP_LND:10009' si LND en servidor diferente

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

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

[mostro]
fee = 0.006                    # 0.6% comisión por operación
max_order_amount = 1000000     # Orden máxima en sats
min_payment_amount = 100       # Orden mínima en sats
fiat_currencies_accepted = ['USD', 'EUR']  # Tus monedas

Guardar: Ctrl+X, luego Y, luego Enter.

Paso 9: Ajustar permisos

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

Paso 10: Ejecutar el contenedor

Si LND está en el mismo 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

Si LND está en un servidor diferente:

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

Paso 11: Revisar los logs

docker logs -f mostro

Busca estos mensajes:

• Settings correctly loaded — La configuración es válida
• Connected to LND — Conexión Lightning exitosa
• Connected to relay — Relay Nostr establecido

🎉 ¡Felicitaciones! Si ves conexiones exitosas en los logs, ¡tu nodo Mostro está funcionando!

Actualización (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

Opción B: Docker Build (Construir imagen localmente)

Paso 5: Descargar Mostro

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

Paso 6: Configurar archivos

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

Paso 7: Editar el archivo de configuración

nano config/settings.toml

Edita los mismos ajustes que en la Opción A, Paso 8.

Paso 8: Construir la imagen Docker

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

Paso 9: Iniciar Mostro

make docker-up

# Verificar
docker compose -f docker/compose.yml ps

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

🎉 ¡Felicitaciones! Si ves conexiones exitosas, ¡tu nodo Mostro está funcionando!

Opción C: Compilación Nativa (Para operadores técnicos)

Paso 5: Instalar Rust

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

Paso 6: Instalar dependencias de compilación

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

Paso 7: Descargar y compilar 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

Paso 8–10: Instalar, inicializar y limpiar

install target/release/mostrod /usr/local/bin
cargo install sqlx-cli --version 0.6.3
./init_db.sh
cargo clean  # Ahorra 2+ GB de espacio

Paso 11–12: Crear usuario y configurar

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

Edita los mismos ajustes que en la Opción A, Paso 8.

Paso 13–15: Prueba, permisos y servicio systemd

# Prueba de ejecución
/usr/local/bin/mostrod -d /opt/mostro

# Establecer permisos
chown -R mostro:mostro /opt/mostro

Crear el servicio systemd:

# /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

🎉 ¡Felicitaciones! Tu nodo Mostro está funcionando como servicio del sistema.

4. Configuración en Detalle

El archivo settings.toml controla todo sobre tu nodo Mostro.

4.1 Claves Nostr — La identidad de tu nodo

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

¿Qué relays usar?

• wss://relay.mostro.network — Relay propio de Mostro, recomendado
• wss://nos.lol — Relay confiable y bien conectado
• Agrega 3–5 relays para fiabilidad. Más relays = mejor disponibilidad pero más ancho de banda.

4.2 Comisiones — Cómo generas ingresos

[mostro]
fee = 0.006
dev_fee_percentage = 0.30

Comisión de trading (fee): Porcentaje cobrado por operación, dividido entre comprador y vendedor.

• 0.006 = 0.6% (cada parte paga 0.3%)
• 0.01 = 1.0% (cada parte paga 0.5%)
• 0 = gratis (bueno para hacer crecer tu base de usuarios)

Ejemplo: En una operación de 100,000 sats con fee = 0.006: El comprador paga 300 sats, el vendedor paga 300 sats, tu nodo gana 600 sats en total.

Comisión de desarrollo (dev_fee_percentage): Un porcentaje de tus ganancias por comisiones que va al desarrollo de Mostro.

• 0.30 = 30% (por defecto) — de 600 sats, 180 van al fondo de desarrollo
• Mínimo: 10% (0.10), Máximo: 100% (1.0)
• Lo paga tu nodo de sus ganancias, no se cobra a los usuarios
• Todos los pagos son auditables públicamente a través de eventos Nostr (kind 8383)

4.3 Límites de órdenes y monedas

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

• max_order_amount: Operación más grande en satoshis. Configúralo basándote en tu capacidad de canales Lightning.
• min_payment_amount: Operación mínima en satoshis. 1,000 o 10,000 es más práctico que 100.
• fiat_currencies_accepted: Usa códigos ISO 4217. Array vacío [] acepta todas las monedas.

4.4 Perfil del nodo (Opcional pero recomendado)

[mostro]
name = "LatAm Mostro"
about = "Exchange P2P de Bitcoin para Latinoamérica. Soporte en español."
picture = "https://ejemplo.com/tu-logo.png"
website = "https://sitio-de-tu-comunidad.com"

Estos configuran el perfil de tu Mostro en Nostr (NIP-01 kind 0 metadata). Los clientes muestran esta información para que los usuarios sepan en qué Mostro están operando.

4.5 Tiempos y expiración

[mostro]
expiration_hours = 24        # Cuánto tiempo una orden queda abierta
expiration_seconds = 900     # Tiempo para completar (15 min)
hold_invoice_expiration_window = 300  # Validez de la hold invoice (5 min)

4.6 Anti-Spam

[mostro]
pow = 0  # 0 = deshabilitado; 10-20 = moderado. Empieza con 0.

4.7 Interfaz RPC Admin (Opcional)

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

Habilítala para herramientas de administración como MostriX (interfaz de terminal) para resolución de disputas.

5. Operando Tu Nodo Mostro

5.1 Cómo funcionan las disputas

Las disputas son tu responsabilidad operativa más importante.

¿Cuándo ocurren las disputas?

• El comprador dice que pagó, el vendedor dice que no recibió
• El vendedor se rehúsa a liberar los Bitcoin después de recibir el pago
• Una de las partes deja de responder

El proceso de disputa:

1. El usuario abre una disputa — Una de las partes hace clic en "Disputa" en el cliente
2. Mostro marca la orden — El estado cambia a "Disputa", los fondos permanecen bloqueados
3. El árbitro toma el caso — Un admin asignado a tu nodo investiga
4. Investigación — Se comunica con ambas partes, solicita pruebas
5. Resolución — El árbitro decide: liberar al comprador, o devolver al vendedor

5.2 Mostrix — Tu herramienta de administración

Mostrix es un cliente basado en terminal (TUI) para resolución de disputas. Si ejecutas un nodo Mostro, necesitas Mostrix.

Opción A: Descargar binario pre-compilado (Recomendado)

Descarga la última versión para tu plataforma desde 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
# Descarga mostrix-x86_64-pc-windows-gnu.exe desde la página de releases

# Importar claves de los desarrolladores (una sola vez)
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

# Descargar manifest y firmas
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

# Verificar firmas
gpg --verify manifest.txt.sig.negrunch manifest.txt
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Verificar que el checksum coincida
shasum -a 256 mostrix-x86_64-unknown-linux-musl
# Compara la salida con el hash en manifest.txt

Opción B: Compilar desde el código fuente

Si prefieres compilar desde el código fuente o necesitas una plataforma que no está en las releases:

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

# Instalar Rust (si no está instalado)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Clonar y compilar
git clone https://github.com/MostroP2P/mostrix.git
cd mostrix
cargo build --release

# Ejecutar
./target/release/mostrix

Primera ejecución y configuración

En la primera ejecución, Mostrix genera automáticamente un archivo ~/.mostrix/settings.toml con valores por defecto sensatos, incluyendo un par de claves Nostr nuevo. Tu npub generado se mostrará en la terminal.

# Editar la configuración
nano ~/.mostrix/settings.toml

# Cambia esta línea por la pubkey de TU nodo Mostro:
mostro_pubkey = "TU_PUBKEY_MOSTRO_HEX"

Para modo admin (resolución de disputas), también configura:

# ~/.mostrix/settings.toml
mostro_pubkey = "TU_PUBKEY_MOSTRO_HEX"
nsec_privkey = "nsec1tu_clave_personal"      # Auto-generada en la primera ejecución
admin_privkey = "nsec1tu_clave_admin"        # Tu clave admin del config de Mostro
relays = ["wss://relay.mostro.network"]
currencies_filter = []                        # Vacío = mostrar todas las monedas
user_mode = "admin"                           # Habilitar modo admin

5.3 mostro-watchdog — Notificaciones de disputas en Telegram

mostro-watchdog monitorea tu nodo Mostro para disputas y envía alertas instantáneas por Telegram. Esencial para tiempos de respuesta rápidos.

Opción A: Instalación automática (Recomendada)

# Descarga y ejecuta el script de instalación
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash

Opción B: Descarga manual del binario

# 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, servidores ARM)
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

Opción C: Compilar desde código fuente

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

Configuración:

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

[mostro]
pubkey = "TU_PUBKEY_MOSTRO"

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

[telegram]
bot_token = "TU_BOT_TOKEN"
chat_id = "TU_CHAT_ID"

5.4 Monitoreo de uptime

Tu nodo necesita estar funcionando 24/7.

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

# Docker Hub (Opción A)
docker ps --filter name=mostro
docker logs -f mostro

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

5.5 Actualizando 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

Nativo:

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 Respaldos

Archivos críticos a respaldar: settings.toml (¡contiene tu clave privada Nostr!) y mostro.db (historial de órdenes, reputaciones).

# Respaldo manual — 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)

# Respaldo manual — Nativo:
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)

Respaldo diario automatizado (agregar al crontab con crontab -e):

# Docker Hub (Opción 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)

# Nativo (Opción C) / Docker Build (Opción 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 Revisando la actividad de operaciones

# Contar todas las órdenes
sqlite3 /ruta/a/mostro.db "SELECT COUNT(*) FROM orders;"

# Operaciones exitosas recientes
sqlite3 /ruta/a/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;"

# Órdenes pendientes
sqlite3 /ruta/a/mostro.db "SELECT id, fiat_code, fiat_amount, status, created_at FROM orders WHERE status = 'pending';"

# Ingresos totales por comisiones (fee del nodo + dev_fee)
sqlite3 /ruta/a/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. Desglose de Costos

Costos operativos mensuales

Costos únicos / de capital

Potencial de ingresos

Compromiso de tiempo

7. Preguntas Frecuentes

¿Necesito ser desarrollador para ejecutar un nodo Mostro?

No, pero necesitas sentirte cómodo con operaciones básicas de línea de comandos (escribir comandos, editar archivos de texto). La ruta Docker (Opción A) está diseñada para ser accesible.

¿Puedo ejecutar Mostro en una Raspberry Pi?

Técnicamente sí (usando Start9 o similar), pero no se recomienda para producción debido a la limitación de CPU y RAM. Un VPS es más confiable.

¿Puedo usar Core Lightning (CLN) en lugar de LND?

No. Mostro actualmente solo soporta LND, porque depende de la implementación específica de hold invoices de LND. El soporte para otras implementaciones podría llegar en el futuro.

¿Cómo se conectan los usuarios a mi Mostro?

Los usuarios necesitan una app cliente de Mostro (como Mostro Mobile o mostro-cli) y la clave pública de tu Mostro (npub). Agregan tu npub a su cliente, y el cliente se comunica a través de relays Nostr. No se necesita conexión directa.

¿Puedo ejecutar múltiples instancias de Mostro?

Sí, pero cada una necesita su propio par de claves Nostr, nodo LND (o al menos canales/liquidez separados), y configuración.

¿Es legal?

Depende mucho de tu jurisdicción. Mostro es software para trading peer-to-peer. En algunas jurisdicciones, operar un exchange P2P puede requerir licencias. Consulta las regulaciones locales y asesoría legal.

¿Cuánto ancho de banda usa Mostro?

Muy poco — principalmente eventos Nostr pequeños. Unos pocos GB por mes es típico incluso con volumen moderado.

¿Qué pasa si mi nodo se desconecta?

Las órdenes pendientes eventualmente expiran. Las operaciones activas con fondos bloqueados continúan cuando vuelves a estar online. Si estás offline demasiado tiempo, los usuarios pueden perder confianza.

¿Puedo cambiar mi clave Nostr después?

Puedes, pero perderás la identidad y reputación de tu nodo. Los usuarios lo verán como un Mostro nuevo. Trata tu clave como tu identidad de marca.

¿Puedo perder dinero ejecutando un nodo Mostro?

Sí, es posible: los fondos de canales Lightning podrían estar en riesgo por bugs (raro); el cierre forzado de canales durante períodos de comisiones altas puede ser costoso; los costos de VPS son continuos.

¿La liquidez Lightning está "en riesgo"?

Tu liquidez Lightning es tuya. No está en riesgo por Mostro en sí — las hold invoices son bloqueos temporales. Sin embargo, aplican los riesgos estándar de Lightning Network (cierres forzados, canales atascados, bugs).

¿Cuándo alcanzaré el punto de equilibrio?

Depende de tus costos y volumen de operaciones. Con $20/mes de costos y 0.6% de comisión, necesitas ~$5,000/mes en operaciones para cubrir costos (antes de la comisión de desarrollo). La mayoría de las comunidades tardan 3–6 meses en alcanzar un volumen significativo.

8. Consideraciones de Seguridad

Operando bajo regímenes autoritarios

Si operas en un país con un gobierno autoritario, la privacidad no es opcional — es un requisito de seguridad.

1. Ejecuta tu nodo Mostro detrás de Tor y/o una VPN. Esto oculta la IP de tu servidor de los relays Nostr.
2. Si Tor/VPN no es posible (común en países en desarrollo con internet lento), solo publica eventos en relays que poseas o en los que confíes.
3. Ten mucho cuidado con qué relays usas. En el futuro, los gobiernos podrían crear relays Nostr específicamente para recolectar direcciones IP.
4. Considera también la privacidad de tu nodo Lightning. Ejecutar LND detrás de Tor es posible y recomendado en entornos sensibles.

9. Solución de Problemas

Mostro no arranca

"Configuration error: dev_fee_percentage below minimum"

Establece dev_fee_percentage en al menos 0.10 en settings.toml.

Archivo de configuración o base de datos no encontrado

Asegúrate de que el flag -d apunte al directorio que contiene settings.toml. Para Docker Hub: verifica que ~/mostro-config/settings.toml exista.

"Failed to connect to LND"

• Verifica que LND esté ejecutándose: lncli getinfo
• Revisa que lnd_grpc_host coincida con la dirección de tu LND
• Verifica que las rutas de tls.cert y admin.macaroon sean correctas
• Docker + LND en host: usa host.docker.internal

Problemas de conexión

Mostro arranca pero no se conecta a los relays

• Verifica las URLs de los relays (deben empezar con wss://)
• Asegúrate de que el firewall de tu VPS permita conexiones salientes en el puerto 443
• Prueba con diferentes relays — algunos pueden estar temporalmente caídos

Problemas con operaciones

Las órdenes no aparecen en los clientes

• Verifica las conexiones a relays en los logs
• Asegúrate de que los clientes usen los mismos relays que tu nodo

Pagos fallando

• Revisa la liquidez: lncli listchannels
• Asegúrate de tener suficiente capacidad saliente
• Revisa el ajuste max_routing_fee

Problemas de base de datos

Errores de base de datos bloqueada

ps aux | grep mostrod
# Si hay múltiples procesos, elimina los extras:
kill <PID>

Obteniendo ayuda

1. Revisa los logs primero — la mayoría de los errores explican qué salió mal
2. Telegram (Desarrolladores): @mostro_dev
3. Telegram (Comunidad): @MostroP2P
4. GitHub Issues: github.com/MostroP2P/mostro/issues
5. DeepWiki: deepwiki.com/MostroP2P/mostro

Cuando pidas ayuda, siempre incluye: tu versión de Mostro, la salida relevante de los logs, y lo que ya intentaste.

Apéndice: Referencia Rápida

Ubicaciones importantes de archivos

Comandos esenciales

# Docker
docker logs -f mostro         # Ver logs
docker restart mostro          # Reiniciar
docker stop mostro             # Detener

# Nativo (systemd)
systemctl start mostro         # Iniciar
systemctl stop mostro          # Detener
systemctl restart mostro       # Reiniciar
systemctl status mostro        # Ver estado
journalctl -u mostro -f        # Ver logs

# Base de datos
sqlite3 mostro.db "SELECT COUNT(*) FROM orders;"                           # Total de órdenes
sqlite3 mostro.db "SELECT COUNT(*) FROM orders WHERE status='success';"    # Operaciones exitosas
sqlite3 mostro.db "SELECT SUM(fee + dev_fee) FROM orders WHERE status='success';"  # Total de comisiones

Configuración recomendada para nodos nuevos

[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']  # Cambia a tu moneda local

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