Ejecutando Tu Propio Nodo Mostro

Mostro v0.19.2 — Guía de la Comunidad · Octubre de 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)
• Un archivo mostro.macaroon dedicado (un token de autenticación con solo los permisos que Mostro necesita, ver abajo)
• La dirección gRPC (típicamente https://127.0.0.1:10009 si está en la misma máquina)

Genera un macaroon dedicado para Mostro. No le des a Mostro tu admin.macaroon: otorga control total sobre tu nodo y sus fondos. Crea un macaroon que tenga únicamente los permisos que Mostro usa (leer info del nodo, crear/liquidar/cancelar hold invoices, enviar y rastrear pagos).

Primero elige un root key ID que no esté en uso. Revocar un macaroon revoca todos los macaroons que comparten su ID, así que reutilizar uno se llevaría credenciales ajenas. El ID 0 pertenece a los macaroons propios de LND, así que elige un número libre distinto de cero y anótalo:

lncli listmacaroonids

Luego crea el macaroon con el ID que elegiste (7 en este ejemplo, sustituye por el tuyo):

lncli bakemacaroon --root_key_id 7 \
  --save_to /root/.lnd/data/chain/bitcoin/mainnet/mostro.macaroon \
  info:read invoices:read invoices:write offchain:read offchain:write

Este macaroon no puede abrir ni cerrar canales, mover fondos on-chain ni cambiar la configuración de tu nodo. Si alguna vez se filtra, revócalo con lncli deletemacaroonid 7, usando el mismo ID con el que lo creaste, y genera uno nuevo.

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.19.2/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/mostro.macaroon ~/mostro-config/lnd/mostro.macaroon

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

• /root/.lnd/tls.cert
• /root/.lnd/data/chain/bitcoin/mainnet/mostro.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/mostro.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"  # mostrod siempre usa <directorio-de-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/mostro.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.19.2

Si LND está en un servidor diferente:

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

Paso 11: Revisar los logs

docker logs -f mostro

Busca estos mensajes:

• Settings correctly loaded! — La configuración es válida
• Transport: nip44 (protocol v2, event kind 14) — Protocolo en uso (ver 4.8)
• Connected to 'wss://...' — Relay Nostr establecido
• Recorded Lightning node identity <pubkey> — LND alcanzado (solo el primer arranque)

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

Alternativa: Docker Compose

En lugar de un comando docker run largo, puedes describir el contenedor en un archivo compose. Corre la misma imagen con la misma configuración, y actualizar se reduce a cambiar el tag en una línea. Crea ~/mostro-docker/compose.yml:

mkdir -p ~/mostro-docker
nano ~/mostro-docker/compose.yml

services:
  mostro:
    image: mostrop2p/mostro:v0.19.2
    container_name: mostro
    restart: unless-stopped
    extra_hosts:
      - "host.docker.internal:host-gateway"  # solo si LND corre en este VPS
    volumes:
      - ${HOME}/mostro-config:/config

Levántalo y sigue los logs:

docker compose -f ~/mostro-docker/compose.yml up -d
docker compose -f ~/mostro-docker/compose.yml logs -f mostro

Elige uno: docker run o compose, no ambos. Para actualizar cualquiera de los dos, ve a 5.5.

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.

    extra_hosts:
      - "host.docker.internal:host-gateway"

Paso 8: Construir la imagen Docker

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

Paso 9: Iniciar Mostro

# Inicia Mostro y el relay incluido. `make docker-up` a secas también
# inicia la imagen StartOS, que no necesitas en una VPS.
docker compose -f docker/compose.yml up -d mostro nostr-relay

# Ver estado
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 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.

Mantener la clave fuera de settings.toml

Mostro también lee la clave desde la variable de entorno MOSTRO_NSEC_PRIVKEY. La precedencia es: variable de entorno, luego <directorio-de-config>/.env, luego settings.toml.

# ~/mostro-config/.env  (chmod 600) — se carga automáticamente al arrancar
MOSTRO_NSEC_PRIVKEY=nsec1...

# Docker
docker run -e MOSTRO_NSEC_PRIVKEY=nsec1... ...

# Unidad systemd
Environment="MOSTRO_NSEC_PRIVKEY=nsec1..."

Dejar nsec_privkey en settings.toml sigue funcionando. Si usas el archivo .env, respáldalo con el mismo cuidado que la configuración.

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
max_orders_per_response = 10
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.
• max_orders_per_response: Cantidad máxima de órdenes que Mostro devuelve en una sola consulta. Si un usuario acumula más órdenes que este límite (por ejemplo al restaurar su sesión desde el cliente móvil), recibirá un error cant-do: too_many_requests y no podrá recuperar sus órdenes. Si tus usuarios operan frecuentemente, sube este valor (por ejemplo 50 o 100). El valor por defecto de 10 puede ser insuficiente.
• 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  # Tiempo que tiene el tomador para pagar la factura o agregar una de cobro (5 min)

4.6 Anti-Spam

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

4.7 Interfaz RPC de Administración (Opcional)

[rpc]
enabled = false
listen_address = "127.0.0.1"
port = 50051
# auth_token = "una-cadena-larga-y-aleatoria"

Esta interfaz gRPC es para herramientas del operador: grpcurl, y mostro-cli para el modo mantenimiento (admsetmaintenance, admmaintenancestatus, admcancelpending). Mostrix no la usa: trabaja sobre Nostr, así que no necesitas RPC para resolver disputas.

4.8 Protocolo de Transporte

Un nodo Mostro habla un solo protocolo, y se elige aquí:

[mostro]
transport = "nip44"

Tu nodo anuncia qué protocolo habla en su evento de info kind 38385, así que los clientes compatibles eligen el formato por su cuenta. Mostro Mobile, Mostrix y mostro-cli soportan v2.

El transporte v2 también permite un filtro anti-spam más fino que el de 4.6. pow aplica a todos los mensajes, mientras que pow_first_contact aplica solo a remitentes que no forman parte de una operación activa y se verifica antes de descifrar. Así las operaciones en curso siguen siendo baratas y a los desconocidos les cuesta trabajo real:

[mostro]
pow = 0                  # operaciones en curso
pow_first_contact = 16   # órdenes y tomas nuevas de claves desconocidas

4.9 Límites de Seguridad Lightning

Estos ajustes de [lightning] limitan cuánto tiempo pueden quedar bloqueados tus canales y cuántos pagos pueden estar sin resolver a la vez. Todos tienen valor por defecto, así que un archivo de configuración de una versión anterior sigue arrancando, pero una plantilla nueva los incluye y vale la pena conocerlos.

[lightning]
max_final_cltv_expiry_delta = 144
escrow_deadline_margin_blocks = 24
max_inflight_payouts = 100
max_inflight_payouts_per_destination = 10
payment_cltv_limit = 1008
allow_node_change = false

Nota también que max_routing_fee, en el bloque [mostro], ahora es 0.002 (0.2%) por defecto.

4.10 Fuentes de Precio de Bitcoin

Mostro necesita una tasa BTC/fiat para cotizar las órdenes. Sin un bloque [price] usa una sola fuente, Yadio, a través del ya deprecado bitcoin_price_api_url. Agregar el bloque te da varias fuentes, combinadas por mediana y con descarte de valores atípicos, así que una API caída o que devuelve un número malo no mueve tus precios.

[price]
update_interval_seconds = 300
max_price_staleness_seconds = 1800
outlier_threshold_pct = 5.0        # descarta una fuente así de lejos de la mediana (requiere 3+ fuentes)
provider_timeout_seconds = 10
provider_failure_threshold = 3     # fallos antes de dejar una fuente en enfriamiento
provider_failure_cooldown_seconds = 120
publish_to_nostr = true            # publica las tasas agregadas como kind 30078

[price.providers.yadio]
enabled = true
url = "https://api.yadio.io"

[price.providers.coingecko]
enabled = true
url = "https://api.coingecko.com/api/v3"
# api_key = "CG-xxxx"              # opcional, sube los límites de tasa

[price.providers.currency_api]
enabled = true
url = "https://currency-api.pages.dev/v1"
fallback_urls = ["https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1"]
except = ["CUP", "MLC"]            # solo tasa oficial, no mezclar con fuentes informales

[price.providers.blockchain]
enabled = true
url = "https://blockchain.info"

Cada fuente acepta only o except para limitar a qué monedas contribuye, y fallback_urls para espejos que se prueban cuando la URL principal falla. Una fuente habilitada a la que le falta un secreto requerido falla al arrancar en lugar de producir silenciosamente ninguna cotización.

[price.providers.nostr]
enabled = true
trusted_nodes = [
    # pubkeys hex de nodos Mostro en los que confías para publicar tasas exactas
]

Los operadores que atienden pesos cubanos pueden agregar El Toque para CUP y MLC del mercado informal. Es opt-in, limitado a esas dos monedas, y necesita un token gratuito: un El Toque habilitado sin token se niega a arrancar.

4.11 Otros Bloques Opcionales

Tres bloques más que puedes encontrar en una plantilla nueva. Ninguno es obligatorio.

Retención de eventos. Cuánto tiempo conserva Mostro cada tipo de evento antes de que expire. Omite el bloque por completo para aceptar los valores por defecto.

[expiration]
order_days = 30        # eventos de órdenes (kind 38383)
rating_days = 90       # historial de reputación (kind 38384)
dispute_days = 90      # disputas, se guardan más tiempo para auditoría (kind 38386)
fee_audit_days = 365   # transparencia de comisiones (kind 8383)
dm_days = 30           # mensajes directos de protocolo v2 (kind 14)

Fianzas anti-abuso ([anti_abuse_bond]) pueden exigir una fianza por hold invoice a los tomadores, a los creadores o a ambos, de modo que abandonar una operación tenga un costo. Está deshabilitado por defecto y todavía se despliega por fases. Lee el docs/ANTI_ABUSE_BOND.md del proyecto antes de habilitarlo en un nodo en producción.

Escrow con Cashu ([cashu]) es un modo experimental que funciona sin LND y mantiene el escrow en tokens Cashu de una sola mint. Todavía no sirve para operar de verdad, las acciones de trade siguen siendo rechazadas, y no se puede combinar con las fianzas anti-abuso. Se menciona aquí para que sepas qué es ese bloque cuando lo veas.

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

Niveles de permiso de los solvers

Un solver se puede registrar como solo lectura o con poderes completos. Los dos niveles pueden tomar una disputa y hablar con las partes, pero solo un solver read-write puede decidir a dónde va el dinero.

Un npub1... pelado sin sufijo queda como read-write por defecto, y lo mismo pasa al registrar por la interfaz RPC. Empieza a un árbitro nuevo en :read mientras aprende el proceso, y vuelve a registrarlo como read-write cuando confíes en su criterio.

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

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

# Windows
# Descarga mostrix-x86_64-pc-windows-gnu.exe desde la página de releases

Verifica la descarga antes de ejecutarla, como se explica justo abajo.

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

wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt.sig.arkanoider

# Verifica cada firma que descargaste
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Luego compara el hash del binario con el manifest
shasum -a 256 mostrix-x86_64-unknown-linux-musl
grep mostrix-x86_64-unknown-linux-musl manifest.txt

Solo cuando una firma y el hash cuadren, dale permiso de ejecución al binario y arráncalo:

chmod +x mostrix-x86_64-unknown-linux-musl
./mostrix-x86_64-unknown-linux-musl

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"        # El nsec del propio daemon — ver abajo
relays = ["wss://relay.mostro.network"]
currencies_filter = []                        # Vacío = mostrar todas las monedas
user_mode = "admin"                           # Habilitar modo admin

ADMIN_NSEC=nsec1... mostro-cli admaddsolver -n npub1solver...

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 = -1001234567890

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

Revisar tu nodo desde afuera

Tu nodo republica un evento de info (kind 38385) que se describe a sí mismo: comisiones, monedas, versión de protocolo, bandera de mantenimiento. Leerlo desde un relay es la forma más rápida de confirmar que el mundo exterior ve lo que crees que ve.

cargo install nostreq nostcat
nostreq --kinds 38385 --limit 1 --authors TU_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq

5.5 Actualizando Mostro

Actualizar reemplaza el binario mostrod y nada más: settings.toml y mostro.db se quedan donde están. Las migraciones de la base de datos se aplican solas cuando arranca la nueva versión, así que no hay pasos extra.

Antes de actualizar

1. Lee las notas de la versión a la que vas a actualizar. Tu settings.toml nunca se sobrescribe, así que una opción nueva solo tiene efecto cuando la agregas: compara tu archivo con el nuevo settings.tpl.toml.
2. Respalda la base de datos con los comandos de 5.6. Necesitas ese respaldo para volver atrás.

Docker Hub (docker run)

export MOSTRO_TAG=v0.19.2
# Primero descarga: el nodo sigue funcionando durante la descarga
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

Usa los mismos flags con los que instalaste (quita --add-host si LND está en otro servidor). Si no los recuerdas, revisa docker inspect mostro antes de borrar el contenedor.

Docker Hub (Docker Compose)

export MOSTRO_TAG=v0.19.2
COMPOSE=~/mostro-docker/compose.yml
# Apunta la línea image al nuevo tag y verifícala
sed -i "s|image: mostrop2p/mostro:.*|image: mostrop2p/mostro:$MOSTRO_TAG|" $COMPOSE
grep image: $COMPOSE
docker compose -f $COMPOSE pull
# Recrea el contenedor porque cambió la imagen
docker compose -f $COMPOSE up -d

Docker Build

cd /opt/mostro
git fetch --tags
git checkout v0.19.2
make docker-build
make docker-down
make docker-up

Nativo

cd /opt/mostro
git fetch --tags
git checkout v0.19.2
cargo build --release
install target/release/mostrod /usr/local/bin
cargo clean
systemctl restart mostro.service

Verificar la nueva versión

# Docker Hub (docker run)
docker exec mostro mostrod --version
docker logs -f mostro

# Docker Hub (Docker Compose)
docker compose -f ~/mostro-docker/compose.yml exec mostro mostrod --version
docker compose -f ~/mostro-docker/compose.yml logs -f mostro

# Docker Build
docker compose -f /opt/mostro/docker/compose.yml exec mostro mostrod --version
docker compose -f /opt/mostro/docker/compose.yml logs -f mostro

# Nativo
mostrod --version
journalctl -u mostro -f

Busca los mismos mensajes de arranque que en la primera ejecución (Paso 11 de la Opción A).

Volver a la versión anterior

Si la nueva versión se comporta mal, vuelve al tag anterior. La nueva versión puede haber migrado ya la base de datos, y un mostrod más viejo puede negarse a arrancar con ella, así que restaura el respaldo que hiciste antes de actualizar:

docker stop mostro
docker rm mostro
# reemplaza YYYYMMDD por la fecha del respaldo hecho antes de actualizar
BACKUP=/root/mostro-backups/mostro.db.YYYYMMDD
cp "$BACKUP" ~/mostro-config/mostro.db
rm -f ~/mostro-config/mostro.db-wal ~/mostro-config/mostro.db-shm
chown 1000:1000 ~/mostro-config/mostro.db
# luego arranca el tag anterior: mismo comando docker run,
# o vuelve a poner el tag viejo en compose.yml y corre docker compose up -d

Docker Build y nativo funcionan igual: haz checkout del tag anterior, recompila y restaura la base de datos antes de arrancar.

5.6 Respaldos

Archivos críticos para respaldar: settings.toml, el archivo .env si guardas ahí tu nsec (ver 4.1), y mostro.db (historial de órdenes, reputación).

# Respaldo manual — Docker Hub:
mkdir -p /root/mostro-backups
sqlite3 ~/mostro-config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +%Y%m%d)'"
cp ~/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp ~/mostro-config/.env /root/mostro-backups/env.$(date +%Y%m%d) 2>/dev/null

# Respaldo manual — Docker Build (Opción B):
sqlite3 /opt/mostro/docker/config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +%Y%m%d)'"
cp /opt/mostro/docker/config/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)

# Respaldo manual — Nativo:
sqlite3 /opt/mostro/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +%Y%m%d)'"
cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)

Respaldo diario automático (agregar al crontab con crontab -e):

# Docker Hub (Opción A):
0 3 * * * mkdir -p /root/mostro-backups && sqlite3 /root/mostro-config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +\%Y\%m\%d)'" && cp /root/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d)

# Docker Build (Opción B):
0 3 * * * mkdir -p /root/mostro-backups && sqlite3 /opt/mostro/docker/config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +\%Y\%m\%d)'" && cp /opt/mostro/docker/config/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d)

# Nativo (Opción C):
0 3 * * * mkdir -p /root/mostro-backups && sqlite3 /opt/mostro/mostro.db ".backup '/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 por comisiones: orders.fee guarda la mitad de cada parte, así que la comisión bruta del nodo es fee*2 y el dev fee se descuenta de ella
sqlite3 /ruta/a/mostro.db "SELECT SUM(fee*2) AS gross_fees, SUM(dev_fee) AS dev_fees, SUM(fee*2 - COALESCE(dev_fee, 0)) AS net_fees FROM orders WHERE status = 'success';"

5.8 Modo Mantenimiento y Cambio de Nodo Lightning

Los hold invoices, las fianzas y los pagos en vuelo pertenecen al nodo Lightning que los creó. Apuntar Mostro a otro nodo mientras algo de eso está abierto dejaría esas operaciones colgadas, así que el daemon se niega a arrancar cuando ve una identidad LND nueva con escrow todavía ligado a la anterior:

REFUSING TO START: Lightning node changed from ... but escrow is still bound to the old node

El modo mantenimiento es la forma de drenar primero. Mientras está activo se rechazan órdenes y tomas nuevas, y las operaciones abiertas siguen funcionando para que el escrow pueda liquidarse. Requiere la interfaz RPC habilitada (ver 4.7).

1. Anuncia la ventana a tus usuarios con bastante antelación.
2. Activa el modo mantenimiento: mostro-cli admsetmaintenance -e true -r "LN node migration".
3. Consulta mostro-cli admmaintenancestatus hasta que reporte drained = true. Las órdenes pendientes expiran solas; para acortar el drenaje puedes cancelar una con mostro-cli admcancelpending -o <order-id>, que libera la fianza del creador de inmediato. Avísalo antes, es la orden del usuario. Cierra las disputas de larga duración como siempre.
4. Mantén el nodo viejo en línea todo el tiempo. Todavía tiene que terminar los pagos en vuelo.
5. Detén Mostro y respalda mostro.db.
6. Apunta [lightning] al nodo nuevo y deja allow_node_change = false.
7. Arranca Mostro. Registra la pubkey nueva. Desactiva el modo mantenimiento y prueba con una orden.
8. Solo entonces da de baja el nodo viejo.

5.9 Comandos de Operador con mostro-cli

Mostrix es la forma cómoda de trabajar las disputas, pero mostro-cli cubre lo mismo desde una terminal y tiene algunos comandos que Mostrix no. Los comandos de disputa se firman con una clave Nostr que pasas como ADMIN_NSEC, y esa clave debe ser la del propio daemon o la de un solver registrado.

# Trabajo de disputas (por Nostr, necesita ADMIN_NSEC)
export ADMIN_NSEC=nsec1...
mostro-cli listdisputes
mostro-cli admtakedispute -d <dispute-id>
mostro-cli admsenddm -p <npub> -m "mensaje a una parte"
mostro-cli admsettle -o <order-id>      # liberar al comprador
mostro-cli admcancel -o <order-id>      # reembolsar al vendedor

# Registrar un árbitro, opcionalmente de solo lectura
mostro-cli admaddsolver -n npub1...:read

Otro grupo de comandos va por el gRPC de administración en lugar de Nostr, así que necesitan MOSTRO_RPC_URL y MOSTRO_RPC_TOKEN en vez de ADMIN_NSEC, y la interfaz RPC habilitada (ver 4.7).

export MOSTRO_RPC_URL=http://127.0.0.1:50051
export MOSTRO_RPC_TOKEN=tu-token-de-auth

mostro-cli admsetmaintenance -e true -r "motivo"
mostro-cli admmaintenancestatus
mostro-cli admcancelpending -o <order-id>

admcancelpending vale la pena conocerlo fuera de una migración. Cancela una orden que sigue pendiente o esperando la fianza de un tomador, avisa al creador y libera todas las fianzas de una vez. Úsalo con una orden claramente abandonada o mal cotizada, y avísale al creador antes: es su orden, y esto no es una resolución de disputa.

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. Desde v0.18.3 también hay un plazo límite para el escrow: si el nodo queda caído lo suficiente para que el hold invoice se acerque a su horizonte CLTV, LND lo cancela y el vendedor recibe el reembolso automáticamente.

¿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.

¿Puedo mover Mostro a otro nodo Lightning?

Sí, pero no editando la configuración y reiniciando. El escrow está ligado al nodo que lo creó, así que primero se drena en modo mantenimiento, y el daemon se niega a arrancar si te lo salteas. Mover el mismo nodo a otro host no es un cambio de nodo y no necesita nada especial. Mira 5.8.

8. Consideraciones de Seguridad

Mantén la Clave de tu Nodo Fuera de Alcance

Tu nsec_privkey es la identidad de tu nodo, y cualquiera que la tenga puede suplantar a tu Mostro. Prefiere pasarla por la variable de entorno MOSTRO_NSEC_PRIVKEY o por un archivo .env con chmod 600 antes que dejarla en settings.toml (ver 4.1). Tampoco la lleves en una laptop para atender disputas: registra una clave de solver aparte para eso (ver 5.2).

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

dev_fee_percentage (0.05) is below minimum (0.1)

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.

Mostro termina al arrancar con Ln node error

• 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 mostro.macaroon sean correctas
• Verifica que el macaroon tenga los permisos de 2.2
• Docker + LND en el host: usa host.docker.internal. La Opción B además necesita el mapeo extra_hosts.

REFUSING TO START: Lightning node changed

Mostro apunta a una identidad LND distinta mientras hay escrow abierto en la anterior. Reconecta el nodo viejo y drénalo antes de cambiar. Mira 5.8.

Los clientes no ven mis órdenes o no pueden escribirle a mi nodo

Revisa la línea Transport: en tus logs. Un nodo en nip44 es invisible para clientes que solo hablan protocolo v1, y un nodo en gift-wrap es invisible para clientes v2. Mira 4.8.

Los pagos fallan con "no route"

Revisa payment_cltv_limit. Debe estar al menos 576 bloques por encima de max_final_cltv_expiry_delta y no debe superar el --max-cltv-expiry de tu LND. Mira 4.9.

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

Un usuario recibe "cant-do: too_many_requests" al restaurar sesión

Esto ocurre cuando el usuario tiene más órdenes (históricas + activas) que el valor de max_orders_per_response en tu configuración. El cliente intenta consultar todas sus órdenes de golpe y Mostro lo rechaza. No es un ban ni un bloqueo temporal — le seguirá pasando hasta que ajustes el valor.

# En settings.toml, sube el límite:
max_orders_per_response = 50  # el default es 10, el máximo 255

El valor se guarda en un solo byte, así que 255 es el techo. Si un usuario tiene más órdenes que eso, tiene que depurar su historial en lugar de que tú sigas subiendo el límite.

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*2 - COALESCE(dev_fee, 0)) FROM orders WHERE status='success';"  # Comisiones netas que conserva el nodo

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'
]